react-instantsearch
Version:
⚡ Lightning-fast search for React, by Algolia
29,430 lines • 1.52 MB
JavaScript
/*! React InstantSearch 7.49.1 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactInstantSearch = {}, global.React));
})(this, (function (exports, React) { 'use strict';
function _interopNamespaceDefault(e) {
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n.default = e;
return Object.freeze(n);
}
var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
var version$2 = '7.49.1';
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true });
} else obj[key] = value;
return obj;
}
function _object_spread(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(
Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
})
);
}
ownKeys.forEach(function(key) {
_define_property(target, key, source[key]);
});
}
return target;
}
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
keys.push.apply(keys, symbols);
}
return keys;
}
function _object_spread_props(target, source) {
source = source != null ? source : {};
if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
else {
ownKeys(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var events;
var hasRequiredEvents;
function requireEvents () {
if (hasRequiredEvents) return events;
hasRequiredEvents = 1;
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
function EventEmitter() {
this._events = this._events || {};
this._maxListeners = this._maxListeners || undefined;
}
events = EventEmitter;
// Backwards-compat with node 0.10.x
// EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function(n) {
if (!isNumber(n) || n < 0 || isNaN(n))
throw TypeError('n must be a positive number');
this._maxListeners = n;
return this;
};
EventEmitter.prototype.emit = function(type) {
var er, handler, len, args, i, listeners;
if (!this._events)
this._events = {};
// If there is no 'error' event listener then throw.
if (type === 'error') {
if (!this._events.error ||
(isObject(this._events.error) && !this._events.error.length)) {
er = arguments[1];
if (er instanceof Error) {
throw er; // Unhandled 'error' event
} else {
// At least give some kind of context to the user
var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
err.context = er;
throw err;
}
}
}
handler = this._events[type];
if (isUndefined(handler))
return false;
if (isFunction(handler)) {
switch (arguments.length) {
// fast cases
case 1:
handler.call(this);
break;
case 2:
handler.call(this, arguments[1]);
break;
case 3:
handler.call(this, arguments[1], arguments[2]);
break;
// slower
default:
args = Array.prototype.slice.call(arguments, 1);
handler.apply(this, args);
}
} else if (isObject(handler)) {
args = Array.prototype.slice.call(arguments, 1);
listeners = handler.slice();
len = listeners.length;
for (i = 0; i < len; i++)
listeners[i].apply(this, args);
}
return true;
};
EventEmitter.prototype.addListener = function(type, listener) {
var m;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events)
this._events = {};
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (this._events.newListener)
this.emit('newListener', type,
isFunction(listener.listener) ?
listener.listener : listener);
if (!this._events[type])
// Optimize the case of one listener. Don't need the extra array object.
this._events[type] = listener;
else if (isObject(this._events[type]))
// If we've already got an array, just append.
this._events[type].push(listener);
else
// Adding the second element, need to change to array.
this._events[type] = [this._events[type], listener];
// Check for listener leak
if (isObject(this._events[type]) && !this._events[type].warned) {
if (!isUndefined(this._maxListeners)) {
m = this._maxListeners;
} else {
m = EventEmitter.defaultMaxListeners;
}
if (m && m > 0 && this._events[type].length > m) {
this._events[type].warned = true;
console.error('(node) warning: possible EventEmitter memory ' +
'leak detected. %d listeners added. ' +
'Use emitter.setMaxListeners() to increase limit.',
this._events[type].length);
if (typeof console.trace === 'function') {
// not supported in IE 10
console.trace();
}
}
}
return this;
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.once = function(type, listener) {
if (!isFunction(listener))
throw TypeError('listener must be a function');
var fired = false;
function g() {
this.removeListener(type, g);
if (!fired) {
fired = true;
listener.apply(this, arguments);
}
}
g.listener = listener;
this.on(type, g);
return this;
};
// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener = function(type, listener) {
var list, position, length, i;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events || !this._events[type])
return this;
list = this._events[type];
length = list.length;
position = -1;
if (list === listener ||
(isFunction(list.listener) && list.listener === listener)) {
delete this._events[type];
if (this._events.removeListener)
this.emit('removeListener', type, listener);
} else if (isObject(list)) {
for (i = length; i-- > 0;) {
if (list[i] === listener ||
(list[i].listener && list[i].listener === listener)) {
position = i;
break;
}
}
if (position < 0)
return this;
if (list.length === 1) {
list.length = 0;
delete this._events[type];
} else {
list.splice(position, 1);
}
if (this._events.removeListener)
this.emit('removeListener', type, listener);
}
return this;
};
EventEmitter.prototype.removeAllListeners = function(type) {
var key, listeners;
if (!this._events)
return this;
// not listening for removeListener, no need to emit
if (!this._events.removeListener) {
if (arguments.length === 0)
this._events = {};
else if (this._events[type])
delete this._events[type];
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
for (key in this._events) {
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = {};
return this;
}
listeners = this._events[type];
if (isFunction(listeners)) {
this.removeListener(type, listeners);
} else if (listeners) {
// LIFO order
while (listeners.length)
this.removeListener(type, listeners[listeners.length - 1]);
}
delete this._events[type];
return this;
};
EventEmitter.prototype.listeners = function(type) {
var ret;
if (!this._events || !this._events[type])
ret = [];
else if (isFunction(this._events[type]))
ret = [this._events[type]];
else
ret = this._events[type].slice();
return ret;
};
EventEmitter.prototype.listenerCount = function(type) {
if (this._events) {
var evlistener = this._events[type];
if (isFunction(evlistener))
return 1;
else if (evlistener)
return evlistener.length;
}
return 0;
};
EventEmitter.listenerCount = function(emitter, type) {
return emitter.listenerCount(type);
};
function isFunction(arg) {
return typeof arg === 'function';
}
function isNumber(arg) {
return typeof arg === 'number';
}
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
function isUndefined(arg) {
return arg === void 0;
}
return events;
}
var inherits_1;
var hasRequiredInherits;
function requireInherits() {
if (hasRequiredInherits) return inherits_1;
hasRequiredInherits = 1;
function inherits(ctor, superCtor) {
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
}
inherits_1 = inherits;
return inherits_1;
}
var DerivedHelper_1;
var hasRequiredDerivedHelper;
function requireDerivedHelper() {
if (hasRequiredDerivedHelper) return DerivedHelper_1;
hasRequiredDerivedHelper = 1;
var EventEmitter = requireEvents();
var inherits = requireInherits();
/**
* A DerivedHelper is a way to create sub requests to
* Algolia from a main helper.
* @class
* @classdesc The DerivedHelper provides an event based interface for search callbacks:
* - search: when a search is triggered using the `search()` method.
* - result: when the response is retrieved from Algolia and is processed.
* This event contains a {@link SearchResults} object and the
* {@link SearchParameters} corresponding to this answer.
* @param {AlgoliaSearchHelper} mainHelper the main helper
* @param {function} fn the function to create the derived state for search
* @param {function} recommendFn the function to create the derived state for recommendations
*/ function DerivedHelper(mainHelper, fn, recommendFn) {
this.main = mainHelper;
this.fn = fn;
this.recommendFn = recommendFn;
this.lastResults = null;
this.lastRecommendResults = null;
}
inherits(DerivedHelper, EventEmitter);
/**
* Detach this helper from the main helper
* @return {undefined}
* @throws Error if the derived helper is already detached
*/ DerivedHelper.prototype.detach = function() {
this.removeAllListeners();
this.main.detachDerivedHelper(this);
};
DerivedHelper.prototype.getModifiedState = function(parameters) {
return this.fn(parameters);
};
DerivedHelper.prototype.getModifiedRecommendState = function(parameters) {
return this.recommendFn(parameters);
};
DerivedHelper_1 = DerivedHelper;
return DerivedHelper_1;
}
var escapeFacetValue_1;
var hasRequiredEscapeFacetValue;
function requireEscapeFacetValue() {
if (hasRequiredEscapeFacetValue) return escapeFacetValue_1;
hasRequiredEscapeFacetValue = 1;
/**
* Replaces a leading - with \-
* @private
* @param {any} value the facet value to replace
* @returns {any} the escaped facet value or the value if it was not a string
*/ function escapeFacetValue(value) {
if (typeof value !== 'string') return value;
return String(value).replace(/^-/, '\\-');
}
/**
* Replaces a leading \- with -
* @private
* @param {any} value the escaped facet value
* @returns {any} the unescaped facet value or the value if it was not a string
*/ function unescapeFacetValue(value) {
if (typeof value !== 'string') return value;
return value.replace(/^\\-/, '-');
}
escapeFacetValue_1 = {
escapeFacetValue: escapeFacetValue,
unescapeFacetValue: unescapeFacetValue
};
return escapeFacetValue_1;
}
function _type_of(obj) {
"@swc/helpers - typeof";
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
var merge_1;
var hasRequiredMerge;
function requireMerge() {
if (hasRequiredMerge) return merge_1;
hasRequiredMerge = 1;
function clone(value) {
if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && value !== null) {
return _merge(Array.isArray(value) ? [] : {}, value);
}
return value;
}
function isObjectOrArrayOrFunction(value) {
return typeof value === 'function' || Array.isArray(value) || Object.prototype.toString.call(value) === '[object Object]';
}
function _merge(target, source) {
if (target === source) {
return target;
}
// eslint-disable-next-line instantsearch/no-for-in
for(var key in source){
if (!Object.prototype.hasOwnProperty.call(source, key) || key === '__proto__' || key === 'constructor') {
continue;
}
var sourceVal = source[key];
var targetVal = target[key];
if (typeof targetVal !== 'undefined' && typeof sourceVal === 'undefined') {
continue;
}
if (isObjectOrArrayOrFunction(targetVal) && isObjectOrArrayOrFunction(sourceVal)) {
target[key] = _merge(targetVal, sourceVal);
} else {
target[key] = clone(sourceVal);
}
}
return target;
}
/**
* This method is like Object.assign, but recursively merges own and inherited
* enumerable keyed properties of source objects into the destination object.
*
* NOTE: this behaves like lodash/merge, but:
* - does mutate functions if they are a source
* - treats non-plain objects as plain
* - does not work for circular objects
* - treats sparse arrays as sparse
* - does not convert Array-like objects (Arguments, NodeLists, etc.) to arrays
*
* @param {Object} target The destination object.
* @param {...Object} [sources] The source objects.
* @returns {Object} Returns `object`.
*/ function merge(target) {
if (!isObjectOrArrayOrFunction(target)) {
target = {};
}
for(var i = 1, l = arguments.length; i < l; i++){
var source = arguments[i];
if (isObjectOrArrayOrFunction(source)) {
_merge(target, source);
}
}
return target;
}
merge_1 = merge;
return merge_1;
}
var objectHasKeys_1;
var hasRequiredObjectHasKeys;
function requireObjectHasKeys() {
if (hasRequiredObjectHasKeys) return objectHasKeys_1;
hasRequiredObjectHasKeys = 1;
function objectHasKeys(obj) {
return obj && Object.keys(obj).length > 0;
}
objectHasKeys_1 = objectHasKeys;
return objectHasKeys_1;
}
var omit$1;
var hasRequiredOmit;
function requireOmit() {
if (hasRequiredOmit) return omit$1;
hasRequiredOmit = 1;
// https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620
function _objectWithoutPropertiesLoose(source, excluded) {
if (source === null) return {};
var target = {};
var sourceKeys = Object.keys(source);
var key;
var i;
for(i = 0; i < sourceKeys.length; i++){
key = sourceKeys[i];
// eslint-disable-next-line no-continue
if (excluded.indexOf(key) >= 0) continue;
target[key] = source[key];
}
return target;
}
omit$1 = _objectWithoutPropertiesLoose;
return omit$1;
}
var RecommendParameters_1;
var hasRequiredRecommendParameters;
function requireRecommendParameters() {
if (hasRequiredRecommendParameters) return RecommendParameters_1;
hasRequiredRecommendParameters = 1;
/**
* RecommendParameters is the data structure that contains all the information
* usable for getting recommendations from the Algolia API. It doesn't do the
* search itself, nor does it contains logic about the parameters.
* It is an immutable object, therefore it has been created in a way that each
* changes does not change the object itself but returns a copy with the
* modification.
* This object should probably not be instantiated outside of the helper. It
* will be provided when needed.
* @constructor
* @classdesc contains all the parameters for recommendations
* @param {RecommendParametersOptions} opts the options to create the object
*/ function RecommendParameters(opts) {
opts = opts || {};
this.params = opts.params || [];
}
RecommendParameters.prototype = {
constructor: RecommendParameters,
addParams: function addParams(params) {
var newParams = this.params.slice();
newParams.push(params);
return new RecommendParameters({
params: newParams
});
},
removeParams: function removeParams(id) {
return new RecommendParameters({
params: this.params.filter(function(param) {
return param.$$id !== id;
})
});
},
addFrequentlyBoughtTogether: function addFrequentlyBoughtTogether(params) {
return this.addParams(Object.assign({}, params, {
model: 'bought-together'
}));
},
addRelatedProducts: function addRelatedProducts(params) {
return this.addParams(Object.assign({}, params, {
model: 'related-products'
}));
},
addTrendingItems: function addTrendingItems(params) {
return this.addParams(Object.assign({}, params, {
model: 'trending-items'
}));
},
addTrendingFacets: function addTrendingFacets(params) {
return this.addParams(Object.assign({}, params, {
model: 'trending-facets'
}));
},
addLookingSimilar: function addLookingSimilar(params) {
return this.addParams(Object.assign({}, params, {
model: 'looking-similar'
}));
},
_buildQueries: function _buildQueries(indexName, cache) {
return this.params.filter(function(params) {
return cache[params.$$id] === undefined;
}).map(function(params) {
var query = Object.assign({}, params, {
indexName: indexName,
// @TODO: remove this if it ever gets handled by the API
threshold: params.threshold || 0
});
delete query.$$id;
return query;
});
}
};
RecommendParameters_1 = RecommendParameters;
return RecommendParameters_1;
}
var RecommendResults_1;
var hasRequiredRecommendResults;
function requireRecommendResults() {
if (hasRequiredRecommendResults) return RecommendResults_1;
hasRequiredRecommendResults = 1;
/**
* Constructor for SearchResults
* @class
* @classdesc SearchResults contains the results of a query to Algolia using the
* {@link AlgoliaSearchHelper}.
* @param {RecommendParameters} state state that led to the response
* @param {Record<string,RecommendResultItem>} results the results from algolia client
**/ function RecommendResults(state, results) {
this._state = state;
this._rawResults = {};
// eslint-disable-next-line consistent-this
var self = this;
state.params.forEach(function(param) {
var id = param.$$id;
self[id] = results[id];
self._rawResults[id] = results[id];
});
}
RecommendResults.prototype = {
constructor: RecommendResults
};
RecommendResults_1 = RecommendResults;
return RecommendResults_1;
}
var requestBuilder_1;
var hasRequiredRequestBuilder;
function requireRequestBuilder() {
if (hasRequiredRequestBuilder) return requestBuilder_1;
hasRequiredRequestBuilder = 1;
var merge = requireMerge();
function sortObject(obj) {
return Object.keys(obj).sort().reduce(function(acc, curr) {
acc[curr] = obj[curr];
return acc;
}, {});
}
var requestBuilder = {
/**
* Get all the queries to send to the client, those queries can used directly
* with the Algolia client.
* @private
* @param {string} index The name of the index
* @param {SearchParameters} state The state from which to get the queries
* @return {object[]} The queries
*/ _getQueries: function getQueries(index, state) {
var queries = [];
// One query for the hits
queries.push({
indexName: index,
params: requestBuilder._getHitsSearchParams(state)
});
// One for each disjunctive facets
state.getRefinedDisjunctiveFacets().forEach(function(refinedFacet) {
queries.push({
indexName: index,
params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet)
});
});
// More to get the parent levels of the hierarchical facets when refined
state.getRefinedHierarchicalFacets().forEach(function(refinedFacet) {
var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);
var currentRefinement = state.getHierarchicalRefinement(refinedFacet);
var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
// If we are deeper than level 0 (starting from `beer > IPA`)
// we want to get all parent values
if (currentRefinement.length > 0 && currentRefinement[0].split(separator).length > 1) {
// We generate a map of the filters we will use for our facet values queries
var filtersMap = currentRefinement[0].split(separator).slice(0, -1).reduce(function createFiltersMap(map, segment, level) {
return map.concat({
attribute: hierarchicalFacet.attributes[level],
value: level === 0 ? segment : [
map[map.length - 1].value,
segment
].join(separator)
});
}, []);
filtersMap.forEach(function(filter, level) {
var params = requestBuilder._getDisjunctiveFacetSearchParams(state, filter.attribute, level === 0);
// Keep facet filters unrelated to current hierarchical attributes
function hasHierarchicalFacetFilter(value) {
return hierarchicalFacet.attributes.some(function(attribute) {
return attribute === value.split(':')[0];
});
}
var filteredFacetFilters = (params.facetFilters || []).reduce(function(acc, facetFilter) {
if (Array.isArray(facetFilter)) {
var filtered = facetFilter.filter(function(filterValue) {
return !hasHierarchicalFacetFilter(filterValue);
});
if (filtered.length > 0) {
acc.push(filtered);
}
}
if (typeof facetFilter === 'string' && !hasHierarchicalFacetFilter(facetFilter)) {
acc.push(facetFilter);
}
return acc;
}, []);
var parent = filtersMap[level - 1];
if (level > 0) {
params.facetFilters = filteredFacetFilters.concat(parent.attribute + ':' + parent.value);
} else if (filteredFacetFilters.length > 0) {
params.facetFilters = filteredFacetFilters;
} else {
delete params.facetFilters;
}
queries.push({
indexName: index,
params: params
});
});
}
});
return queries;
},
/**
* Get all the queries to send to the client, those queries can used directly
* with the Algolia client.
* @private
* @param {SearchParameters} state The state from which to get the queries
* @return {object[]} The queries
*/ _getCompositionQueries: function getQueries(state) {
return [
{
compositionID: state.index,
requestBody: {
params: requestBuilder._getCompositionHitsSearchParams(state)
}
}
];
},
/**
* Build search parameters used to fetch hits
* @private
* @param {SearchParameters} state The state from which to get the queries
* @return {object.<string, any>} The search parameters for hits
*/ _getHitsSearchParams: function _getHitsSearchParams(state) {
var facets = state.facets.concat(state.disjunctiveFacets).concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state)).sort();
var facetFilters = requestBuilder._getFacetFilters(state);
var numericFilters = requestBuilder._getNumericFilters(state);
var tagFilters = requestBuilder._getTagFilters(state);
var additionalParams = {};
if (facets.length > 0) {
additionalParams.facets = facets.indexOf('*') > -1 ? [
'*'
] : facets;
}
if (tagFilters.length > 0) {
additionalParams.tagFilters = tagFilters;
}
if (facetFilters.length > 0) {
additionalParams.facetFilters = facetFilters;
}
if (numericFilters.length > 0) {
additionalParams.numericFilters = numericFilters;
}
return sortObject(merge({}, state.getQueryParams(), additionalParams));
},
/**
* Build search parameters used to fetch hits
* @private
* @param {SearchParameters} state The state from which to get the queries
* @return {object.<string, any>} The search parameters for hits
*/ _getCompositionHitsSearchParams: function _getCompositionHitsSearchParams(state) {
var facets = state.facets.concat(state.disjunctiveFacets.map(function(value) {
if (state.disjunctiveFacetsRefinements && state.disjunctiveFacetsRefinements[value] && state.disjunctiveFacetsRefinements[value].length > 0) {
// only tag a disjunctiveFacet as disjunctive if it has a value selected
// this helps avoid hitting the limit of 20 disjunctive facets in the Composition API
return 'disjunctive(' + value + ')';
}
return value;
})).concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state)).sort();
var facetFilters = requestBuilder._getFacetFilters(state);
var numericFilters = requestBuilder._getNumericFilters(state);
var tagFilters = requestBuilder._getTagFilters(state);
var additionalParams = {};
if (facets.length > 0) {
additionalParams.facets = facets.indexOf('*') > -1 ? [
'*'
] : facets;
}
if (tagFilters.length > 0) {
additionalParams.tagFilters = tagFilters;
}
if (facetFilters.length > 0) {
additionalParams.facetFilters = facetFilters;
}
if (numericFilters.length > 0) {
additionalParams.numericFilters = numericFilters;
}
var params = state.getQueryParams();
delete params.highlightPreTag;
delete params.highlightPostTag;
// not a valid search parameter, it is handled in _getCompositionQueries
delete params.index;
return sortObject(merge({}, params, additionalParams));
},
/**
* Build search parameters used to fetch a disjunctive facet
* @private
* @param {SearchParameters} state The state from which to get the queries
* @param {string} facet the associated facet name
* @param {boolean} hierarchicalRootLevel ?? FIXME
* @return {object} The search parameters for a disjunctive facet
*/ _getDisjunctiveFacetSearchParams: function _getDisjunctiveFacetSearchParams(state, facet, hierarchicalRootLevel) {
var facetFilters = requestBuilder._getFacetFilters(state, facet, hierarchicalRootLevel);
var numericFilters = requestBuilder._getNumericFilters(state, facet);
var tagFilters = requestBuilder._getTagFilters(state);
var additionalParams = {
hitsPerPage: 0,
page: 0,
analytics: false,
clickAnalytics: false
};
if (tagFilters.length > 0) {
additionalParams.tagFilters = tagFilters;
}
var hierarchicalFacet = state.getHierarchicalFacetByName(facet);
if (hierarchicalFacet) {
additionalParams.facets = requestBuilder._getDisjunctiveHierarchicalFacetAttribute(state, hierarchicalFacet, hierarchicalRootLevel);
} else {
additionalParams.facets = facet;
}
if (numericFilters.length > 0) {
additionalParams.numericFilters = numericFilters;
}
if (facetFilters.length > 0) {
additionalParams.facetFilters = facetFilters;
}
return sortObject(merge({}, state.getQueryParams(), additionalParams));
},
/**
* Return the numeric filters in an algolia request fashion
* @private
* @param {SearchParameters} state the state from which to get the filters
* @param {string} [facetName] the name of the attribute for which the filters should be excluded
* @return {string[]} the numeric filters in the algolia format
*/ _getNumericFilters: function _getNumericFilters(state, facetName) {
if (state.numericFilters) {
return state.numericFilters;
}
var numericFilters = [];
Object.keys(state.numericRefinements).forEach(function(attribute) {
var operators = state.numericRefinements[attribute] || {};
Object.keys(operators).forEach(function(operator) {
var values = operators[operator] || [];
if (facetName !== attribute) {
values.forEach(function(value) {
if (Array.isArray(value)) {
var vs = value.map(function(v) {
return attribute + operator + v;
});
numericFilters.push(vs);
} else {
numericFilters.push(attribute + operator + value);
}
});
}
});
});
return numericFilters;
},
/**
* Return the tags filters depending on which format is used, either tagFilters or tagRefinements
* @private
* @param {SearchParameters} state the state from which to get the filters
* @return {string} Tag filters in a single string
*/ _getTagFilters: function _getTagFilters(state) {
if (state.tagFilters) {
return state.tagFilters;
}
return state.tagRefinements.join(',');
},
/**
* Build facetFilters parameter based on current refinements. The array returned
* contains strings representing the facet filters in the algolia format.
* @private
* @param {SearchParameters} state The state from which to get the queries
* @param {string} [facet] if set, the current disjunctive facet
* @param {boolean} [hierarchicalRootLevel] ?? FIXME
* @return {array.<string>} The facet filters in the algolia format
*/ _getFacetFilters: function _getFacetFilters(state, facet, hierarchicalRootLevel) {
var facetFilters = [];
var facetsRefinements = state.facetsRefinements || {};
Object.keys(facetsRefinements).sort().forEach(function(facetName) {
var facetValues = facetsRefinements[facetName] || [];
facetValues.slice().sort().forEach(function(facetValue) {
facetFilters.push(facetName + ':' + facetValue);
});
});
var facetsExcludes = state.facetsExcludes || {};
Object.keys(facetsExcludes).sort().forEach(function(facetName) {
var facetValues = facetsExcludes[facetName] || [];
facetValues.sort().forEach(function(facetValue) {
facetFilters.push(facetName + ':-' + facetValue);
});
});
var disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements || {};
Object.keys(disjunctiveFacetsRefinements).sort().forEach(function(facetName) {
var facetValues = disjunctiveFacetsRefinements[facetName] || [];
if (facetName === facet || !facetValues || facetValues.length === 0) {
return;
}
var orFilters = [];
facetValues.slice().sort().forEach(function(facetValue) {
orFilters.push(facetName + ':' + facetValue);
});
facetFilters.push(orFilters);
});
var hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements || {};
Object.keys(hierarchicalFacetsRefinements).sort().forEach(function(facetName) {
var facetValues = hierarchicalFacetsRefinements[facetName] || [];
var facetValue = facetValues[0];
if (facetValue === undefined) {
return;
}
var hierarchicalFacet = state.getHierarchicalFacetByName(facetName);
var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);
var attributeToRefine;
var attributesIndex;
// we ask for parent facet values only when the `facet` is the current hierarchical facet
if (facet === facetName) {
// if we are at the root level already, no need to ask for facet values, we get them from
// the hits query
if (facetValue.indexOf(separator) === -1 || !rootPath && hierarchicalRootLevel === true || rootPath && rootPath.split(separator).length === facetValue.split(separator).length) {
return;
}
if (!rootPath) {
attributesIndex = facetValue.split(separator).length - 2;
facetValue = facetValue.slice(0, facetValue.lastIndexOf(separator));
} else {
attributesIndex = rootPath.split(separator).length - 1;
facetValue = rootPath;
}
attributeToRefine = hierarchicalFacet.attributes[attributesIndex];
} else {
attributesIndex = facetValue.split(separator).length - 1;
attributeToRefine = hierarchicalFacet.attributes[attributesIndex];
}
if (attributeToRefine) {
facetFilters.push([
attributeToRefine + ':' + facetValue
]);
}
});
return facetFilters;
},
_getHitsHierarchicalFacetsAttributes: function _getHitsHierarchicalFacetsAttributes(state) {
var out = [];
return state.hierarchicalFacets.reduce(// ask for as much levels as there's hierarchical refinements
function getHitsAttributesForHierarchicalFacet(allAttributes, hierarchicalFacet) {
var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0];
// if no refinement, ask for root level
if (!hierarchicalRefinement) {
allAttributes.push(hierarchicalFacet.attributes[0]);
return allAttributes;
}
var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
var level = hierarchicalRefinement.split(separator).length;
var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);
return allAttributes.concat(newAttributes);
}, out);
},
_getDisjunctiveHierarchicalFacetAttribute: function _getDisjunctiveHierarchicalFacetAttribute(state, hierarchicalFacet, rootLevel) {
var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
if (rootLevel === true) {
var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);
var attributeIndex = 0;
if (rootPath) {
attributeIndex = rootPath.split(separator).length;
}
return [
hierarchicalFacet.attributes[attributeIndex]
];
}
var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0] || '';
// if refinement is 'beers > IPA > Flying dog',
// then we want `facets: ['beers > IPA']` as disjunctive facet (parent level values)
var parentLevel = hierarchicalRefinement.split(separator).length - 1;
return hierarchicalFacet.attributes.slice(0, parentLevel + 1);
},
getSearchForFacetQuery: function getSearchForFacetQuery(facetName, query, maxFacetHits, state) {
var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ? state.clearRefinements(facetName) : state;
var searchForFacetSearchParameters = {
facetQuery: query,
facetName: facetName
};
if (typeof maxFacetHits === 'number') {
searchForFacetSearchParameters.maxFacetHits = maxFacetHits;
}
return sortObject(merge({}, requestBuilder._getHitsSearchParams(stateForSearchForFacetValues), searchForFacetSearchParameters));
}
};
requestBuilder_1 = requestBuilder;
return requestBuilder_1;
}
function _instanceof(left, right) {
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
return !!right[Symbol.hasInstance](left);
} else return left instanceof right;
}
var defaultsPure;
var hasRequiredDefaultsPure;
function requireDefaultsPure() {
if (hasRequiredDefaultsPure) return defaultsPure;
hasRequiredDefaultsPure = 1;
// NOTE: this behaves like lodash/defaults, but doesn't mutate the target
// it also preserve keys order
defaultsPure = function defaultsPure() {
var sources = Array.prototype.slice.call(arguments);
return sources.reduceRight(function(acc, source) {
Object.keys(Object(source)).forEach(function(key) {
if (source[key] === undefined) {
return;
}
if (acc[key] !== undefined) {
// remove if already added, so that we can add it in correct order
delete acc[key];
}
acc[key] = source[key];
});
return acc;
}, {});
};
return defaultsPure;
}
var find$2;
var hasRequiredFind;
function requireFind() {
if (hasRequiredFind) return find$2;
hasRequiredFind = 1;
// @MAJOR can be replaced by native Array#find when we change support
find$2 = function find(array, comparator) {
if (!Array.isArray(array)) {
return undefined;
}
for(var i = 0; i < array.length; i++){
if (comparator(array[i])) {
return array[i];
}
}
return undefined;
};
return find$2;
}
var intersection_1;
var hasRequiredIntersection;
function requireIntersection() {
if (hasRequiredIntersection) return intersection_1;
hasRequiredIntersection = 1;
function intersection(arr1, arr2) {
return arr1.filter(function(value, index) {
return arr2.indexOf(value) > -1 && arr1.indexOf(value) === index /* skips duplicates */ ;
});
}
intersection_1 = intersection;
return intersection_1;
}
var valToNumber_1;
var hasRequiredValToNumber;
function requireValToNumber() {
if (hasRequiredValToNumber) return valToNumber_1;
hasRequiredValToNumber = 1;
function valToNumber(v) {
if (typeof v === 'number') {
return v;
} else if (typeof v === 'string') {
return parseFloat(v);
} else if (Array.isArray(v)) {
return v.map(valToNumber);
}
throw new Error('The value should be a number, a parsable string or an array of those.');
}
valToNumber_1 = valToNumber;
return valToNumber_1;
}
var isValidUserToken;
var hasRequiredIsValidUserToken;
function requireIsValidUserToken() {
if (hasRequiredIsValidUserToken) return isValidUserToken;
hasRequiredIsValidUserToken = 1;
isValidUserToken = function isValidUserToken(userToken) {
if (userToken === null) {
return false;
}
return /^[a-zA-Z0-9_-]{1,64}$/.test(userToken);
};
return isValidUserToken;
}
var RefinementList$2;
var hasRequiredRefinementList;
function requireRefinementList() {
if (hasRequiredRefinementList) return RefinementList$2;
hasRequiredRefinementList = 1;
/**
* Functions to manipulate refinement lists
*
* The RefinementList is not formally defined through a prototype but is based
* on a specific structure.
*
* @module SearchParameters.refinementList
*
* @typedef {string[]} SearchParameters.refinementList.Refinements
* @typedef {Object.<string, SearchParameters.refinementList.Refinements>} SearchParameters.refinementList.RefinementList
*/ var defaultsPure = requireDefaultsPure();
var objectHasKeys = requireObjectHasKeys();
var omit = requireOmit();
var lib = {
/**
* Adds a refinement to a RefinementList
* @param {RefinementList} refinementList the initial list
* @param {string} attribute the attribute to refine
* @param {string} value the value of the refinement, if the value is not a string it will be converted
* @return {RefinementList} a new and updated refinement list
*/ addRefinement: function addRefinement(refinementList, attribute, value) {
if (lib.isRefined(refinementList, attribute, value)) {
return refinementList;
}
var valueAsString = '' + value;
var facetRefinement = !refinementList[attribute] ? [
valueAsString
] : refinementList[attribute].concat(valueAsString);
var mod = {};
mod[attribute] = facetRefinement;
return defaultsPure(mod, refinementList);
},
/**
* Removes refinement(s) for an attribute:
* - if the value is specified removes the refinement for the value on the attribute
* - if no value is specified removes all the refinements for this attribute
* @param {RefinementList} refinementList the initial list
* @param {string} attribute the attribute to refine
* @param {string} [value] the value of the refinement
* @return {RefinementList} a new and updated refinement lst
*/ removeRefinement: function removeRefinement(refinementList, attribute, value) {
if (value === undefined) {
// we use the "filter" form of clearRefinement, since it leaves empty values as-is
// the form with a string will remove the attribute completely
return lib.clearRefinement(refinementList, function(v, f) {
return attribute === f;
});
}
var valueAsString = '' + value;
return lib.clearRefinement(refinementList, function(v, f) {
return attribute === f && valueAsString === v;
});
},
/**
* Toggles the refinement value for an attribute.
* @param {RefinementList} refinementList the initial list
* @param {string} attribute the attribute to refine
* @param {string} value the value of the refinement
* @return {RefinementList} a new and updated list
*/ toggleRefinement: function toggleRefinement(refinementList, attribute, value) {
if (value === undefined) throw new Error('toggleRefinement should be used with a value');
if (lib.isRefined(refinementList, attribute, value)) {
return lib.removeRefinement(refinementList, attribute, value);
}
return lib.addRefinement(refinementList, attribute, value);
},
/**
* Clear all or parts of a RefinementList. Depending on the arguments, three
* kinds of behavior can happen:
* - if no attribute is provided: clears the whole list
* - if an attribute is provided as a string: clears the list for the specific attribute
* - if an attribute is provided as a function: discards the elements for which the function returns true
* @param {RefinementList} refinementList the initial list
* @param {string} [attribute] the attribute or function to discard
* @param {string} [refinementType] optional parameter to give more context to the attribute function
* @return {RefinementList} a new and updated refinement list
*/ clearRefinement: function clearRefinement(refinementList, attribute, refinementType) {
if (attribute === undefined) {
// return the same object if the list is already empty
// this is mainly for tests, as it doesn't have much impact on performance
if (!objectHasKeys(refinementList)) {
return refinementList;
}
return {};
} else if (typeof attribute === 'string') {
return omit(refinementList, [
attribute
]);
} else if (typeof attribute === 'function') {
var hasChanged = false;
var newRefinementList = Object.keys(refinementList).reduce(function(memo, key) {
var values = refinementList[key] || [];
var facetList = values.filter(function(value) {
return !attribute(value, key, refinementType);
});
if (facetList.length !== values.length) {
hasChanged = true;
}
memo[key] = facetList;
return memo;
}, {});
if (hasChanged) return newRefinementList;
return refinementList;
}
// We return nothing if the attribute is not undefined, a string or a function,
// as it is not a valid value for a refinement
return undefined;
},
/**
* Test if the refinement value is used for the attribute. If no refinement value
* is provided, test if the refinementList contains any refinement for the
* given attribute.
* @param {RefinementList} refinementList the list of refinement
* @param {string} attribute name of the attribute
* @param {string} [refinementValue] value of the filter/refinement
* @return {boolean} true if the attribute is refined, false otherwise
*/ isRefined: function isRefined(refinementList, attribute, refinementValue) {
var containsRefinements = Boolean(refinementList[attribute]) && refinementList[attribute].length > 0;
if (refinementValue === undefined || !containsRefinements) {
return containsRefinements;
}
var refinementValueAsString = '' + refinementValue;
return refinementList[attribute].indexOf(refinementValueAsString) !== -1;
}
};
RefinementList$2 = lib;
return RefinementList$2;
}
var SearchParameters_1;
var hasRequiredSearchParameters;
function requireSearchParameters() {
if (hasRequiredSearchParameters) return SearchParameters_1;
hasRequiredSearchParameters = 1;
var defaultsPure = requireDefaultsPure();
var find = requireFind();
var intersection = requireIntersection();
var merge = requireMerge();
var objectHasKeys = requireObjectHasKeys();
var omit = requireOmit();
var valToNumber = requireValToNumber();
var isValidUserToken = requireIsValidUserToken();
var RefinementList = requireRefinementList();
/**
* isEqual, but only for numeric refinement values, possible values:
* - 5
* - [5]
* - [[5]]
* - [[5,5],[4]]
* @param {any} a numeric refinement value
* @param {any} b numeric refinement value
* @return {boolean} true if the values are equal
*/ function isEqualNumericRefinement(a, b) {
if (Array.isArray(a) && Array.isArray(b)) {
return a.length === b.length && a.every(function(el, i) {
return isEqualNumericRefinement(b[i], el);
});
}
return a === b;
}
/**
* like _.find but using deep equality to be able to use it
* to find arrays.
* @private
* @param {any[]} array array to search into (elements are base or array of base)
* @param {any} searchedValue the value we're looking for (base or array of base)
* @return {any} the searched value or undefined
*/ function findArray(array, searchedValue) {
return find(array, function(currentValue) {
return isEqualNumericRefinement(currentValue, searchedValue);
});
}
/**
* The facet list is the structure used to store the list of values used to
* filter a single attribute.
* @typedef {string[]} SearchParameters.FacetList
*/ /**
* Structure to store numeric filters with the operator as the key. The supported operators
* are `=`, `>`, `<`, `>=`, `<=` and `!=`.
* @typedef {Object.<string, Array.<number|number[]>>} SearchParameters.OperatorList
*/ /**
* SearchParameters is the data structure that contains all the information
* usable for making a search to Algolia API. It doesn't do the search itself,
* nor does it contains logic about the parameters.
* It is an immutable object, therefore it has been created in a way that each
* changes does not change the object itself but returns a copy with the
* modification.
* This object should probably not be instantiated outside of the helper. It will
* be provided when needed. This object is documented for reference as you'll
* get it from events generated by the {@link AlgoliaSearchHelper}.
* If need be, instantiate the Helper from the factory function {@link SearchParameters.make}
* @constructor
* @classdesc contains all the parameters of a search
* @param {object|SearchParameters} newParameters existing parameters or partial object
* for the properties of a new SearchParameters
* @see SearchParameters.make
* @example <caption>SearchParameters of the first query in
* <a href="http://demos.algolia.com/instant-search-demo/">the instant search demo</a></caption>
{
"query": "",
"disjunctiveFacets": [
"customerReviewCount",
"category",
"salePrice_range",
"manufacturer"
],
"maxValuesPerFacet": 30,
"page": 0,
"hitsPerPage": 10,
"facets": [
"type",
"shipping"
]
}
*/ function SearchParameters(newParameters) {
var params = newParameters ? SearchParameters._parseNumbers(newParameters) : {};
if (params.userToken !== undefined && !isValidUserToken(params.userToken)) {
// eslint-disable-next-line no-console
console.warn('[algoliasearch-helper] The `userToken` parameter is invalid. This can lead to wrong analytics.\n - Format: [a-zA-Z0-9_-]{1,64}');
}
/**
* This attribute contains the list of all the conjunctive facets
* used. This list will be added to requested facets in the
* [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.
* @member {string[]}
*/ this.facets = params.facets || [];
/**
* This attribute contains the list of all the disjunctive facets
* used. This list will be added to requested facets in the
* [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.
* @member {string[]}
*/ this.disjunctiveFacets = params.disjunctiveFacets || [];
/**
* This attribute contains the list of all the hierarchical facets
* used. This list will be added to requested facets in the
* [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.
* Hierarchical facets are a sub type of disjunctive facets that
* let you filter faceted attributes hierarchically.
* @member {string[]|object[]}
*/ this.hierarchicalFacets = params.hierarchicalFacets || [];
// Refinements
/**
* This attribute contains all the filters that need to be
* applied on the conjunctive facets. Each facet must be properly
* defined in the `facets` attribute.
*
* The key is the name of the facet, and the `FacetList` contains all
* filters selected for the associated facet name.
*
* When querying algolia, the values stored in this attribute will
* be translated into the `facetFilters` attribute.
* @member {Object.<string, SearchParameters.FacetList>}
*/ this.facetsRefinements = params.facetsRefinements || {};
/**
* This attribute contains all the filters that need to be
* excluded from the conjunctive facets. Each facet must be properly
* defined in the `facets` attribute.
*
* The key is the name of the facet, and the `FacetList` contains all
* filters excluded for the associated facet name.
*
* When querying algolia, the values stored in this attribute will
* be translated into the `facetFilters` attribute.
* @member {Object.<string, SearchParameters.FacetList>}
*/ this.facetsExcludes = params.facetsExcludes || {};
/**
* This attribute contains all the filters that need to be
* applied on the disjunctive facets. Each facet must be properly
* defined in the `disjunctiveFacets` attribute.
*
* The key is the name of the facet, and the `FacetList` contains all
* filters selected for the associated facet name.
*
* When querying algolia, the values stored in this attribute will
* be translated into the `facetFilters` attribute.
* @member {Object.<string, SearchParameters.FacetList>}
*/ this.disjunctiveFacetsRefinements = params.disjunctiveFacetsRefinements || {};
/**
* This attribute contains all the filters that need to be
* applied on the numeric attributes.
*
* The key is the name of the attribute, and the value is the
* filters to apply to this attribute.
*
* When querying algolia, the values stored in this attribute will
* be translated into the `numericFilters` attribute.
* @member {Object.<string, SearchParameters.OperatorList>}
*/ this.numericRefinements = params.numericRefinements || {};
/**
* This attribute contains all the tags used to refine the query.
*
* When querying algolia, the values stored in this attribute will
* be translated into the `tagFilters` attribute.
* @member {string[]}
*/ this.tagRefinements = params.tagRefinements || [];
/**
* This attribute contains all the filters that need to be
* applied on the hierarchical facets. Each facet must be properly
* defined in the `hierarchicalFacets` attribute.
*
* The key is the name of the facet, and the `FacetList` contains all
* filters selected for the associated facet name. The FacetList values
* are structured as a string that contain the values for each level
* separated by the configured separator.
*
* When querying algolia, the values stored in this attribute will
* be translated into the `facetFilters` attribute.
* @member {Object.<string, SearchParameters.FacetList>}
*/ this.hierarchicalFacetsRefinements = params.hierarchicalFacetsRefinements || {};
// eslint-disable-next-line consistent-this
var self = this;
Object.keys(params).forEach(function(paramName) {
var isKeyKnown = SearchParameters.PARAMETERS.indexOf(paramName) !== -1;
var isValueDefined = params[paramName] !== undefined;
if (!isKeyKnown && isValueDefined) {
self[paramName] = params[paramName];
}
});
}
/**
* List all the properties in SearchParameters and therefore all the known Algolia properties
* This doesn't contain any beta/hidden features.
* @private
*/ SearchParameters.PARAMETERS = Object.keys(new SearchParameters());
// Returns a finite number or null. Used to reject Infinity/-Infinity from parseFloat.
function parseFiniteFloat(value) {
var n = parseFloat(value);
// global isFinite is safe here: n is always a number type (no string coercion risk)
return isFinite(n) ? n : null;
}
/**
* @private
* @param {object} partialState full or part of a state
* @return {object} a new object with the number keys as number
*/ SearchParameters._parseNumbers = function(partialState) {
// Do not parse numbers again in SearchParameters, they ought to be parsed already
if (_instanceof(partialState, SearchParameters)) return partialState;
var numbers = {};
var numberKeys = [
'aroundPrecision',
'aroundRadius',
'getRankingInfo',
'minWordSizefor2Typos',
'minWordSizefor1Typo',
'page',
'maxValuesPerFacet',
'distinct',
'minimumAroundRadius',
'hitsPerPage',
'minProximity'
];
numberKeys.forEach(function(k) {
var value = partialState[k];
if (typeof value === 'string') {
var parsedValue = parseFloat(value);
if (isNaN(parsedValue)) {
// originally an unparseable string like "all", keep NaN
numbers[k] = value;
} else if (!isFinite(parsedValue)) {
// Infinity/-Infinity — convert to null
numbers[k] = null;
} else {
numbers[k] = parsedValue;
}
} else if (typeof value === 'number' && !isFinite(value)) {
// Already-numeric Infinity — convert to null
numbers[k] = null;
}
});
// there's two formats of insideBoundingBox, we need to parse
// the one which is an array of float geo rectangles
if (Array.isArray(partialState.insideBoundingBox)) {
numbers.insideBoundingBox = partialState.insideBoundingBox.map(function(geoRect) {
if (Array.isArray(geoRect)) {
return geoRect.map(function(value) {
if (typeof value === 'string') {
return parseFiniteFloat(value);
}
if (typeof value === 'number' && !isFinite(value)) {
return null;
}
return value;
});
}
return geoRect;
});
}
if (partialState.numericRefinements) {
var numericRefinements = {};
Object.keys(partialState.numericRefinements).forEach(function(attribute) {
var operators = partialState.numericRefinements[attribute] || {};
numericRefinements[attribute] = {};
Object.keys(operators).forEach(function(operator) {
var values = operators[operator];
var parsedValues = values.map(function(v) {
if (Array.isArray(v)) {
return v.map(function(vPrime) {
if (typeof vPrime === 'string') {
return parseFiniteFloat(vPrime);
}
if (typeof vPrime === 'number' && !isFinite(vPrime)) {
return null;
}
return vPrime;
});
} else if (typeof v === 'string') {
return parseFiniteFloat(v);
} else if (typeof v === 'number' && !isFinite(v)) {
return null;
}
return v;
});
numericRefinements[attribute][operator] = parsedValues;
});
});
numbers.numericRefinements = numericRefinements;
}
return merge(partialState, numbers);
};
/**
* Factory for SearchParameters
* @param {object|SearchParameters} newParameters existing parameters or partial
* object for the properties of a new SearchParameters
* @return {SearchParameters} frozen instance of SearchParameters
*/ SearchParameters.make = function makeSearchParameters(newParameters) {
var instance = new SearchParameters(newParameters);
var hierarchicalFacets = newParameters.hierarchicalFacets || [];
hierarchicalFacets.forEach(function(facet) {
if (facet.rootPath) {
var currentRefinement = instance.getHierarchicalRefinement(facet.name);
if (currentRefinement.length > 0 && currentRefinement[0].indexOf(facet.rootPath) !== 0) {
instance = instance.clearRefinements(facet.name);
}
// get it again in case it has been cleared
currentRefinement = instance.getHierarchicalRefinement(facet.name);
if (currentRefinement.length === 0) {
instance = instance.toggleHierarchicalFacetRefinement(facet.name, facet.rootPath);
}
}
});
return instance;
};
/**
* Validates the new parameters based on the previous state
* @param {SearchParameters} currentState the current state
* @param {object|SearchParameters} parameters the new parameters to set
* @return {Error|null} Error if the modification is invalid, null otherwise
*/ SearchParameters.validate = function(currentState, parameters) {
var params = parameters || {};
if (currentState.tagFilters && params.tagRefinements && params.tagRefinements.length > 0) {
return new Error('[Tags] Cannot switch from the managed tag API to the advanced API. It is probably ' + 'an error, if it is really what you want, you should first clear the tags with clearTags method.');
}
if (currentState.tagRefinements.length > 0 && params.tagFilters) {
return new Error('[Tags] Cannot switch from the advanced tag API to the managed API. It is probably ' + 'an error, if it is not, you should first clear the tags with clearTags method.');
}
if (currentState.numericFilters && params.numericRefinements && objectHasKeys(params.numericRefinements)) {
return new Error("[Numeric filters] Can't switch from the advanced to the managed API. It" + ' is probably an error, if this is really what you want, you have to first' + ' clear the numeric filters.');
}
if (objectHasKeys(currentState.numericRefinements) && params.numericFilters) {
return new Error("[Numeric filters] Can't switch from the managed API to the advanced. It" + ' is probably an error, if this is really what you want, you have to first' + ' clear the numeric filters.');
}
return null;
};
SearchParameters.prototype = {
constructor: SearchParameters,
/**
* Remove all refinements (disjunctive + conjunctive + excludes + numeric filters)
* @method
* @param {undefined|string|SearchParameters.clearCallback} [attribute] optional string or function
* - If not given, means to clear all the filters.
* - If `string`, means to clear all refinements for the `attribute` named filter.
* - If `function`, means to clear all the refinements that return truthy values.
* @return {SearchParameters} new instance with filters cleared
*/ clearRefinements: function clearRefinements(attribute) {
var patch = {
numericRefinements: this._clearNumericRefinements(attribute),
facetsRefinements: RefinementList.clearRefinement(this.facetsRefinements, attribute, 'conjunctiveFacet'),
facetsExcludes: RefinementList.clearRefinement(this.facetsExcludes, attribute, 'exclude'),
disjunctiveFacetsRefinements: RefinementList.clearRefinement(this.disjunctiveFacetsRefinements, attribute, 'disjunctiveFacet'),
hierarchicalFacetsRefinements: RefinementList.clearRefinement(this.hierarchicalFacetsRefinements, attribute, 'hierarchicalFacet')
};
if (patch.numericRefinements === this.numericRefinements && patch.facetsRefinements === this.facetsRefinements && patch.facetsExcludes === this.facetsExcludes && patch.disjunctiveFacetsRefinements === this.disjunctiveFacetsRefinements && patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements) {
return this;
}
return this.setQueryParameters(patch);
},
/**
* Remove all the refined tags from the SearchParameters
* @method
* @return {SearchParameters} new instance with tags cleared
*/ clearTags: function clearTags() {
if (this.tagFilters === undefined && this.tagRefinements.length === 0) return this;
return this.setQueryParameters({
tagFilters: undefined,
tagRefinements: []
});
},
/**
* Set the index.
* @method
* @param {string} index the index name
* @return {SearchParameters} new instance
*/ setIndex: function setIndex(index) {
if (index === this.index) return this;
return this.setQueryParameters({
index: index
});
},
/**
* Query setter
* @method
* @param {string} newQuery value for the new query
* @return {SearchParameters} new instance
*/ setQuery: function setQuery(newQuery) {
if (newQuery === this.query) return this;
return this.setQueryParameters({
query: newQuery
});
},
/**
* Page setter
* @method
* @param {number} newPage new page number
* @return {SearchParameters} new instance
*/ setPage: function setPage(newPage) {
if (newPage === this.page) return this;
return this.setQueryParameters({
page: newPage
});
},
/**
* Facets setter
* The facets are the simple facets, used for conjunctive (and) faceting.
* @method
* @param {string[]} facets all the attributes of the algolia records used for conjunctive faceting
* @return {SearchParameters} new instance
*/ setFacets: function setFacets(facets) {
return this.setQueryParameters({
facets: facets
});
},
/**
* Disjunctive facets setter
* Change the list of disjunctive (or) facets the helper chan handle.
* @method
* @param {string[]} facets all the attributes of the algolia records used for disjunctive faceting
* @return {SearchParameters} new instance
*/ setDisjunctiveFacets: function setDisjunctiveFacets(facets) {
return this.setQueryParameters({
disjunctiveFacets: facets
});
},
/**
* HitsPerPage setter
* Hits per page represents the number of hits retrieved for this query
* @method
* @param {number} n number of hits retrieved per page of results
* @return {SearchParameters} new instance
*/ setHitsPerPage: function setHitsPerPage(n) {
if (this.hitsPerPage === n) return this;
return this.setQueryParameters({
hitsPerPage: n
});
},
/**
* typoTolerance setter
* Set the value of typoTolerance
* @method
* @param {string} typoTolerance new value of typoTolerance ("true", "false", "min" or "strict")
* @return {SearchParameters} new instance
*/ setTypoTolerance: function setTypoTolerance(typoTolerance) {
if (this.typoTolerance === typoTolerance) return this;
return this.setQueryParameters({
typoTolerance: typoTolerance
});
},
/**
* Add a numeric filter for a given attribute
* When value is an array, they are combined with OR
* When value is a single value, it will combined with AND
* @method
* @param {string} attribute attribute to set the filter on
* @param {string} operator operator of the filter (possible values: =, >, >=, <, <=, !=)
* @param {number | number[]} value value of the filter
* @return {SearchParameters} new instance
* @example
* // for price = 50 or 40
* state.addNumericRefinement('price', '=', [50, 40]);
* @example
* // for size = 38 and 40
* state.addNumericRefinement('size', '=', 38);
* state.addNumericRefinement('size', '=', 40);
*/ addNumericRefinement: function addNumericRefinement(attribute, operator, value) {
var val = valToNumber(value);
if (this.isNumericRefined(attribute, operator, val)) return this;
var mod = merge({}, this.numericRefinements);
mod[attribute] = merge({}, mod[attribute]);
if (mod[attribute][operator]) {
// Array copy
mod[attribute][operator] = mod[attribute][operator].slice();
// Add the element. Concat can't be used here because value can be an array.
mod[attribute][operator].push(val);
} else {
mod[attribute][operator] = [
val
];
}
return this.setQueryParameters({
numericRefinements: mod
});
},
/**
* Get the list of conjunctive refinements for a single facet
* @param {string} facetName name of the attribute used for faceting
* @return {string[]} list of refinements
*/ getConjunctiveRefinements: function getConjunctiveRefinements(facetName) {
if (!this.isConjunctiveFacet(facetName)) {
return [];
}
return this.facetsRefinements[facetName] || [];
},
/**
* Get the list of disjunctive refinements for a single facet
* @param {string} facetName name of the attribute used for faceting
* @return {string[]} list of refinements
*/ getDisjunctiveRefinements: function getDisjunctiveRefinements(facetName) {
if (!this.isDisjunctiveFacet(facetName)) {
return [];
}
return this.disjunctiveFacetsRefinements[facetName] || [];
},
/**
* Get the list of hierarchical refinements for a single facet
* @param {string} facetName name of the attribute used for faceting
* @return {string[]} list of refinements
*/ getHierarchicalRefinement: function getHierarchicalRefinement(facetName) {
// we send an array but we currently do not support multiple
// hierarchicalRefinements for a hierarchicalFacet
return this.hierarchicalFacetsRefinements[facetName] || [];
},
/**
* Get the list of exclude refinements for a single facet
* @param {string} facetName name of the attribute used for faceting
* @return {string[]} list of refinements
*/ getExcludeRefinements: function getExcludeRefinements(facetName) {
if (!this.isConjunctiveFacet(facetName)) {
return [];
}
return this.facetsExcludes[facetName] || [];
},
/**
* Remove all the numeric filter for a given (attribute, operator)
* @method
* @param {string} attribute attribute to set the filter on
* @param {string} [operator] operator of the filter (possible values: =, >, >=, <, <=, !=)
* @param {number} [number] the value to be removed
* @return {SearchParameters} new instance
*/ removeNumericRefinement: function removeNumericRefinement(attribute, operator, number) {
var paramValue = number;
if (paramValue !== undefined) {
if (!this.isNumericRefined(attribute, operator, paramValue)) {
return this;
}
return this.setQueryParameters({
numericRefinements: this._clearNumericRefinements(function(value, key) {
return key === attribute && value.op === operator && isEqualNumericRefinement(value.val, valToNumber(paramValue));
})
});
} else if (operator !== undefined) {
if (!this.isNumericRefined(attribute, operator)) return this;
return this.setQueryParameters({
numericRefinements: this._clearNumericRefinements(function(value, key) {
return key === attribute && value.op === operator;
})
});
}
if (!this.isNumericRefined(attribute)) return this;
return this.setQueryParameters({
numericRefinements: this._clearNumericRefinements(function(value, key) {
return key === attribute;
})
});
},
/**
* Get the list of numeric refinements for a single facet
* @param {string} facetName name of the attribute used for faceting
* @return {SearchParameters.OperatorList} list of refinements
*/ getNumericRefinements: function getNumericRefinements(facetName) {
return this.numericRefinements[facetName] || {};
},
/**
* Return the current refinement for the (attribute, operator)
* @param {string} attribute attribute in the record
* @param {string} operator operator applied on the refined values
* @return {Array.<number|number[]>} refined values
*/ getNumericRefinement: function getNumericRefinement(attribute, operator) {
return this.numericRefinements[attribute] && this.numericRefinements[attribute][operator];
},
/**
* Clear numeric filters.
* @method
* @private
* @param {string|SearchParameters.clearCallback} [attribute] optional string or function
* - If not given, means to clear all the filters.
* - If `string`, means to clear all refinements for the `attribute` named filter.
* - If `function`, means to clear all the refinements that return truthy values.
* @return {Object.<string, OperatorList>} new numeric refinements
*/ _clearNumericRefinements: function _clearNumericRefinements(attribute) {
if (attribute === undefined) {
if (!objectHasKeys(this.numericRefinements)) {
return this.numericRefinements;
}
return {};
} else if (typeof attribute === 'string') {
return omit(this.numericRefinements, [
attribute
]);
} else if (typeof attribute === 'function') {
var hasChanged = false;
var numericRefinements = this.numericRefinements;
var newNumericRefinements = Object.keys(numericRefinements).reduce(function(memo, key) {
var operators = numericRefinements[key];
var operatorList = {};
operators = operators || {};
Object.keys(operators).forEach(function(operator) {
var values = operators[operator] || [];
var outValues = [];
values.forEach(function(value) {
var predicateResult = attribute({
val: value,
op: operator
}, key, 'numeric');
if (!predicateResult) outValues.push(value);
});
if (outValues.length !== values.length) {
hasChanged = true;
}
operatorList[operator] = outValues;
});
memo[key] = operatorList;
return memo;
}, {});
if (hasChanged) return newNumericRefinements;
return this.numericRefinements;
}
// We return nothing if the attribute is not undefined, a string or a function,
// as it is not a valid value for a refinement
return undefined;
},
/**
* Add a facet to the facets attribute of the helper configuration, if it
* isn't already present.
* @method
* @param {string} facet facet name to add
* @return {SearchParameters} new instance
*/ addFacet: function addFacet(facet) {
if (this.isConjunctiveFacet(facet)) {
return this;
}
return this.setQueryParameters({
facets: this.facets.concat([
facet
])
});
},
/**
* Add a disjunctive facet to the disjunctiveFacets attribute of the helper
* configuration, if it isn't already present.
* @method
* @param {string} facet disjunctive facet name to add
* @return {SearchParameters} new instance
*/ addDisjunctiveFacet: function addDisjunctiveFacet(facet) {
if (this.isDisjunctiveFacet(facet)) {
return this;
}
return this.setQueryParameters({
disjunctiveFacets: this.disjunctiveFacets.concat([
facet
])
});
},
/**
* Add a hierarchical facet to the hierarchicalFacets attribute of the helper
* configuration.
* @method
* @param {object} hierarchicalFacet hierarchical facet to add
* @return {SearchParameters} new instance
* @throws will throw an error if a hierarchical facet with the same name was already declared
*/ addHierarchicalFacet: function addHierarchicalFacet(hierarchicalFacet) {
if (this.isHierarchicalFacet(hierarchicalFacet.name)) {
throw new Error('Cannot declare two hierarchical facets with the same name: `' + hierarchicalFacet.name + '`');
}
return this.setQueryParameters({
hierarchicalFacets: this.hierarchicalFacets.concat([
hierarchicalFacet
])
});
},
/**
* Add a refinement on a "normal" facet
* @method
* @param {string} facet attribute to apply the faceting on
* @param {string} value value of the attribute (will be converted to string)
* @return {SearchParameters} new instance
*/ addFacetRefinement: function addFacetRefinement(facet, value) {
if (!this.isConjunctiveFacet(facet)) {
throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
}
if (RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;
return this.setQueryParameters({
facetsRefinements: RefinementList.addRefinement(this.facetsRefinements, facet, value)
});
},
/**
* Exclude a value from a "normal" facet
* @method
* @param {string} facet attribute to apply the exclusion on
* @param {string} value value of the attribute (will be converted to string)
* @return {SearchParameters} new instance
*/ addExcludeRefinement: function addExcludeRefinement(facet, value) {
if (!this.isConjunctiveFacet(facet)) {
throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
}
if (RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;
return this.setQueryParameters({
facetsExcludes: RefinementList.addRefinement(this.facetsExcludes, facet, value)
});
},
/**
* Adds a refinement on a disjunctive facet.
* @method
* @param {string} facet attribute to apply the faceting on
* @param {string} value value of the attribute (will be converted to string)
* @return {SearchParameters} new instance
*/ addDisjunctiveFacetRefinement: function addDisjunctiveFacetRefinement(facet, value) {
if (!this.isDisjunctiveFacet(facet)) {
throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
}
if (RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;
return this.setQueryParameters({
disjunctiveFacetsRefinements: RefinementList.addRefinement(this.disjunctiveFacetsRefinements, facet, value)
});
},
/**
* addTagRefinement adds a tag to the list used to filter the results
* @param {string} tag tag to be added
* @return {SearchParameters} new instance
*/ addTagRefinement: function addTagRefinement(tag) {
if (this.isTagRefined(tag)) return this;
var modification = {
tagRefinements: this.tagRefinements.concat(tag)
};
return this.setQueryParameters(modification);
},
/**
* Remove a facet from the facets attribute of the helper configuration, if it
* is present.
* @method
* @param {string} facet facet name to remove
* @return {SearchParameters} new instance
*/ removeFacet: function removeFacet(facet) {
if (!this.isConjunctiveFacet(facet)) {
return this;
}
return this.clearRefinements(facet).setQueryParameters({
facets: this.facets.filter(function(f) {
return f !== facet;
})
});
},
/**
* Remove a disjunctive facet from the disjunctiveFacets attribute of the
* helper configuration, if it is present.
* @method
* @param {string} facet disjunctive facet name to remove
* @return {SearchParameters} new instance
*/ removeDisjunctiveFacet: function removeDisjunctiveFacet(facet) {
if (!this.isDisjunctiveFacet(facet)) {
return this;
}
return this.clearRefinements(facet).setQueryParameters({
disjunctiveFacets: this.disjunctiveFacets.filter(function(f) {
return f !== facet;
})
});
},
/**
* Remove a hierarchical facet from the hierarchicalFacets attribute of the
* helper configuration, if it is present.
* @method
* @param {string} facet hierarchical facet name to remove
* @return {SearchParameters} new instance
*/ removeHierarchicalFacet: function removeHierarchicalFacet(facet) {
if (!this.isHierarchicalFacet(facet)) {
return this;
}
return this.clearRefinements(facet).setQueryParameters({
hierarchicalFacets: this.hierarchicalFacets.filter(function(f) {
return f.name !== facet;
})
});
},
/**
* Remove a refinement set on facet. If a value is provided, it will clear the
* refinement for the given value, otherwise it will clear all the refinement
* values for the faceted attribute.
* @method
* @param {string} facet name of the attribute used for faceting
* @param {string} [value] value used to filter
* @return {SearchParameters} new instance
*/ removeFacetRefinement: function removeFacetRefinement(facet, value) {
if (!this.isConjunctiveFacet(facet)) {
throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
}
if (!RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;
return this.setQueryParameters({
facetsRefinements: RefinementList.removeRefinement(this.facetsRefinements, facet, value)
});
},
/**
* Remove a negative refinement on a facet
* @method
* @param {string} facet name of the attribute used for faceting
* @param {string} value value used to filter
* @return {SearchParameters} new instance
*/ removeExcludeRefinement: function removeExcludeRefinement(facet, value) {
if (!this.isConjunctiveFacet(facet)) {
throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
}
if (!RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;
return this.setQueryParameters({
facetsExcludes: RefinementList.removeRefinement(this.facetsExcludes, facet, value)
});
},
/**
* Remove a refinement on a disjunctive facet
* @method
* @param {string} facet name of the attribute used for faceting
* @param {string} value value used to filter
* @return {SearchParameters} new instance
*/ removeDisjunctiveFacetRefinement: function removeDisjunctiveFacetRefinement(facet, value) {
if (!this.isDisjunctiveFacet(facet)) {
throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
}
if (!RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;
return this.setQueryParameters({
disjunctiveFacetsRefinements: RefinementList.removeRefinement(this.disjunctiveFacetsRefinements, facet, value)
});
},
/**
* Remove a tag from the list of tag refinements
* @method
* @param {string} tag the tag to remove
* @return {SearchParameters} new instance
*/ removeTagRefinement: function removeTagRefinement(tag) {
if (!this.isTagRefined(tag)) return this;
var modification = {
tagRefinements: this.tagRefinements.filter(function(t) {
return t !== tag;
})
};
return this.setQueryParameters(modification);
},
/**
* Generic toggle refinement method to use with facet, disjunctive facets
* and hierarchical facets
* @param {string} facet the facet to refine
* @param {string} value the associated value
* @return {SearchParameters} new instance
* @throws will throw an error if the facet is not declared in the settings of the helper
* @deprecated since version 2.19.0, see {@link SearchParameters#toggleFacetRefinement}
*/ toggleRefinement: function toggleRefinement(facet, value) {
return this.toggleFacetRefinement(facet, value);
},
/**
* Generic toggle refinement method to use with facet, disjunctive facets
* and hierarchical facets
* @param {string} facet the facet to refine
* @param {string} value the associated value
* @return {SearchParameters} new instance
* @throws will throw an error if the facet is not declared in the settings of the helper
*/ toggleFacetRefinement: function toggleFacetRefinement(facet, value) {
if (this.isHierarchicalFacet(facet)) {
return this.toggleHierarchicalFacetRefinement(facet, value);
} else if (this.isConjunctiveFacet(facet)) {
return this.toggleConjunctiveFacetRefinement(facet, value);
} else if (this.isDisjunctiveFacet(facet)) {
return this.toggleDisjunctiveFacetRefinement(facet, value);
}
throw new Error('Cannot refine the undeclared facet ' + facet + '; it should be added to the helper options facets, disjunctiveFacets or hierarchicalFacets');
},
/**
* Switch the refinement applied over a facet/value
* @method
* @param {string} facet name of the attribute used for faceting
* @param {value} value value used for filtering
* @return {SearchParameters} new instance
*/ toggleConjunctiveFacetRefinement: function toggleConjunctiveFacetRefinement(facet, value) {
if (!this.isConjunctiveFacet(facet)) {
throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
}
return this.setQueryParameters({
facetsRefinements: RefinementList.toggleRefinement(this.facetsRefinements, facet, value)
});
},
/**
* Switch the refinement applied over a facet/value
* @method
* @param {string} facet name of the attribute used for faceting
* @param {value} value value used for filtering
* @return {SearchParameters} new instance
*/ toggleExcludeFacetRefinement: function toggleExcludeFacetRefinement(facet, value) {
if (!this.isConjunctiveFacet(facet)) {
throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
}
return this.setQueryParameters({
facetsExcludes: RefinementList.toggleRefinement(this.facetsExcludes, facet, value)
});
},
/**
* Switch the refinement applied over a facet/value
* @method
* @param {string} facet name of the attribute used for faceting
* @param {value} value value used for filtering
* @return {SearchParameters} new instance
*/ toggleDisjunctiveFacetRefinement: function toggleDisjunctiveFacetRefinement(facet, value) {
if (!this.isDisjunctiveFacet(facet)) {
throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
}
return this.setQueryParameters({
disjunctiveFacetsRefinements: RefinementList.toggleRefinement(this.disjunctiveFacetsRefinements, facet, value)
});
},
/**
* Switch the refinement applied over a facet/value
* @method
* @param {string} facet name of the attribute used for faceting
* @param {value} value value used for filtering
* @return {SearchParameters} new instance
*/ toggleHierarchicalFacetRefinement: function toggleHierarchicalFacetRefinement(facet, value) {
if (!this.isHierarchicalFacet(facet)) {
throw new Error(facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration');
}
var separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facet));
var mod = {};
var upOneOrMultipleLevel = this.hierarchicalFacetsRefinements[facet] !== undefined && this.hierarchicalFacetsRefinements[facet].length > 0 && // remove current refinement:
// refinement was 'beer > IPA', call is toggleRefine('beer > IPA'), refinement should be `beer`
(this.hierarchicalFacetsRefinements[facet][0] === value || // remove a parent refinement of the current refinement:
// - refinement was 'beer > IPA > Flying dog'
// - call is toggleRefine('beer > IPA')
// - refinement should be `beer`
this.hierarchicalFacetsRefinements[facet][0].indexOf(value + separator) === 0);
if (upOneOrMultipleLevel) {
if (value.indexOf(separator) === -1) {
// go back to root level
mod[facet] = [];
} else {
mod[facet] = [
value.slice(0, value.lastIndexOf(separator))
];
}
} else {
mod[facet] = [
value
];
}
return this.setQueryParameters({
hierarchicalFacetsRefinements: defaultsPure(mod, this.hierarchicalFacetsRefinements)
});
},
/**
* Adds a refinement on a hierarchical facet.
* @param {string} facet the facet name
* @param {string} path the hierarchical facet path
* @return {SearchParameter} the new state
* @throws Error if the facet is not defined or if the facet is refined
*/ addHierarchicalFacetRefinement: function addHierarchicalFacetRefinement(facet, path) {
if (this.isHierarchicalFacetRefined(facet)) {
throw new Error(facet + ' is already refined.');
}
if (!this.isHierarchicalFacet(facet)) {
throw new Error(facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration.');
}
var mod = {};
mod[facet] = [
path
];
return this.setQueryParameters({
hierarchicalFacetsRefinements: defaultsPure(mod, this.hierarchicalFacetsRefinements)
});
},
/**
* Removes the refinement set on a hierarchical facet.
* @param {string} facet the facet name
* @return {SearchParameter} the new state
* @throws Error if the facet is not defined or if the facet is not refined
*/ removeHierarchicalFacetRefinement: function removeHierarchicalFacetRefinement(facet) {
if (!this.isHierarchicalFacetRefined(facet)) {
return this;
}
var mod = {};
mod[facet] = [];
return this.setQueryParameters({
hierarchicalFacetsRefinements: defaultsPure(mod, this.hierarchicalFacetsRefinements)
});
},
/**
* Switch the tag refinement
* @method
* @param {string} tag the tag to remove or add
* @return {SearchParameters} new instance
*/ toggleTagRefinement: function toggleTagRefinement(tag) {
if (this.isTagRefined(tag)) {
return this.removeTagRefinement(tag);
}
return this.addTagRefinement(tag);
},
/**
* Test if the facet name is from one of the disjunctive facets
* @method
* @param {string} facet facet name to test
* @return {boolean} true if facet is a disjunctive facet
*/ isDisjunctiveFacet: function isDisjunctiveFacet(facet) {
return this.disjunctiveFacets.indexOf(facet) > -1;
},
/**
* Test if the facet name is from one of the hierarchical facets
* @method
* @param {string} facetName facet name to test
* @return {boolean} true if facetName is a hierarchical facet
*/ isHierarchicalFacet: function isHierarchicalFacet(facetName) {
return this.getHierarchicalFacetByName(facetName) !== undefined;
},
/**
* Test if the facet name is from one of the conjunctive/normal facets
* @method
* @param {string} facet facet name to test
* @return {boolean} true if facet is a conjunctive facet
*/ isConjunctiveFacet: function isConjunctiveFacet(facet) {
return this.facets.indexOf(facet) > -1;
},
/**
* Returns true if the facet is refined, either for a specific value or in
* general.
* @method
* @param {string} facet name of the attribute for used for faceting
* @param {string} value, optional value. If passed will test that this value
* is filtering the given facet.
* @return {boolean} returns true if refined
*/ isFacetRefined: function isFacetRefined(facet, value) {
if (!this.isConjunctiveFacet(facet)) {
return false;
}
return RefinementList.isRefined(this.facetsRefinements, facet, value);
},
/**
* Returns true if the facet contains exclusions or if a specific value is
* excluded.
*
* @method
* @param {string} facet name of the attribute for used for faceting
* @param {string} [value] optional value. If passed will test that this value
* is filtering the given facet.
* @return {boolean} returns true if refined
*/ isExcludeRefined: function isExcludeRefined(facet, value) {
if (!this.isConjunctiveFacet(facet)) {
return false;
}
return RefinementList.isRefined(this.facetsExcludes, facet, value);
},
/**
* Returns true if the facet contains a refinement, or if a value passed is a
* refinement for the facet.
* @method
* @param {string} facet name of the attribute for used for faceting
* @param {string} value optional, will test if the value is used for refinement
* if there is one, otherwise will test if the facet contains any refinement
* @return {boolean} true if the facet is refined
*/ isDisjunctiveFacetRefined: function isDisjunctiveFacetRefined(facet, value) {
if (!this.isDisjunctiveFacet(facet)) {
return false;
}
return RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value);
},
/**
* Returns true if the facet contains a refinement, or if a value passed is a
* refinement for the facet.
* @method
* @param {string} facet name of the attribute for used for faceting
* @param {string} value optional, will test if the value is used for refinement
* if there is one, otherwise will test if the facet contains any refinement
* @return {boolean} true if the facet is refined
*/ isHierarchicalFacetRefined: function isHierarchicalFacetRefined(facet, value) {
if (!this.isHierarchicalFacet(facet)) {
return false;
}
var refinements = this.getHierarchicalRefinement(facet);
if (!value) {
return refinements.length > 0;
}
return refinements.indexOf(value) !== -1;
},
/**
* Test if the triple (attribute, operator, value) is already refined.
* If only the attribute and the operator are provided, it tests if the
* contains any refinement value.
* @method
* @param {string} attribute attribute for which the refinement is applied
* @param {string} [operator] operator of the refinement
* @param {string} [value] value of the refinement
* @return {boolean} true if it is refined
*/ isNumericRefined: function isNumericRefined(attribute, operator, value) {
if (value === undefined && operator === undefined) {
return Boolean(this.numericRefinements[attribute]);
}
var isOperatorDefined = this.numericRefinements[attribute] && this.numericRefinements[attribute][operator] !== undefined;
if (value === undefined || !isOperatorDefined) {
return isOperatorDefined;
}
var parsedValue = valToNumber(value);
var isAttributeValueDefined = findArray(this.numericRefinements[attribute][operator], parsedValue) !== undefined;
return isOperatorDefined && isAttributeValueDefined;
},
/**
* Returns true if the tag refined, false otherwise
* @method
* @param {string} tag the tag to check
* @return {boolean} true if tag is refined
*/ isTagRefined: function isTagRefined(tag) {
return this.tagRefinements.indexOf(tag) !== -1;
},
/**
* Returns the list of all disjunctive facets refined
* @method
* @param {string} facet name of the attribute used for faceting
* @param {value} value value used for filtering
* @return {string[]} returns the list of refinements
*/ getRefinedDisjunctiveFacets: function getRefinedDisjunctiveFacets() {
// eslint-disable-next-line consistent-this
var self = this;
// attributes used for numeric filter can also be disjunctive
var disjunctiveNumericRefinedFacets = intersection(Object.keys(this.numericRefinements).filter(function(facet) {
return Object.keys(self.numericRefinements[facet]).length > 0;
}), this.disjunctiveFacets);
return Object.keys(this.disjunctiveFacetsRefinements).filter(function(facet) {
return self.disjunctiveFacetsRefinements[facet].length > 0;
}).concat(disjunctiveNumericRefinedFacets).concat(this.getRefinedHierarchicalFacets()).sort();
},
/**
* Returns the list of all disjunctive facets refined
* @method
* @param {string} facet name of the attribute used for faceting
* @param {value} value value used for filtering
* @return {string[]} returns the list of refinements
*/ getRefinedHierarchicalFacets: function getRefinedHierarchicalFacets() {
// eslint-disable-next-line consistent-this
var self = this;
return intersection(// enforce the order between the two arrays,
// so that refinement name index === hierarchical facet index
this.hierarchicalFacets.map(function(facet) {
return facet.name;
}), Object.keys(this.hierarchicalFacetsRefinements).filter(function(facet) {
return self.hierarchicalFacetsRefinements[facet].length > 0;
})).sort();
},
/**
* Returned the list of all disjunctive facets not refined
* @method
* @return {string[]} returns the list of facets that are not refined
*/ getUnrefinedDisjunctiveFacets: function getUnrefinedDisjunctiveFacets() {
var refinedFacets = this.getRefinedDisjunctiveFacets();
return this.disjunctiveFacets.filter(function(f) {
return refinedFacets.indexOf(f) === -1;
});
},
managedParameters: [
'index',
'facets',
'disjunctiveFacets',
'facetsRefinements',
'hierarchicalFacets',
'facetsExcludes',
'disjunctiveFacetsRefinements',
'numericRefinements',
'tagRefinements',
'hierarchicalFacetsRefinements'
],
getQueryParams: function getQueryParams() {
var managedParameters = this.managedParameters;
var queryParams = {};
// eslint-disable-next-line consistent-this
var self = this;
Object.keys(this).forEach(function(paramName) {
var paramValue = self[paramName];
if (managedParameters.indexOf(paramName) === -1 && paramValue !== undefined) {
queryParams[paramName] = paramValue;
}
});
return queryParams;
},
/**
* Let the user set a specific value for a given parameter. Will return the
* same instance if the parameter is invalid or if the value is the same as the
* previous one.
* @method
* @param {string} parameter the parameter name
* @param {any} value the value to be set, must be compliant with the definition
* of the attribute on the object
* @return {SearchParameters} the updated state
*/ setQueryParameter: function setParameter(parameter, value) {
if (this[parameter] === value) return this;
var modification = {};
modification[parameter] = value;
return this.setQueryParameters(modification);
},
/**
* Let the user set any of the parameters with a plain object.
* @method
* @param {object} params all the keys and the values to be updated
* @return {SearchParameters} a new updated instance
*/ setQueryParameters: function setQueryParameters(params) {
if (!params) return this;
var error = SearchParameters.validate(this, params);
if (error) {
throw error;
}
// eslint-disable-next-line consistent-this
var self = this;
var nextWithNumbers = SearchParameters._parseNumbers(params);
var previousPlainObject = Object.keys(this).reduce(function(acc, key) {
acc[key] = self[key];
return acc;
}, {});
var nextPlainObject = Object.keys(nextWithNumbers).reduce(function(previous, key) {
var isPreviousValueDefined = previous[key] !== undefined;
var isNextValueDefined = nextWithNumbers[key] !== undefined;
if (isPreviousValueDefined && !isNextValueDefined) {
return omit(previous, [
key
]);
}
if (isNextValueDefined) {
previous[key] = nextWithNumbers[key];
}
return previous;
}, previousPlainObject);
return new this.constructor(nextPlainObject);
},
/**
* Returns a new instance with the page reset. Two scenarios possible:
* the page is omitted -> return the given instance
* the page is set -> return a new instance with a page of 0
* @return {SearchParameters} a new updated instance
*/ resetPage: function resetPage() {
if (this.page === undefined) {
return this;
}
return this.setPage(0);
},
/**
* Helper function to get the hierarchicalFacet separator or the default one (`>`)
* @param {object} hierarchicalFacet the hierarchicalFacet object
* @return {string} returns the hierarchicalFacet.separator or `>` as default
*/ _getHierarchicalFacetSortBy: function _getHierarchicalFacetSortBy(hierarchicalFacet) {
return hierarchicalFacet.sortBy || [
'isRefined:desc',
'name:asc'
];
},
/**
* Helper function to get the hierarchicalFacet separator or the default one (`>`)
* @private
* @param {object} hierarchicalFacet the hierarchicalFacet object
* @return {string} returns the hierarchicalFacet.separator or `>` as default
*/ _getHierarchicalFacetSeparator: function _getHierarchicalFacetSeparator(hierarchicalFacet) {
return hierarchicalFacet.separator || ' > ';
},
/**
* Helper function to get the hierarchicalFacet prefix path or null
* @private
* @param {object} hierarchicalFacet the hierarchicalFacet object
* @return {string} returns the hierarchicalFacet.rootPath or null as default
*/ _getHierarchicalRootPath: function _getHierarchicalRootPath(hierarchicalFacet) {
return hierarchicalFacet.rootPath || null;
},
/**
* Helper function to check if we show the parent level of the hierarchicalFacet
* @private
* @param {object} hierarchicalFacet the hierarchicalFacet object
* @return {string} returns the hierarchicalFacet.showParentLevel or true as default
*/ _getHierarchicalShowParentLevel: function _getHierarchicalShowParentLevel(hierarchicalFacet) {
if (typeof hierarchicalFacet.showParentLevel === 'boolean') {
return hierarchicalFacet.showParentLevel;
}
return true;
},
/**
* Helper function to get the hierarchicalFacet by it's name
* @param {string} hierarchicalFacetName the hierarchicalFacet name
* @return {object} a hierarchicalFacet
*/ getHierarchicalFacetByName: function getHierarchicalFacetByName(hierarchicalFacetName) {
return find(this.hierarchicalFacets, function(f) {
return f.name === hierarchicalFacetName;
});
},
/**
* Get the current breadcrumb for a hierarchical facet, as an array
* @param {string} facetName Hierarchical facet name
* @return {array.<string>} the path as an array of string
*/ getHierarchicalFacetBreadcrumb: function getHierarchicalFacetBreadcrumb(facetName) {
if (!this.isHierarchicalFacet(facetName)) {
return [];
}
var refinement = this.getHierarchicalRefinement(facetName)[0];
if (!refinement) return [];
var separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facetName));
var path = refinement.split(separator);
return path.map(function(part) {
return part.trim();
});
},
toString: function toString() {
return JSON.stringify(this, null, 2);
}
};
/**
* Callback used for clearRefinement method
* @callback SearchParameters.clearCallback
* @param {OperatorList|FacetList} value the value of the filter
* @param {string} key the current attribute name
* @param {string} type `numeric`, `disjunctiveFacet`, `conjunctiveFacet`, `hierarchicalFacet` or `exclude`
* depending on the type of facet
* @return {boolean} `true` if the element should be removed. `false` otherwise.
*/ SearchParameters_1 = SearchParameters;
return SearchParameters_1;
}
var compact;
var hasRequiredCompact;
function requireCompact() {
if (hasRequiredCompact) return compact;
hasRequiredCompact = 1;
compact = function compact(array) {
if (!Array.isArray(array)) {
return [];
}
return array.filter(Boolean);
};
return compact;
}
var findIndex$1;
var hasRequiredFindIndex;
function requireFindIndex() {
if (hasRequiredFindIndex) return findIndex$1;
hasRequiredFindIndex = 1;
// @MAJOR can be replaced by native Array#findIndex when we change support
findIndex$1 = function find(array, comparator) {
if (!Array.isArray(array)) {
return -1;
}
for(var i = 0; i < array.length; i++){
if (comparator(array[i])) {
return i;
}
}
return -1;
};
return findIndex$1;
}
var formatSort;
var hasRequiredFormatSort;
function requireFormatSort() {
if (hasRequiredFormatSort) return formatSort;
hasRequiredFormatSort = 1;
var find = requireFind();
/**
* Transform sort format from user friendly notation to lodash format
* @param {string[]} sortBy array of predicate of the form "attribute:order"
* @param {string[]} [defaults] array of predicate of the form "attribute:order"
* @return {array.<string[]>} array containing 2 elements : attributes, orders
*/ formatSort = function formatSort(sortBy, defaults) {
var defaultInstructions = (defaults || []).map(function(sort) {
return sort.split(':');
});
return sortBy.reduce(function preparePredicate(out, sort) {
var sortInstruction = sort.split(':');
var matchingDefault = find(defaultInstructions, function(defaultInstruction) {
return defaultInstruction[0] === sortInstruction[0];
});
if (sortInstruction.length > 1 || !matchingDefault) {
out[0].push(sortInstruction[0]);
out[1].push(sortInstruction[1]);
return out;
}
out[0].push(matchingDefault[0]);
out[1].push(matchingDefault[1]);
return out;
}, [
[],
[]
]);
};
return formatSort;
}
var mergeNumericMax_1;
var hasRequiredMergeNumericMax;
function requireMergeNumericMax() {
if (hasRequiredMergeNumericMax) return mergeNumericMax_1;
hasRequiredMergeNumericMax = 1;
// NOTE: this behaves like lodash/defaults, but doesn't mutate the target
// it also preserve keys order and keep the highest numeric value
function mergeNumericMax() {
var sources = Array.prototype.slice.call(arguments);
return sources.reduceRight(function(acc, source) {
Object.keys(Object(source)).forEach(function(key) {
var accValue = typeof acc[key] === 'number' ? acc[key] : 0;
var sourceValue = source[key];
if (sourceValue === undefined) {
return;
}
if (sourceValue >= accValue) {
if (acc[key] !== undefined) {
// remove if already added, so that we can add it in correct order
delete acc[key];
}
acc[key] = sourceValue;
}
});
return acc;
}, {});
}
mergeNumericMax_1 = mergeNumericMax;
return mergeNumericMax_1;
}
var orderBy_1;
var hasRequiredOrderBy;
function requireOrderBy() {
if (hasRequiredOrderBy) return orderBy_1;
hasRequiredOrderBy = 1;
function compareAscending(value, other) {
if (value !== other) {
var valIsDefined = value !== undefined;
var valIsNull = value === null;
var othIsDefined = other !== undefined;
var othIsNull = other === null;
if (!othIsNull && value > other || valIsNull && othIsDefined || !valIsDefined) {
return 1;
}
if (!valIsNull && value < other || othIsNull && valIsDefined || !othIsDefined) {
return -1;
}
}
return 0;
}
/**
* @param {Array<object>} collection object with keys in attributes
* @param {Array<string>} iteratees attributes
* @param {Array<string>} orders asc | desc
* @return {Array<object>} sorted collection
*/ function orderBy(collection, iteratees, orders) {
if (!Array.isArray(collection)) {
return [];
}
if (!Array.isArray(orders)) {
orders = [];
}
var result = collection.map(function(value, index) {
return {
criteria: iteratees.map(function(iteratee) {
return value[iteratee];
}),
index: index,
value: value
};
});
result.sort(function comparer(object, other) {
var index = -1;
while(++index < object.criteria.length){
var res = compareAscending(object.criteria[index], other.criteria[index]);
if (res) {
if (index >= orders.length) {
return res;
}
if (orders[index] === 'desc') {
return -res;
}
return res;
}
}
// This ensures a stable sort in V8 and other engines.
// See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
return object.index - other.index;
});
return result.map(function(res) {
return res.value;
});
}
orderBy_1 = orderBy;
return orderBy_1;
}
var generateHierarchicalTree_1;
var hasRequiredGenerateHierarchicalTree;
function requireGenerateHierarchicalTree() {
if (hasRequiredGenerateHierarchicalTree) return generateHierarchicalTree_1;
hasRequiredGenerateHierarchicalTree = 1;
generateHierarchicalTree_1 = generateTrees;
var fv = requireEscapeFacetValue();
var find = requireFind();
var prepareHierarchicalFacetSortBy = requireFormatSort();
var orderBy = requireOrderBy();
var escapeFacetValue = fv.escapeFacetValue;
var unescapeFacetValue = fv.unescapeFacetValue;
function generateTrees(state) {
return function generate(hierarchicalFacetResult, hierarchicalFacetIndex) {
var hierarchicalFacet = state.hierarchicalFacets[hierarchicalFacetIndex];
var hierarchicalFacetRefinement = state.hierarchicalFacetsRefinements[hierarchicalFacet.name] && state.hierarchicalFacetsRefinements[hierarchicalFacet.name][0] || '';
var hierarchicalSeparator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
var hierarchicalRootPath = state._getHierarchicalRootPath(hierarchicalFacet);
var hierarchicalShowParentLevel = state._getHierarchicalShowParentLevel(hierarchicalFacet);
var sortBy = prepareHierarchicalFacetSortBy(state._getHierarchicalFacetSortBy(hierarchicalFacet));
var rootExhaustive = hierarchicalFacetResult.every(function(facetResult) {
return facetResult.exhaustive;
});
var generateTreeFn = generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel, hierarchicalFacetRefinement);
var results = hierarchicalFacetResult;
if (hierarchicalRootPath) {
results = hierarchicalFacetResult.slice(hierarchicalRootPath.split(hierarchicalSeparator).length);
}
return results.reduce(generateTreeFn, {
name: state.hierarchicalFacets[hierarchicalFacetIndex].name,
count: null,
isRefined: true,
path: null,
escapedValue: null,
exhaustive: rootExhaustive,
data: null
});
};
}
function generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel, currentRefinement) {
return function generateTree(hierarchicalTree, hierarchicalFacetResult, currentHierarchicalLevel) {
var parent = hierarchicalTree;
if (currentHierarchicalLevel > 0) {
var level = 0;
parent = hierarchicalTree;
while(level < currentHierarchicalLevel){
/**
* @type {object[]]} hierarchical data
*/ var data = parent && Array.isArray(parent.data) ? parent.data : [];
parent = find(data, function(subtree) {
return subtree.isRefined;
});
level++;
}
}
// we found a refined parent, let's add current level data under it
if (parent) {
// filter values in case an object has multiple categories:
// {
// categories: {
// level0: ['beers', 'bières'],
// level1: ['beers > IPA', 'bières > Belges']
// }
// }
//
// If parent refinement is `beers`, then we do not want to have `bières > Belges`
// showing up
var picked = Object.keys(hierarchicalFacetResult.data).map(function(facetValue) {
return [
facetValue,
hierarchicalFacetResult.data[facetValue]
];
}).filter(function(tuple) {
var facetValue = tuple[0];
return onlyMatchingTree(facetValue, parent.path || hierarchicalRootPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel);
});
parent.data = orderBy(picked.map(function(tuple) {
var facetValue = tuple[0];
var facetCount = tuple[1];
return format(facetCount, facetValue, hierarchicalSeparator, unescapeFacetValue(currentRefinement), hierarchicalFacetResult.exhaustive);
}), sortBy[0], sortBy[1]);
}
return hierarchicalTree;
};
}
// eslint-disable-next-line max-params
function onlyMatchingTree(facetValue, parentPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel) {
// we want the facetValue is a child of hierarchicalRootPath
if (hierarchicalRootPath && (facetValue.indexOf(hierarchicalRootPath) !== 0 || hierarchicalRootPath === facetValue)) {
return false;
}
// we always want root levels (only when there is no prefix path)
return !hierarchicalRootPath && facetValue.indexOf(hierarchicalSeparator) === -1 || // if there is a rootPath, being root level mean 1 level under rootPath
hierarchicalRootPath && facetValue.split(hierarchicalSeparator).length - hierarchicalRootPath.split(hierarchicalSeparator).length === 1 || // if current refinement is a root level and current facetValue is a root level,
// keep the facetValue
facetValue.indexOf(hierarchicalSeparator) === -1 && currentRefinement.indexOf(hierarchicalSeparator) === -1 || // currentRefinement is a child of the facet value
currentRefinement.indexOf(facetValue) === 0 || // facetValue is a child of the current parent, add it
facetValue.indexOf(parentPath + hierarchicalSeparator) === 0 && (hierarchicalShowParentLevel || facetValue.indexOf(currentRefinement) === 0);
}
function format(facetCount, facetValue, hierarchicalSeparator, currentRefinement, exhaustive) {
var parts = facetValue.split(hierarchicalSeparator);
return {
name: parts[parts.length - 1].trim(),
path: facetValue,
escapedValue: escapeFacetValue(facetValue),
count: facetCount,
isRefined: currentRefinement === facetValue || currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,
exhaustive: exhaustive,
data: null
};
}
return generateHierarchicalTree_1;
}
var SearchResults_1;
var hasRequiredSearchResults;
function requireSearchResults() {
if (hasRequiredSearchResults) return SearchResults_1;
hasRequiredSearchResults = 1;
var compact = requireCompact();
var defaultsPure = requireDefaultsPure();
var fv = requireEscapeFacetValue();
var find = requireFind();
var findIndex = requireFindIndex();
var formatSort = requireFormatSort();
var mergeNumericMax = requireMergeNumericMax();
var orderBy = requireOrderBy();
var escapeFacetValue = fv.escapeFacetValue;
var unescapeFacetValue = fv.unescapeFacetValue;
var generateHierarchicalTree = requireGenerateHierarchicalTree();
/**
* @typedef SearchResults.Facet
* @type {object}
* @property {string} name name of the attribute in the record
* @property {object} data the faceting data: value, number of entries
* @property {object} stats undefined unless facet_stats is retrieved from algolia
*/ /**
* @typedef SearchResults.HierarchicalFacet
* @type {object}
* @property {string} name name of the current value given the hierarchical level, trimmed.
* If root node, you get the facet name
* @property {number} count number of objects matching this hierarchical value
* @property {string} path the current hierarchical value full path
* @property {boolean} isRefined `true` if the current value was refined, `false` otherwise
* @property {HierarchicalFacet[]} data sub values for the current level
*/ /**
* @typedef SearchResults.FacetValue
* @type {object}
* @property {string} name the facet value itself
* @property {number} count times this facet appears in the results
* @property {boolean} isRefined is the facet currently selected
* @property {boolean} isExcluded is the facet currently excluded (only for conjunctive facets)
*/ /**
* @typedef Refinement
* @type {object}
* @property {string} type the type of filter used:
* `numeric`, `facet`, `exclude`, `disjunctive`, `hierarchical`
* @property {string} attributeName name of the attribute used for filtering
* @property {string} name the value of the filter
* @property {number} numericValue the value as a number. Only for numeric filters.
* @property {string} operator the operator used. Only for numeric filters.
* @property {number} count the number of computed hits for this filter. Only on facets.
* @property {boolean} exhaustive if the count is exhaustive
*/ /**
* Turn an array of attributes in an object of attributes with their position in the array as value
* @param {string[]} attributes the list of attributes in the record
* @return {object} the list of attributes indexed by attribute name
*/ function getIndices(attributes) {
var indices = {};
attributes.forEach(function(val, idx) {
indices[val] = idx;
});
return indices;
}
function assignFacetStats(dest, facetStats, key) {
if (facetStats && facetStats[key]) {
dest.stats = facetStats[key];
}
}
/**
* @typedef {Object} HierarchicalFacet
* @property {string} name
* @property {string[]} attributes
*/ /**
* @param {HierarchicalFacet[]} hierarchicalFacets All hierarchical facets
* @param {string} hierarchicalAttributeName The name of the hierarchical attribute
* @return {HierarchicalFacet} The hierarchical facet matching the attribute name
*/ function findMatchingHierarchicalFacetFromAttributeName(hierarchicalFacets, hierarchicalAttributeName) {
return find(hierarchicalFacets, function facetKeyMatchesAttribute(hierarchicalFacet) {
var facetNames = hierarchicalFacet.attributes || [];
return facetNames.indexOf(hierarchicalAttributeName) > -1;
});
}
/**
* Constructor for SearchResults
* @class
* @classdesc SearchResults contains the results of a query to Algolia using the
* {@link AlgoliaSearchHelper}.
* @param {SearchParameters} state state that led to the response
* @param {array.<object>} results the results from algolia client
* @param {object} options options to control results content
* @example <caption>SearchResults of the first query in
* <a href="http://demos.algolia.com/instant-search-demo">the instant search demo</a></caption>
{
"hitsPerPage": 10,
"processingTimeMS": 2,
"facets": [
{
"name": "type",
"data": {
"HardGood": 6627,
"BlackTie": 550,
"Music": 665,
"Software": 131,
"Game": 456,
"Movie": 1571
},
"exhaustive": false
},
{
"exhaustive": false,
"data": {
"Free shipping": 5507
},
"name": "shipping"
}
],
"hits": [
{
"thumbnailImage": "http://img.bbystatic.com/BestBuy_US/images/products/1688/1688832_54x108_s.gif",
"_highlightResult": {
"shortDescription": {
"matchLevel": "none",
"value": "Safeguard your PC, Mac, Android and iOS devices with comprehensive Internet protection",
"matchedWords": []
},
"category": {
"matchLevel": "none",
"value": "Computer Security Software",
"matchedWords": []
},
"manufacturer": {
"matchedWords": [],
"value": "Webroot",
"matchLevel": "none"
},
"name": {
"value": "Webroot SecureAnywhere Internet Security (3-Device) (1-Year Subscription) - Mac/Windows",
"matchedWords": [],
"matchLevel": "none"
}
},
"image": "http://img.bbystatic.com/BestBuy_US/images/products/1688/1688832_105x210_sc.jpg",
"shipping": "Free shipping",
"bestSellingRank": 4,
"shortDescription": "Safeguard your PC, Mac, Android and iOS devices with comprehensive Internet protection",
"url": "http://www.bestbuy.com/site/webroot-secureanywhere-internet-security-3-devi…d=1219060687969&skuId=1688832&cmp=RMX&ky=2d3GfEmNIzjA0vkzveHdZEBgpPCyMnLTJ",
"name": "Webroot SecureAnywhere Internet Security (3-Device) (1-Year Subscription) - Mac/Windows",
"category": "Computer Security Software",
"salePrice_range": "1 - 50",
"objectID": "1688832",
"type": "Software",
"customerReviewCount": 5980,
"salePrice": 49.99,
"manufacturer": "Webroot"
},
....
],
"nbHits": 10000,
"disjunctiveFacets": [
{
"exhaustive": false,
"data": {
"5": 183,
"12": 112,
"7": 149,
...
},
"name": "customerReviewCount",
"stats": {
"max": 7461,
"avg": 157.939,
"min": 1
}
},
{
"data": {
"Printer Ink": 142,
"Wireless Speakers": 60,
"Point & Shoot Cameras": 48,
...
},
"name": "category",
"exhaustive": false
},
{
"exhaustive": false,
"data": {
"> 5000": 2,
"1 - 50": 6524,
"501 - 2000": 566,
"201 - 500": 1501,
"101 - 200": 1360,
"2001 - 5000": 47
},
"name": "salePrice_range"
},
{
"data": {
"Dynex™": 202,
"Insignia™": 230,
"PNY": 72,
...
},
"name": "manufacturer",
"exhaustive": false
}
],
"query": "",
"nbPages": 100,
"page": 0,
"index": "bestbuy"
}
**/ function SearchResults(state, results, options) {
var mainSubResponse = results[0] || {};
this._rawResults = results;
// eslint-disable-next-line consistent-this
var self = this;
// https://www.algolia.com/doc/api-reference/api-methods/search/#response
Object.keys(mainSubResponse).forEach(function(key) {
self[key] = mainSubResponse[key];
});
// Make every key of the result options reachable from the instance
var opts = defaultsPure(options, {
persistHierarchicalRootCount: false
});
Object.keys(opts).forEach(function(key) {
self[key] = opts[key];
});
/**
* query used to generate the results
* @name query
* @member {string}
* @memberof SearchResults
* @instance
*/ /**
* The query as parsed by the engine given all the rules.
* @name parsedQuery
* @member {string}
* @memberof SearchResults
* @instance
*/ /**
* all the records that match the search parameters. Each record is
* augmented with a new attribute `_highlightResult`
* which is an object keyed by attribute and with the following properties:
* - `value` : the value of the facet highlighted (html)
* - `matchLevel`: `full`, `partial` or `none`, depending on how the query terms match
* @name hits
* @member {object[]}
* @memberof SearchResults
* @instance
*/ /**
* index where the results come from
* @name index
* @member {string}
* @memberof SearchResults
* @instance
*/ /**
* number of hits per page requested
* @name hitsPerPage
* @member {number}
* @memberof SearchResults
* @instance
*/ /**
* total number of hits of this query on the index
* @name nbHits
* @member {number}
* @memberof SearchResults
* @instance
*/ /**
* total number of pages with respect to the number of hits per page and the total number of hits
* @name nbPages
* @member {number}
* @memberof SearchResults
* @instance
*/ /**
* current page
* @name page
* @member {number}
* @memberof SearchResults
* @instance
*/ /**
* The position if the position was guessed by IP.
* @name aroundLatLng
* @member {string}
* @memberof SearchResults
* @instance
* @example "48.8637,2.3615",
*/ /**
* The radius computed by Algolia.
* @name automaticRadius
* @member {string}
* @memberof SearchResults
* @instance
* @example "126792922",
*/ /**
* String identifying the server used to serve this request.
*
* getRankingInfo needs to be set to `true` for this to be returned
*
* @name serverUsed
* @member {string}
* @memberof SearchResults
* @instance
* @example "c7-use-2.algolia.net",
*/ /**
* Boolean that indicates if the computation of the counts did time out.
* @deprecated
* @name timeoutCounts
* @member {boolean}
* @memberof SearchResults
* @instance
*/ /**
* Boolean that indicates if the computation of the hits did time out.
* @deprecated
* @name timeoutHits
* @member {boolean}
* @memberof SearchResults
* @instance
*/ /**
* True if the counts of the facets is exhaustive
* @name exhaustiveFacetsCount
* @member {boolean}
* @memberof SearchResults
* @instance
*/ /**
* True if the number of hits is exhaustive
* @name exhaustiveNbHits
* @member {boolean}
* @memberof SearchResults
* @instance
*/ /**
* Contains the userData if they are set by a [query rule](https://www.algolia.com/doc/guides/query-rules/query-rules-overview/).
* @name userData
* @member {object[]}
* @memberof SearchResults
* @instance
*/ /**
* queryID is the unique identifier of the query used to generate the current search results.
* This value is only available if the `clickAnalytics` search parameter is set to `true`.
* @name queryID
* @member {string}
* @memberof SearchResults
* @instance
*/ /**
* sum of the processing time of all the queries
* @name processingTimeMS
* @member {number}
* @memberof SearchResults
* @instance
*/ this.processingTimeMS = results.reduce(function(sum, result) {
return result.processingTimeMS === undefined ? sum : sum + result.processingTimeMS;
}, 0);
/**
* disjunctive facets results
* @member {SearchResults.Facet[]}
*/ this.disjunctiveFacets = [];
/**
* disjunctive facets results
* @member {SearchResults.HierarchicalFacet[]}
*/ this.hierarchicalFacets = state.hierarchicalFacets.map(function initFutureTree() {
return [];
});
/**
* other facets results
* @member {SearchResults.Facet[]}
*/ this.facets = [];
var disjunctiveFacets = state.getRefinedDisjunctiveFacets();
var facetsIndices = getIndices(state.facets);
var disjunctiveFacetsIndices = getIndices(state.disjunctiveFacets);
var nextDisjunctiveResult = 1;
// Since we send request only for disjunctive facets that have been refined,
// we get the facets information from the first, general, response.
var mainFacets = mainSubResponse.facets || {};
Object.keys(mainFacets).forEach(function(facetKey) {
var facetValueObject = mainFacets[facetKey];
var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(state.hierarchicalFacets, facetKey);
if (hierarchicalFacet) {
// Place the hierarchicalFacet data at the correct index depending on
// the attributes order that was defined at the helper initialization
var facetIndex = hierarchicalFacet.attributes.indexOf(facetKey);
var idxAttributeName = findIndex(state.hierarchicalFacets, function(f) {
return f.name === hierarchicalFacet.name;
});
self.hierarchicalFacets[idxAttributeName][facetIndex] = {
attribute: facetKey,
data: facetValueObject,
exhaustive: mainSubResponse.exhaustiveFacetsCount
};
} else {
var isFacetDisjunctive = state.disjunctiveFacets.indexOf(facetKey) !== -1;
var isFacetConjunctive = state.facets.indexOf(facetKey) !== -1;
var position;
if (isFacetDisjunctive) {
position = disjunctiveFacetsIndices[facetKey];
self.disjunctiveFacets[position] = {
name: facetKey,
data: facetValueObject,
exhaustive: mainSubResponse.exhaustiveFacetsCount
};
assignFacetStats(self.disjunctiveFacets[position], mainSubResponse.facets_stats, facetKey);
}
if (isFacetConjunctive) {
position = facetsIndices[facetKey];
self.facets[position] = {
name: facetKey,
data: facetValueObject,
exhaustive: mainSubResponse.exhaustiveFacetsCount
};
assignFacetStats(self.facets[position], mainSubResponse.facets_stats, facetKey);
}
}
});
// Make sure we do not keep holes within the hierarchical facets
this.hierarchicalFacets = compact(this.hierarchicalFacets);
// aggregate the refined disjunctive facets
disjunctiveFacets.forEach(function(disjunctiveFacet) {
var result = results[nextDisjunctiveResult];
var facets = result && result.facets ? result.facets : {};
var hierarchicalFacet = state.getHierarchicalFacetByName(disjunctiveFacet);
// There should be only item in facets.
Object.keys(facets).forEach(function(dfacet) {
var facetResults = facets[dfacet];
var position;
if (hierarchicalFacet) {
position = findIndex(state.hierarchicalFacets, function(f) {
return f.name === hierarchicalFacet.name;
});
var attributeIndex = findIndex(self.hierarchicalFacets[position], function(f) {
return f.attribute === dfacet;
});
// previous refinements and no results so not able to find it
if (attributeIndex === -1) {
return;
}
self.hierarchicalFacets[position][attributeIndex].data = self.persistHierarchicalRootCount ? mergeNumericMax(self.hierarchicalFacets[position][attributeIndex].data, facetResults) : defaultsPure(facetResults, self.hierarchicalFacets[position][attributeIndex].data);
} else {
position = disjunctiveFacetsIndices[dfacet];
var dataFromMainRequest = mainSubResponse.facets && mainSubResponse.facets[dfacet] || {};
self.disjunctiveFacets[position] = {
name: dfacet,
data: mergeNumericMax(dataFromMainRequest, facetResults),
exhaustive: result.exhaustiveFacetsCount
};
assignFacetStats(self.disjunctiveFacets[position], result.facets_stats, dfacet);
if (state.disjunctiveFacetsRefinements[dfacet]) {
state.disjunctiveFacetsRefinements[dfacet].forEach(function(refinementValue) {
// add the disjunctive refinements if it is no more retrieved
if (!self.disjunctiveFacets[position].data[refinementValue] && state.disjunctiveFacetsRefinements[dfacet].indexOf(unescapeFacetValue(refinementValue)) > -1) {
self.disjunctiveFacets[position].data[refinementValue] = 0;
}
});
}
}
});
nextDisjunctiveResult++;
});
// if we have some parent level values for hierarchical facets, merge them
state.getRefinedHierarchicalFacets().forEach(function(refinedFacet) {
var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);
var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
var currentRefinement = state.getHierarchicalRefinement(refinedFacet);
// if we are already at a root refinement (or no refinement at all), there is no
// root level values request
if (currentRefinement.length === 0 || currentRefinement[0].split(separator).length < 2) {
return;
}
results.slice(nextDisjunctiveResult).forEach(function(result) {
var facets = result && result.facets ? result.facets : {};
Object.keys(facets).forEach(function(dfacet) {
var facetResults = facets[dfacet];
var position = findIndex(state.hierarchicalFacets, function(f) {
return f.name === hierarchicalFacet.name;
});
var attributeIndex = findIndex(self.hierarchicalFacets[position], function(f) {
return f.attribute === dfacet;
});
// previous refinements and no results so not able to find it
if (attributeIndex === -1) {
return;
}
// when we always get root levels, if the hits refinement is `beers > IPA` (count: 5),
// then the disjunctive values will be `beers` (count: 100),
// but we do not want to display
// | beers (100)
// > IPA (5)
// We want
// | beers (5)
// > IPA (5)
// @MAJOR: remove this legacy behaviour in next major version
var defaultData = {};
if (currentRefinement.length > 0 && !self.persistHierarchicalRootCount) {
var root = currentRefinement[0].split(separator)[0];
defaultData[root] = self.hierarchicalFacets[position][attributeIndex].data[root];
}
self.hierarchicalFacets[position][attributeIndex].data = defaultsPure(defaultData, facetResults, self.hierarchicalFacets[position][attributeIndex].data);
});
nextDisjunctiveResult++;
});
});
// add the excludes
Object.keys(state.facetsExcludes).forEach(function(facetName) {
var excludes = state.facetsExcludes[facetName];
var position = facetsIndices[facetName];
self.facets[position] = {
name: facetName,
data: mainFacets[facetName],
exhaustive: mainSubResponse.exhaustiveFacetsCount
};
excludes.forEach(function(facetValue) {
self.facets[position] = self.facets[position] || {
name: facetName
};
self.facets[position].data = self.facets[position].data || {};
self.facets[position].data[facetValue] = 0;
});
});
/**
* @type {Array}
*/ this.hierarchicalFacets = this.hierarchicalFacets.map(generateHierarchicalTree(state));
/**
* @type {Array}
*/ this.facets = compact(this.facets);
/**
* @type {Array}
*/ this.disjunctiveFacets = compact(this.disjunctiveFacets);
this._state = state;
}
/**
* Get a facet object with its name
* @deprecated
* @param {string} name name of the faceted attribute
* @return {SearchResults.Facet} the facet object
*/ SearchResults.prototype.getFacetByName = function(name) {
function predicate(facet) {
return facet.name === name;
}
return find(this.facets, predicate) || find(this.disjunctiveFacets, predicate) || find(this.hierarchicalFacets, predicate);
};
/**
* Get the facet values of a specified attribute from a SearchResults object.
* @private
* @param {SearchResults} results the search results to search in
* @param {string} attribute name of the faceted attribute to search for
* @return {array|object} facet values. For the hierarchical facets it is an object.
*/ function extractNormalizedFacetValues(results, attribute) {
function predicate(facet) {
return facet.name === attribute;
}
if (results._state.isConjunctiveFacet(attribute)) {
var facet = find(results.facets, predicate);
if (!facet) return [];
return Object.keys(facet.data).map(function(name) {
var value = escapeFacetValue(name);
return {
name: name,
escapedValue: value,
count: facet.data[name],
isRefined: results._state.isFacetRefined(attribute, value),
isExcluded: results._state.isExcludeRefined(attribute, name)
};
});
} else if (results._state.isDisjunctiveFacet(attribute)) {
var disjunctiveFacet = find(results.disjunctiveFacets, predicate);
if (!disjunctiveFacet) return [];
return Object.keys(disjunctiveFacet.data).map(function(name) {
var value = escapeFacetValue(name);
return {
name: name,
escapedValue: value,
count: disjunctiveFacet.data[name],
isRefined: results._state.isDisjunctiveFacetRefined(attribute, value)
};
});
} else if (results._state.isHierarchicalFacet(attribute)) {
var hierarchicalFacetValues = find(results.hierarchicalFacets, predicate);
if (!hierarchicalFacetValues) return hierarchicalFacetValues;
var hierarchicalFacet = results._state.getHierarchicalFacetByName(attribute);
var separator = results._state._getHierarchicalFacetSeparator(hierarchicalFacet);
var currentRefinement = unescapeFacetValue(results._state.getHierarchicalRefinement(attribute)[0] || '');
if (currentRefinement.indexOf(hierarchicalFacet.rootPath) === 0) {
currentRefinement = currentRefinement.replace(hierarchicalFacet.rootPath + separator, '');
}
var currentRefinementSplit = currentRefinement.split(separator);
currentRefinementSplit.unshift(attribute);
setIsRefined(hierarchicalFacetValues, currentRefinementSplit, 0);
return hierarchicalFacetValues;
}
return undefined;
}
/**
* Set the isRefined of a hierarchical facet result based on the current state.
* @param {SearchResults.HierarchicalFacet} item Hierarchical facet to fix
* @param {string[]} currentRefinement array of parts of the current hierarchical refinement
* @param {number} depth recursion depth in the currentRefinement
* @return {undefined} function mutates the item
*/ function setIsRefined(item, currentRefinement, depth) {
item.isRefined = item.name === (currentRefinement[depth] && currentRefinement[depth].trim());
if (item.data) {
item.data.forEach(function(child) {
setIsRefined(child, currentRefinement, depth + 1);
});
}
}
/**
* Sort nodes of a hierarchical or disjunctive facet results
* @private
* @param {function} sortFn sort function to apply
* @param {HierarchicalFacet|Array} node node upon which we want to apply the sort
* @param {string[]} names attribute names
* @param {number} [level=0] current index in the names array
* @return {HierarchicalFacet|Array} sorted node
*/ function recSort(sortFn, node, names, level) {
level = level || 0;
if (Array.isArray(node)) {
return sortFn(node, names[level]);
}
if (!node.data || node.data.length === 0) {
return node;
}
var children = node.data.map(function(childNode) {
return recSort(sortFn, childNode, names, level + 1);
});
var sortedChildren = sortFn(children, names[level]);
var newNode = defaultsPure({
data: sortedChildren
}, node);
return newNode;
}
SearchResults.DEFAULT_SORT = [
'isRefined:desc',
'count:desc',
'name:asc'
];
function vanillaSortFn(order, data) {
return data.sort(order);
}
/**
* @typedef FacetOrdering
* @type {Object}
* @property {string[]} [order]
* @property {'count' | 'alpha' | 'hidden'} [sortRemainingBy]
*/ /**
* Sorts facet arrays via their facet ordering
* @param {Array} facetValues the values
* @param {FacetOrdering} facetOrdering the ordering
* @returns {Array} the sorted facet values
*/ function sortViaFacetOrdering(facetValues, facetOrdering) {
var orderedFacets = [];
var remainingFacets = [];
var hide = facetOrdering.hide || [];
var order = facetOrdering.order || [];
/**
* an object with the keys being the values in order, the values their index:
* ['one', 'two'] -> { one: 0, two: 1 }
*/ var reverseOrder = order.reduce(function(acc, name, i) {
acc[name] = i;
return acc;
}, {});
facetValues.forEach(function(item) {
// hierarchical facets get sorted using their raw name
var name = item.path || item.name;
var hidden = hide.indexOf(name) > -1;
if (!hidden && reverseOrder[name] !== undefined) {
orderedFacets[reverseOrder[name]] = item;
} else if (!hidden) {
remainingFacets.push(item);
}
});
orderedFacets = orderedFacets.filter(function(facet) {
return facet;
});
var sortRemainingBy = facetOrdering.sortRemainingBy;
var ordering;
if (sortRemainingBy === 'hidden') {
return orderedFacets;
} else if (sortRemainingBy === 'alpha') {
ordering = [
[
'path',
'name'
],
[
'asc',
'asc'
]
];
} else {
ordering = [
[
'count'
],
[
'desc'
]
];
}
return orderedFacets.concat(orderBy(remainingFacets, ordering[0], ordering[1]));
}
/**
* @param {SearchResults} results the search results class
* @param {string} attribute the attribute to retrieve ordering of
* @returns {FacetOrdering | undefined} the facet ordering
*/ function getFacetOrdering(results, attribute) {
return results.renderingContent && results.renderingContent.facetOrdering && results.renderingContent.facetOrdering.values && results.renderingContent.facetOrdering.values[attribute];
}
/**
* Get a the list of values for a given facet attribute. Those values are sorted
* refinement first, descending count (bigger value on top), and name ascending
* (alphabetical order). The sort formula can overridden using either string based
* predicates or a function.
*
* This method will return all the values returned by the Algolia engine plus all
* the values already refined. This means that it can happen that the
* `maxValuesPerFacet` [configuration](https://www.algolia.com/doc/rest-api/search#param-maxValuesPerFacet)
* might not be respected if you have facet values that are already refined.
* @param {string} attribute attribute name
* @param {object} opts configuration options.
* @param {boolean} [opts.facetOrdering]
* Force the use of facetOrdering from the result if a sortBy is present. If
* sortBy isn't present, facetOrdering will be used automatically.
* @param {Array.<string> | function} opts.sortBy
* When using strings, it consists of
* the name of the [FacetValue](#SearchResults.FacetValue) or the
* [HierarchicalFacet](#SearchResults.HierarchicalFacet) attributes with the
* order (`asc` or `desc`). For example to order the value by count, the
* argument would be `['count:asc']`.
*
* If only the attribute name is specified, the ordering defaults to the one
* specified in the default value for this attribute.
*
* When not specified, the order is
* ascending. This parameter can also be a function which takes two facet
* values and should return a number, 0 if equal, 1 if the first argument is
* bigger or -1 otherwise.
*
* The default value for this attribute `['isRefined:desc', 'count:desc', 'name:asc']`
* @return {FacetValue[]|HierarchicalFacet|undefined} depending on the type of facet of
* the attribute requested (hierarchical, disjunctive or conjunctive)
* @example
* helper.on('result', function(event){
* //get values ordered only by name ascending using the string predicate
* event.results.getFacetValues('city', {sortBy: ['name:asc']});
* //get values ordered only by count ascending using a function
* event.results.getFacetValues('city', {
* // this is equivalent to ['count:asc']
* sortBy: function(a, b) {
* if (a.count === b.count) return 0;
* if (a.count > b.count) return 1;
* if (b.count > a.count) return -1;
* }
* });
* });
*/ SearchResults.prototype.getFacetValues = function(attribute, opts) {
var facetValues = extractNormalizedFacetValues(this, attribute);
if (!facetValues) {
return undefined;
}
var options = defaultsPure(opts, {
sortBy: SearchResults.DEFAULT_SORT,
// if no sortBy is given, attempt to sort based on facetOrdering
// if it is given, we still allow to sort via facet ordering first
facetOrdering: !(opts && opts.sortBy)
});
// eslint-disable-next-line consistent-this
var results = this;
var attributes;
if (Array.isArray(facetValues)) {
attributes = [
attribute
];
} else {
var config = results._state.getHierarchicalFacetByName(facetValues.name);
attributes = config.attributes;
}
return recSort(function(data, facetName) {
var facetOrdering = getFacetOrdering(results, facetName);
if (options.facetOrdering) {
if (facetOrdering) {
return sortViaFacetOrdering(data, facetOrdering);
}
}
if (Array.isArray(options.sortBy)) {
var order = formatSort(options.sortBy, SearchResults.DEFAULT_SORT);
var items = orderBy(data, order[0], order[1]);
var hide = facetOrdering && facetOrdering.hide ? facetOrdering.hide : [];
if (hide.length > 0) {
var visible = [];
items.forEach(function(item) {
// hierarchical facets get sorted using their raw name
var name = item.path || item.name;
if (hide.indexOf(name) === -1) {
visible.push(item);
}
});
return visible;
}
return items;
} else if (typeof options.sortBy === 'function') {
return vanillaSortFn(options.sortBy, data);
}
throw new Error('options.sortBy is optional but if defined it must be ' + 'either an array of string (predicates) or a sorting function');
}, facetValues, attributes);
};
/**
* Returns the facet stats if attribute is defined and the facet contains some.
* Otherwise returns undefined.
* @param {string} attribute name of the faceted attribute
* @return {object} The stats of the facet
*/ SearchResults.prototype.getFacetStats = function(attribute) {
if (this._state.isConjunctiveFacet(attribute)) {
return getFacetStatsIfAvailable(this.facets, attribute);
} else if (this._state.isDisjunctiveFacet(attribute)) {
return getFacetStatsIfAvailable(this.disjunctiveFacets, attribute);
}
return undefined;
};
/**
* @typedef {Object} FacetListItem
* @property {string} name
*/ /**
* @param {FacetListItem[]} facetList (has more items, but enough for here)
* @param {string} facetName The attribute to look for
* @return {object|undefined} The stats of the facet
*/ function getFacetStatsIfAvailable(facetList, facetName) {
var data = find(facetList, function(facet) {
return facet.name === facetName;
});
return data && data.stats;
}
/**
* Returns all refinements for all filters + tags. It also provides
* additional information: count and exhaustiveness for each filter.
*
* See the [refinement type](#Refinement) for an exhaustive view of the available
* data.
*
* Note that for a numeric refinement, results are grouped per operator, this
* means that it will return responses for operators which are empty.
*
* @return {Array.<Refinement>} all the refinements
*/ SearchResults.prototype.getRefinements = function() {
var state = this._state;
// eslint-disable-next-line consistent-this
var results = this;
var res = [];
Object.keys(state.facetsRefinements).forEach(function(attributeName) {
state.facetsRefinements[attributeName].forEach(function(name) {
res.push(getRefinement(state, 'facet', attributeName, name, results.facets));
});
});
Object.keys(state.facetsExcludes).forEach(function(attributeName) {
state.facetsExcludes[attributeName].forEach(function(name) {
res.push(getRefinement(state, 'exclude', attributeName, name, results.facets));
});
});
Object.keys(state.disjunctiveFacetsRefinements).forEach(function(attributeName) {
state.disjunctiveFacetsRefinements[attributeName].forEach(function(name) {
res.push(getRefinement(state, 'disjunctive', attributeName, name, results.disjunctiveFacets));
});
});
Object.keys(state.hierarchicalFacetsRefinements).forEach(function(attributeName) {
state.hierarchicalFacetsRefinements[attributeName].forEach(function(name) {
res.push(getHierarchicalRefinement(state, attributeName, name, results.hierarchicalFacets));
});
});
Object.keys(state.numericRefinements).forEach(function(attributeName) {
var operators = state.numericRefinements[attributeName];
Object.keys(operators).forEach(function(operator) {
operators[operator].forEach(function(value) {
res.push({
type: 'numeric',
attributeName: attributeName,
name: value,
numericValue: value,
operator: operator
});
});
});
});
state.tagRefinements.forEach(function(name) {
res.push({
type: 'tag',
attributeName: '_tags',
name: name
});
});
return res;
};
/**
* @typedef {Object} Facet
* @property {string} name
* @property {Object} data
* @property {boolean} exhaustive
*/ /**
* @param {SearchParameters} state the current state
* @param {string} type the type of the refinement
* @param {string} attributeName The attribute of the facet
* @param {*} name The name of the facet
* @param {Facet[]} resultsFacets facets from the results
* @return {Refinement} the refinement
*/ function getRefinement(state, type, attributeName, name, resultsFacets) {
var facet = find(resultsFacets, function(f) {
return f.name === attributeName;
});
var count = facet && facet.data && facet.data[name] ? facet.data[name] : 0;
var exhaustive = facet && facet.exhaustive || false;
return {
type: type,
attributeName: attributeName,
name: name,
count: count,
exhaustive: exhaustive
};
}
/**
* @param {SearchParameters} state the current state
* @param {string} attributeName the attribute of the hierarchical facet
* @param {string} name the name of the facet
* @param {Facet[]} resultsFacets facets from the results
* @return {HierarchicalFacet} the hierarchical facet
*/ function getHierarchicalRefinement(state, attributeName, name, resultsFacets) {
var facetDeclaration = state.getHierarchicalFacetByName(attributeName);
var separator = state._getHierarchicalFacetSeparator(facetDeclaration);
var split = name.split(separator);
var rootFacet = find(resultsFacets, function(facet) {
return facet.name === attributeName;
});
var facet = split.reduce(function(intermediateFacet, part) {
var newFacet = intermediateFacet && find(intermediateFacet.data, function(f) {
return f.name === part;
});
return newFacet !== undefined ? newFacet : intermediateFacet;
}, rootFacet);
var count = facet && facet.count || 0;
var exhaustive = facet && facet.exhaustive || false;
var path = facet && facet.path || '';
return {
type: 'hierarchical',
attributeName: attributeName,
name: path,
count: count,
exhaustive: exhaustive
};
}
SearchResults_1 = SearchResults;
return SearchResults_1;
}
var flat$1;
var hasRequiredFlat;
function requireFlat() {
if (hasRequiredFlat) return flat$1;
hasRequiredFlat = 1;
// @MAJOR: remove this function and use Array.prototype.flat
flat$1 = function flat(arr) {
return arr.reduce(function(acc, val) {
return acc.concat(val);
}, []);
};
return flat$1;
}
var sortAndMergeRecommendations_1;
var hasRequiredSortAndMergeRecommendations;
function requireSortAndMergeRecommendations() {
if (hasRequiredSortAndMergeRecommendations) return sortAndMergeRecommendations_1;
hasRequiredSortAndMergeRecommendations = 1;
var find = requireFind();
var flat = requireFlat();
function getAverageIndices(indexTracker, nrOfObjs) {
var avgIndices = [];
Object.keys(indexTracker).forEach(function(key) {
if (indexTracker[key].count < 2) {
indexTracker[key].indexSum += 100;
}
avgIndices.push({
objectID: key,
avgOfIndices: indexTracker[key].indexSum / nrOfObjs
});
});
return avgIndices.sort(function(a, b) {
return a.avgOfIndices > b.avgOfIndices ? 1 : -1;
});
}
function sortAndMergeRecommendations(objectIDs, results) {
var indexTracker = {};
results.forEach(function(hits) {
hits.forEach(function(hit, index) {
if (objectIDs.includes(hit.objectID)) return;
if (!indexTracker[hit.objectID]) {
indexTracker[hit.objectID] = {
indexSum: index,
count: 1
};
} else {
indexTracker[hit.objectID] = {
indexSum: indexTracker[hit.objectID].indexSum + index,
count: indexTracker[hit.objectID].count + 1
};
}
});
});
var sortedAverageIndices = getAverageIndices(indexTracker, results.length);
var finalOrder = sortedAverageIndices.reduce(function(orderedHits, avgIndexRef) {
var result = find(flat(results), function(hit) {
return hit.objectID === avgIndexRef.objectID;
});
return result ? orderedHits.concat(result) : orderedHits;
}, []);
return finalOrder;
}
sortAndMergeRecommendations_1 = sortAndMergeRecommendations;
return sortAndMergeRecommendations_1;
}
var version$1;
var hasRequiredVersion;
function requireVersion() {
if (hasRequiredVersion) return version$1;
hasRequiredVersion = 1;
version$1 = '3.29.3';
return version$1;
}
var algoliasearch_helper;
var hasRequiredAlgoliasearch_helper;
function requireAlgoliasearch_helper() {
if (hasRequiredAlgoliasearch_helper) return algoliasearch_helper;
hasRequiredAlgoliasearch_helper = 1;
var EventEmitter = requireEvents();
var DerivedHelper = requireDerivedHelper();
var escapeFacetValue = requireEscapeFacetValue().escapeFacetValue;
var inherits = requireInherits();
var merge = requireMerge();
var objectHasKeys = requireObjectHasKeys();
var omit = requireOmit();
var RecommendParameters = requireRecommendParameters();
var RecommendResults = requireRecommendResults();
var requestBuilder = requireRequestBuilder();
var SearchParameters = requireSearchParameters();
var SearchResults = requireSearchResults();
var sortAndMergeRecommendations = requireSortAndMergeRecommendations();
var version = requireVersion();
/**
* Event triggered when a parameter is set or updated
* @event AlgoliaSearchHelper#event:change
* @property {object} event
* @property {SearchParameters} event.state the current parameters with the latest changes applied
* @property {SearchResults} event.results the previous results received from Algolia. `null` before the first request
* @example
* helper.on('change', function(event) {
* console.log('The parameters have changed');
* });
*/ /**
* Event triggered when a main search is sent to Algolia
* @event AlgoliaSearchHelper#event:search
* @property {object} event
* @property {SearchParameters} event.state the parameters used for this search
* @property {SearchResults} event.results the results from the previous search. `null` if it is the first search.
* @example
* helper.on('search', function(event) {
* console.log('Search sent');
* });
*/ /**
* Event triggered when a search using `searchForFacetValues` is sent to Algolia
* @event AlgoliaSearchHelper#event:searchForFacetValues
* @property {object} event
* @property {SearchParameters} event.state the parameters used for this search it is the first search.
* @property {string} event.facet the facet searched into
* @property {string} event.query the query used to search in the facets
* @example
* helper.on('searchForFacetValues', function(event) {
* console.log('searchForFacetValues sent');
* });
*/ /**
* Event triggered when a search using `searchOnce` is sent to Algolia
* @event AlgoliaSearchHelper#event:searchOnce
* @property {object} event
* @property {SearchParameters} event.state the parameters used for this search it is the first search.
* @example
* helper.on('searchOnce', function(event) {
* console.log('searchOnce sent');
* });
*/ /**
* Event triggered when the results are retrieved from Algolia
* @event AlgoliaSearchHelper#event:result
* @property {object} event
* @property {SearchResults} event.results the results received from Algolia
* @property {SearchParameters} event.state the parameters used to query Algolia. Those might be different from the one in the helper instance (for example if the network is unreliable).
* @example
* helper.on('result', function(event) {
* console.log('Search results received');
* });
*/ /**
* Event triggered when Algolia sends back an error. For example, if an unknown parameter is
* used, the error can be caught using this event.
* @event AlgoliaSearchHelper#event:error
* @property {object} event
* @property {Error} event.error the error returned by the Algolia.
* @example
* helper.on('error', function(event) {
* console.log('Houston we got a problem.');
* });
*/ /**
* Event triggered when the queue of queries have been depleted (with any result or outdated queries)
* @event AlgoliaSearchHelper#event:searchQueueEmpty
* @example
* helper.on('searchQueueEmpty', function() {
* console.log('No more search pending');
* // This is received before the result event if we're not expecting new results
* });
*
* helper.search();
*/ /**
* Initialize a new AlgoliaSearchHelper
* @class
* @classdesc The AlgoliaSearchHelper is a class that ease the management of the
* search. It provides an event based interface for search callbacks:
* - change: when the internal search state is changed.
* This event contains a {@link SearchParameters} object and the
* {@link SearchResults} of the last result if any.
* - search: when a search is triggered using the `search()` method.
* - result: when the response is retrieved from Algolia and is processed.
* This event contains a {@link SearchResults} object and the
* {@link SearchParameters} corresponding to this answer.
* - error: when the response is an error. This event contains the error returned by the server.
* @param {AlgoliaSearch} client an AlgoliaSearch client
* @param {string} index the index name to query
* @param {SearchParameters | object} options an object defining the initial
* config of the search. It doesn't have to be a {SearchParameters},
* just an object containing the properties you need from it.
* @param {SearchResultsOptions|object} searchResultsOptions an object defining the options to use when creating the search results.
*/ function AlgoliaSearchHelper(client, index, options, searchResultsOptions) {
if (typeof client.addAlgoliaAgent === 'function') {
client.addAlgoliaAgent('JS Helper (' + version + ')');
}
this.setClient(client);
var opts = options || {};
opts.index = index;
this.state = SearchParameters.make(opts);
this.recommendState = new RecommendParameters({
params: opts.recommendState
});
this.lastResults = null;
this.lastRecommendResults = null;
this._queryId = 0;
this._recommendQueryId = 0;
this._lastQueryIdReceived = -1;
this._lastRecommendQueryIdReceived = -1;
this.derivedHelpers = [];
this._currentNbQueries = 0;
this._currentNbRecommendQueries = 0;
this._searchResultsOptions = searchResultsOptions;
this._recommendCache = {};
}
inherits(AlgoliaSearchHelper, EventEmitter);
/**
* Start the search with the parameters set in the state. When the
* method is called, it triggers a `search` event. The results will
* be available through the `result` event. If an error occurs, an
* `error` will be fired instead.
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires search
* @fires result
* @fires error
* @chainable
*/ AlgoliaSearchHelper.prototype.search = function() {
this._search({
onlyWithDerivedHelpers: false
});
return this;
};
AlgoliaSearchHelper.prototype.searchOnlyWithDerivedHelpers = function() {
this._search({
onlyWithDerivedHelpers: true
});
return this;
};
AlgoliaSearchHelper.prototype.searchWithComposition = function() {
this._runComposition({
onlyWithDerivedHelpers: true
});
return this;
};
/**
* Sends the recommendation queries set in the state. When the method is
* called, it triggers a `fetch` event. The results will be available through
* the `result` event. If an error occurs, an `error` will be fired instead.
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires fetch
* @fires result
* @fires error
* @chainable
*/ AlgoliaSearchHelper.prototype.recommend = function() {
this._recommend();
return this;
};
/**
* Gets the search query parameters that would be sent to the Algolia Client
* for the hits
* @return {object} Query Parameters
*/ AlgoliaSearchHelper.prototype.getQuery = function() {
var state = this.state;
return requestBuilder._getHitsSearchParams(state);
};
/**
* Start a search using a modified version of the current state. This method does
* not trigger the helper lifecycle and does not modify the state kept internally
* by the helper. This second aspect means that the next search call will be the
* same as a search call before calling searchOnce.
* @param {object} options can contain all the parameters that can be set to SearchParameters
* plus the index
* @param {function} [cb] optional callback executed when the response from the
* server is back.
* @return {promise|undefined} if a callback is passed the method returns undefined
* otherwise it returns a promise containing an object with two keys :
* - content with a SearchResults
* - state with the state used for the query as a SearchParameters
* @example
* // Changing the number of records returned per page to 1
* // This example uses the callback API
* var state = helper.searchOnce({hitsPerPage: 1},
* function(error, content, state) {
* // if an error occurred it will be passed in error, otherwise its value is null
* // content contains the results formatted as a SearchResults
* // state is the instance of SearchParameters used for this search
* });
* @example
* // Changing the number of records returned per page to 1
* // This example uses the promise API
* var state1 = helper.searchOnce({hitsPerPage: 1})
* .then(promiseHandler);
*
* function promiseHandler(res) {
* // res contains
* // {
* // content : SearchResults
* // state : SearchParameters (the one used for this specific search)
* // }
* }
*/ AlgoliaSearchHelper.prototype.searchOnce = function(options, cb) {
var tempState = !options ? this.state : this.state.setQueryParameters(options);
var queries = requestBuilder._getQueries(tempState.index, tempState);
// eslint-disable-next-line consistent-this
var self = this;
this._currentNbQueries++;
this.emit('searchOnce', {
state: tempState
});
if (cb) {
this.client.search(queries).then(function(content) {
self._currentNbQueries--;
if (self._currentNbQueries === 0) {
self.emit('searchQueueEmpty');
}
cb(null, new SearchResults(tempState, content.results), tempState);
}).catch(function(err) {
self._currentNbQueries--;
if (self._currentNbQueries === 0) {
self.emit('searchQueueEmpty');
}
cb(err, null, tempState);
});
return undefined;
}
return this.client.search(queries).then(function(content) {
self._currentNbQueries--;
if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
return {
content: new SearchResults(tempState, content.results),
state: tempState,
_originalResponse: content
};
}, function(e) {
self._currentNbQueries--;
if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
throw e;
});
};
/**
* Start the search for answers with the parameters set in the state.
* This method returns a promise.
* @param {Object} options - the options for answers API call
* @param {string[]} options.attributesForPrediction - Attributes to use for predictions. If empty, `searchableAttributes` is used instead.
* @param {string[]} options.queryLanguages - The languages in the query. Currently only supports ['en'].
* @param {number} options.nbHits - Maximum number of answers to retrieve from the Answers Engine. Cannot be greater than 1000.
*
* @return {promise} the answer results
* @deprecated answers is deprecated and will be replaced with new initiatives
*/ AlgoliaSearchHelper.prototype.findAnswers = function(options) {
// eslint-disable-next-line no-console
console.warn('[algoliasearch-helper] answers is no longer supported');
var state = this.state;
var derivedHelper = this.derivedHelpers[0];
if (!derivedHelper) {
return Promise.resolve([]);
}
var derivedState = derivedHelper.getModifiedState(state);
var data = merge({
attributesForPrediction: options.attributesForPrediction,
nbHits: options.nbHits
}, {
params: omit(requestBuilder._getHitsSearchParams(derivedState), [
'attributesToSnippet',
'hitsPerPage',
'restrictSearchableAttributes',
'snippetEllipsisText'
])
});
var errorMessage = 'search for answers was called, but this client does not have a function client.initIndex(index).findAnswers';
if (typeof this.client.initIndex !== 'function') {
throw new Error(errorMessage);
}
var index = this.client.initIndex(derivedState.index);
if (typeof index.findAnswers !== 'function') {
throw new Error(errorMessage);
}
return index.findAnswers(derivedState.query, options.queryLanguages, data);
};
/**
* Structure of each result when using
* [`searchForFacetValues()`](reference.html#AlgoliaSearchHelper#searchForFacetValues)
* @typedef FacetSearchHit
* @type {object}
* @property {string} value the facet value
* @property {string} highlighted the facet value highlighted with the query string
* @property {number} count number of occurrence of this facet value
* @property {boolean} isRefined true if the value is already refined
*/ /**
* Structure of the data resolved by the
* [`searchForFacetValues()`](reference.html#AlgoliaSearchHelper#searchForFacetValues)
* promise.
* @typedef FacetSearchResult
* @type {object}
* @property {FacetSearchHit} facetHits the results for this search for facet values
* @property {number} processingTimeMS time taken by the query inside the engine
*/ /**
* Search for facet values based on an query and the name of a faceted attribute. This
* triggers a search and will return a promise. On top of using the query, it also sends
* the parameters from the state so that the search is narrowed down to only the possible values.
*
* See the description of [FacetSearchResult](reference.html#FacetSearchResult)
* @param {string} facet the name of the faceted attribute
* @param {string} query the string query for the search
* @param {number} [maxFacetHits] the maximum number values returned. Should be > 0 and <= 100
* @param {object} [userState] the set of custom parameters to use on top of the current state. Setting a property to `undefined` removes
* it in the generated query.
* @return {promise.<FacetSearchResult>} the results of the search
*/ AlgoliaSearchHelper.prototype.searchForFacetValues = function(facet, query, maxFacetHits, userState) {
var clientHasSFFV = typeof this.client.searchForFacetValues === 'function' && // v5 has a wrong sffv signature
typeof this.client.searchForFacets !== 'function';
var clientHasInitIndex = typeof this.client.initIndex === 'function';
if (!clientHasSFFV && !clientHasInitIndex && typeof this.client.search !== 'function') {
throw new Error('search for facet values (searchable) was called, but this client does not have a function client.searchForFacetValues or client.initIndex(index).searchForFacetValues');
}
var state = this.state.setQueryParameters(userState || {});
var isDisjunctive = state.isDisjunctiveFacet(facet);
var algoliaQuery = requestBuilder.getSearchForFacetQuery(facet, query, maxFacetHits, state);
this._currentNbQueries++;
// eslint-disable-next-line consistent-this
var self = this;
var searchForFacetValuesPromise;
// newer algoliasearch ^3.27.1 - ~4.0.0
if (clientHasSFFV) {
searchForFacetValuesPromise = this.client.searchForFacetValues([
{
indexName: state.index,
params: algoliaQuery
}
]);
// algoliasearch < 3.27.1
} else if (clientHasInitIndex) {
searchForFacetValuesPromise = this.client.initIndex(state.index).searchForFacetValues(algoliaQuery);
// algoliasearch ~5.0.0
} else {
// @MAJOR only use client.search
delete algoliaQuery.facetName;
searchForFacetValuesPromise = this.client.search([
{
type: 'facet',
facet: facet,
indexName: state.index,
params: algoliaQuery
}
]).then(function processResponse(response) {
return response.results[0];
});
}
this.emit('searchForFacetValues', {
state: state,
facet: facet,
query: query
});
var hide = this.lastResults && this.lastResults.index === state.index && this.lastResults.renderingContent && this.lastResults.renderingContent.facetOrdering && this.lastResults.renderingContent.facetOrdering.values && this.lastResults.renderingContent.facetOrdering.values[facet] && this.lastResults.renderingContent.facetOrdering.values[facet].hide || [];
return searchForFacetValuesPromise.then(function addIsRefined(content) {
self._currentNbQueries--;
if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
content = Array.isArray(content) ? content[0] : content;
content.facetHits = content.facetHits.reduce(function(acc, f) {
if (hide.indexOf(f.value) > -1) {
return acc;
}
f.escapedValue = escapeFacetValue(f.value);
f.isRefined = isDisjunctive ? state.isDisjunctiveFacetRefined(facet, f.escapedValue) : state.isFacetRefined(facet, f.escapedValue);
acc.push(f);
return acc;
}, []);
return content;
}, function(e) {
self._currentNbQueries--;
if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
throw e;
});
};
/**
* Search for facet values using the Composition API & based on a query and the name of a faceted attribute.
* This triggers a search and will return a promise. On top of using the query, it also sends
* the parameters from the state so that the search is narrowed down to only the possible values.
*
* See the description of [FacetSearchResult](reference.html#FacetSearchResult)
* @param {string} facet the name of the faceted attribute
* @param {string} query the string query for the search
* @param {number} [maxFacetHits] the maximum number values returned. Should be > 0 and <= 100
* @param {object} [userState] the set of custom parameters to use on top of the current state. Setting a property to `undefined` removes
* it in the generated query.
* @return {promise.<FacetSearchResult>} the results of the search
*/ AlgoliaSearchHelper.prototype.searchForCompositionFacetValues = function(facet, query, maxFacetHits, userState) {
if (typeof this.client.searchForFacetValues !== 'function') {
throw new Error('search for facet values (searchable) was called, but this client does not have a function client.searchForFacetValues');
}
var state = this.state.setQueryParameters(userState || {});
var isDisjunctive = state.isDisjunctiveFacet(facet);
this._currentNbQueries++;
// eslint-disable-next-line consistent-this
var self = this;
var searchForFacetValuesPromise;
searchForFacetValuesPromise = this.client.searchForFacetValues({
compositionID: state.index,
facetName: facet,
searchForFacetValuesRequest: {
params: {
query: query,
maxFacetHits: maxFacetHits,
searchQuery: requestBuilder._getCompositionHitsSearchParams(state)
}
}
});
this.emit('searchForFacetValues', {
state: state,
facet: facet,
query: query
});
return searchForFacetValuesPromise.then(function addIsRefined(content) {
self._currentNbQueries--;
if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
content = content.results[0];
content.facetHits.forEach(function(f) {
f.escapedValue = escapeFacetValue(f.value);
f.isRefined = isDisjunctive ? state.isDisjunctiveFacetRefined(facet, f.escapedValue) : state.isFacetRefined(facet, f.escapedValue);
});
return content;
}, function(e) {
self._currentNbQueries--;
if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
throw e;
});
};
/**
* Sets the text query used for the search.
*
* This method resets the current page to 0.
* @param {string} q the user query
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.setQuery = function(q) {
this._change({
state: this.state.resetPage().setQuery(q),
isPageReset: true
});
return this;
};
/**
* Remove all the types of refinements except tags. A string can be provided to remove
* only the refinements of a specific attribute. For more advanced use case, you can
* provide a function instead. This function should follow the
* [clearCallback definition](#SearchParameters.clearCallback).
*
* This method resets the current page to 0.
* @param {string} [name] optional name of the facet / attribute on which we want to remove all refinements
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
* @example
* // Removing all the refinements
* helper.clearRefinements().search();
* @example
* // Removing all the filters on a the category attribute.
* helper.clearRefinements('category').search();
* @example
* // Removing only the exclude filters on the category facet.
* helper.clearRefinements(function(value, attribute, type) {
* return type === 'exclude' && attribute === 'category';
* }).search();
*/ AlgoliaSearchHelper.prototype.clearRefinements = function(name) {
this._change({
state: this.state.resetPage().clearRefinements(name),
isPageReset: true
});
return this;
};
/**
* Remove all the tag filters.
*
* This method resets the current page to 0.
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.clearTags = function() {
this._change({
state: this.state.resetPage().clearTags(),
isPageReset: true
});
return this;
};
/**
* Adds a disjunctive filter to a faceted attribute with the `value` provided. If the
* filter is already set, it doesn't change the filters.
*
* This method resets the current page to 0.
* @param {string} facet the facet to refine
* @param {string} value the associated value (will be converted to string)
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.addDisjunctiveFacetRefinement = function(facet, value) {
this._change({
state: this.state.resetPage().addDisjunctiveFacetRefinement(facet, value),
isPageReset: true
});
return this;
};
// eslint-disable-next-line valid-jsdoc
/**
* @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addDisjunctiveFacetRefinement}
*/ AlgoliaSearchHelper.prototype.addDisjunctiveRefine = function() {
return this.addDisjunctiveFacetRefinement.apply(this, arguments);
};
/**
* Adds a refinement on a hierarchical facet. It will throw
* an exception if the facet is not defined or if the facet
* is already refined.
*
* This method resets the current page to 0.
* @param {string} facet the facet name
* @param {string} path the hierarchical facet path
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @throws Error if the facet is not defined or if the facet is refined
* @chainable
* @fires change
*/ AlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function(facet, path) {
this._change({
state: this.state.resetPage().addHierarchicalFacetRefinement(facet, path),
isPageReset: true
});
return this;
};
/**
* Adds a an numeric filter to an attribute with the `operator` and `value` provided. If the
* filter is already set, it doesn't change the filters.
*
* This method resets the current page to 0.
* @param {string} attribute the attribute on which the numeric filter applies
* @param {string} operator the operator of the filter
* @param {number} value the value of the filter
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.addNumericRefinement = function(attribute, operator, value) {
this._change({
state: this.state.resetPage().addNumericRefinement(attribute, operator, value),
isPageReset: true
});
return this;
};
/**
* Adds a filter to a faceted attribute with the `value` provided. If the
* filter is already set, it doesn't change the filters.
*
* This method resets the current page to 0.
* @param {string} facet the facet to refine
* @param {string} value the associated value (will be converted to string)
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.addFacetRefinement = function(facet, value) {
this._change({
state: this.state.resetPage().addFacetRefinement(facet, value),
isPageReset: true
});
return this;
};
// eslint-disable-next-line valid-jsdoc
/**
* @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetRefinement}
*/ AlgoliaSearchHelper.prototype.addRefine = function() {
return this.addFacetRefinement.apply(this, arguments);
};
/**
* Adds a an exclusion filter to a faceted attribute with the `value` provided. If the
* filter is already set, it doesn't change the filters.
*
* This method resets the current page to 0.
* @param {string} facet the facet to refine
* @param {string} value the associated value (will be converted to string)
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.addFacetExclusion = function(facet, value) {
this._change({
state: this.state.resetPage().addExcludeRefinement(facet, value),
isPageReset: true
});
return this;
};
// eslint-disable-next-line valid-jsdoc
/**
* @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetExclusion}
*/ AlgoliaSearchHelper.prototype.addExclude = function() {
return this.addFacetExclusion.apply(this, arguments);
};
/**
* Adds a tag filter with the `tag` provided. If the
* filter is already set, it doesn't change the filters.
*
* This method resets the current page to 0.
* @param {string} tag the tag to add to the filter
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.addTag = function(tag) {
this._change({
state: this.state.resetPage().addTagRefinement(tag),
isPageReset: true
});
return this;
};
/**
* Adds a "frequently bought together" recommendation query.
*
* @param {FrequentlyBoughtTogetherQuery} params the parameters for the recommendation
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.addFrequentlyBoughtTogether = function(params) {
this._recommendChange({
state: this.recommendState.addFrequentlyBoughtTogether(params)
});
return this;
};
/**
* Adds a "related products" recommendation query.
*
* @param {RelatedProductsQuery} params the parameters for the recommendation
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.addRelatedProducts = function(params) {
this._recommendChange({
state: this.recommendState.addRelatedProducts(params)
});
return this;
};
/**
* Adds a "trending items" recommendation query.
*
* @param {TrendingItemsQuery} params the parameters for the recommendation
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.addTrendingItems = function(params) {
this._recommendChange({
state: this.recommendState.addTrendingItems(params)
});
return this;
};
/**
* Adds a "trending facets" recommendation query.
*
* @param {TrendingFacetsQuery} params the parameters for the recommendation
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.addTrendingFacets = function(params) {
this._recommendChange({
state: this.recommendState.addTrendingFacets(params)
});
return this;
};
/**
* Adds a "looking similar" recommendation query.
*
* @param {LookingSimilarQuery} params the parameters for the recommendation
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.addLookingSimilar = function(params) {
this._recommendChange({
state: this.recommendState.addLookingSimilar(params)
});
return this;
};
/**
* Removes an numeric filter to an attribute with the `operator` and `value` provided. If the
* filter is not set, it doesn't change the filters.
*
* Some parameters are optional, triggering different behavior:
* - if the value is not provided, then all the numeric value will be removed for the
* specified attribute/operator couple.
* - if the operator is not provided either, then all the numeric filter on this attribute
* will be removed.
*
* This method resets the current page to 0.
* @param {string} attribute the attribute on which the numeric filter applies
* @param {string} [operator] the operator of the filter
* @param {number} [value] the value of the filter
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeNumericRefinement = function(attribute, operator, value) {
this._change({
state: this.state.resetPage().removeNumericRefinement(attribute, operator, value),
isPageReset: true
});
return this;
};
/**
* Removes a disjunctive filter to a faceted attribute with the `value` provided. If the
* filter is not set, it doesn't change the filters.
*
* If the value is omitted, then this method will remove all the filters for the
* attribute.
*
* This method resets the current page to 0.
* @param {string} facet the facet to refine
* @param {string} [value] the associated value
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeDisjunctiveFacetRefinement = function(facet, value) {
this._change({
state: this.state.resetPage().removeDisjunctiveFacetRefinement(facet, value),
isPageReset: true
});
return this;
};
// eslint-disable-next-line valid-jsdoc
/**
* @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeDisjunctiveFacetRefinement}
*/ AlgoliaSearchHelper.prototype.removeDisjunctiveRefine = function() {
return this.removeDisjunctiveFacetRefinement.apply(this, arguments);
};
/**
* Removes the refinement set on a hierarchical facet.
* @param {string} facet the facet name
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @throws Error if the facet is not defined or if the facet is not refined
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function(facet) {
this._change({
state: this.state.resetPage().removeHierarchicalFacetRefinement(facet),
isPageReset: true
});
return this;
};
/**
* Removes a filter to a faceted attribute with the `value` provided. If the
* filter is not set, it doesn't change the filters.
*
* If the value is omitted, then this method will remove all the filters for the
* attribute.
*
* This method resets the current page to 0.
* @param {string} facet the facet to refine
* @param {string} [value] the associated value
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeFacetRefinement = function(facet, value) {
this._change({
state: this.state.resetPage().removeFacetRefinement(facet, value),
isPageReset: true
});
return this;
};
// eslint-disable-next-line valid-jsdoc
/**
* @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetRefinement}
*/ AlgoliaSearchHelper.prototype.removeRefine = function() {
return this.removeFacetRefinement.apply(this, arguments);
};
/**
* Removes an exclusion filter to a faceted attribute with the `value` provided. If the
* filter is not set, it doesn't change the filters.
*
* If the value is omitted, then this method will remove all the filters for the
* attribute.
*
* This method resets the current page to 0.
* @param {string} facet the facet to refine
* @param {string} [value] the associated value
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeFacetExclusion = function(facet, value) {
this._change({
state: this.state.resetPage().removeExcludeRefinement(facet, value),
isPageReset: true
});
return this;
};
// eslint-disable-next-line valid-jsdoc
/**
* @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetExclusion}
*/ AlgoliaSearchHelper.prototype.removeExclude = function() {
return this.removeFacetExclusion.apply(this, arguments);
};
/**
* Removes a tag filter with the `tag` provided. If the
* filter is not set, it doesn't change the filters.
*
* This method resets the current page to 0.
* @param {string} tag tag to remove from the filter
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeTag = function(tag) {
this._change({
state: this.state.resetPage().removeTagRefinement(tag),
isPageReset: true
});
return this;
};
/**
* Removes a "frequently bought together" recommendation query.
*
* @param {number} id identifier of the recommendation widget
* @returns {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeFrequentlyBoughtTogether = function(id) {
this._recommendChange({
state: this.recommendState.removeParams(id)
});
return this;
};
/**
* Removes a "related products" recommendation query.
*
* @param {number} id identifier of the recommendation widget
* @returns {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeRelatedProducts = function(id) {
this._recommendChange({
state: this.recommendState.removeParams(id)
});
return this;
};
/**
* Removes a "trending items" recommendation query.
*
* @param {number} id identifier of the recommendation widget
* @returns {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeTrendingItems = function(id) {
this._recommendChange({
state: this.recommendState.removeParams(id)
});
return this;
};
/**
* Removes a "trending facets" recommendation query.
*
* @param {number} id identifier of the recommendation widget
* @returns {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeTrendingFacets = function(id) {
this._recommendChange({
state: this.recommendState.removeParams(id)
});
return this;
};
/**
* Removes a "looking similar" recommendation query.
*
* @param {number} id identifier of the recommendation widget
* @returns {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.removeLookingSimilar = function(id) {
this._recommendChange({
state: this.recommendState.removeParams(id)
});
return this;
};
/**
* Adds or removes an exclusion filter to a faceted attribute with the `value` provided. If
* the value is set then it removes it, otherwise it adds the filter.
*
* This method resets the current page to 0.
* @param {string} facet the facet to refine
* @param {string} value the associated value
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.toggleFacetExclusion = function(facet, value) {
this._change({
state: this.state.resetPage().toggleExcludeFacetRefinement(facet, value),
isPageReset: true
});
return this;
};
// eslint-disable-next-line valid-jsdoc
/**
* @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetExclusion}
*/ AlgoliaSearchHelper.prototype.toggleExclude = function() {
return this.toggleFacetExclusion.apply(this, arguments);
};
/**
* Adds or removes a filter to a faceted attribute with the `value` provided. If
* the value is set then it removes it, otherwise it adds the filter.
*
* This method can be used for conjunctive, disjunctive and hierarchical filters.
*
* This method resets the current page to 0.
* @param {string} facet the facet to refine
* @param {string} value the associated value
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @throws Error will throw an error if the facet is not declared in the settings of the helper
* @fires change
* @chainable
* @deprecated since version 2.19.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}
*/ AlgoliaSearchHelper.prototype.toggleRefinement = function(facet, value) {
return this.toggleFacetRefinement(facet, value);
};
/**
* Adds or removes a filter to a faceted attribute with the `value` provided. If
* the value is set then it removes it, otherwise it adds the filter.
*
* This method can be used for conjunctive, disjunctive and hierarchical filters.
*
* This method resets the current page to 0.
* @param {string} facet the facet to refine
* @param {string} value the associated value
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @throws Error will throw an error if the facet is not declared in the settings of the helper
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.toggleFacetRefinement = function(facet, value) {
this._change({
state: this.state.resetPage().toggleFacetRefinement(facet, value),
isPageReset: true
});
return this;
};
// eslint-disable-next-line valid-jsdoc
/**
* @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}
*/ AlgoliaSearchHelper.prototype.toggleRefine = function() {
return this.toggleFacetRefinement.apply(this, arguments);
};
/**
* Adds or removes a tag filter with the `value` provided. If
* the value is set then it removes it, otherwise it adds the filter.
*
* This method resets the current page to 0.
* @param {string} tag tag to remove or add
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.toggleTag = function(tag) {
this._change({
state: this.state.resetPage().toggleTagRefinement(tag),
isPageReset: true
});
return this;
};
/**
* Increments the page number by one.
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
* @example
* helper.setPage(0).nextPage().getPage();
* // returns 1
*/ AlgoliaSearchHelper.prototype.nextPage = function() {
var page = this.state.page || 0;
return this.setPage(page + 1);
};
/**
* Decrements the page number by one.
* @fires change
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @chainable
* @example
* helper.setPage(1).previousPage().getPage();
* // returns 0
*/ AlgoliaSearchHelper.prototype.previousPage = function() {
var page = this.state.page || 0;
return this.setPage(page - 1);
};
/**
* @private
* @param {number} page The page number
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @chainable
* @fires change
*/ function setCurrentPage(page) {
if (page < 0) throw new Error('Page requested below 0.');
this._change({
state: this.state.setPage(page),
isPageReset: false
});
return this;
}
/**
* Change the current page
* @deprecated
* @param {number} page The page number
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.setCurrentPage = setCurrentPage;
/**
* Updates the current page.
* @function
* @param {number} page The page number
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.setPage = setCurrentPage;
/**
* Updates the name of the index that will be targeted by the query.
*
* This method resets the current page to 0.
* @param {string} name the index name
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.setIndex = function(name) {
this._change({
state: this.state.resetPage().setIndex(name),
isPageReset: true
});
return this;
};
/**
* Update a parameter of the search. This method reset the page
*
* The complete list of parameters is available on the
* [Algolia website](https://www.algolia.com/doc/rest#query-an-index).
* The most commonly used parameters have their own [shortcuts](#query-parameters-shortcuts)
* or benefit from higher-level APIs (all the kind of filters and facets have their own API)
*
* This method resets the current page to 0.
* @param {string} parameter name of the parameter to update
* @param {any} value new value of the parameter
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
* @example
* helper.setQueryParameter('hitsPerPage', 20).search();
*/ AlgoliaSearchHelper.prototype.setQueryParameter = function(parameter, value) {
this._change({
state: this.state.resetPage().setQueryParameter(parameter, value),
isPageReset: true
});
return this;
};
/**
* Set the whole state (warning: will erase previous state)
* @param {SearchParameters} newState the whole new state
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @fires change
* @chainable
*/ AlgoliaSearchHelper.prototype.setState = function(newState) {
this._change({
state: SearchParameters.make(newState),
isPageReset: false
});
return this;
};
/**
* Override the current state without triggering a change event.
* Do not use this method unless you know what you are doing. (see the example
* for a legit use case)
* @param {SearchParameters} newState the whole new state
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
* @example
* helper.on('change', function(state){
* // In this function you might want to find a way to store the state in the url/history
* updateYourURL(state)
* })
* window.onpopstate = function(event){
* // This is naive though as you should check if the state is really defined etc.
* helper.overrideStateWithoutTriggeringChangeEvent(event.state).search()
* }
* @chainable
*/ AlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function(newState) {
this.state = new SearchParameters(newState);
return this;
};
/**
* Check if an attribute has any numeric, conjunctive, disjunctive or hierarchical filters.
* @param {string} attribute the name of the attribute
* @return {boolean} true if the attribute is filtered by at least one value
* @example
* // hasRefinements works with numeric, conjunctive, disjunctive and hierarchical filters
* helper.hasRefinements('price'); // false
* helper.addNumericRefinement('price', '>', 100);
* helper.hasRefinements('price'); // true
*
* helper.hasRefinements('color'); // false
* helper.addFacetRefinement('color', 'blue');
* helper.hasRefinements('color'); // true
*
* helper.hasRefinements('material'); // false
* helper.addDisjunctiveFacetRefinement('material', 'plastic');
* helper.hasRefinements('material'); // true
*
* helper.hasRefinements('categories'); // false
* helper.toggleFacetRefinement('categories', 'kitchen > knife');
* helper.hasRefinements('categories'); // true
*
*/ AlgoliaSearchHelper.prototype.hasRefinements = function(attribute) {
if (objectHasKeys(this.state.getNumericRefinements(attribute))) {
return true;
} else if (this.state.isConjunctiveFacet(attribute)) {
return this.state.isFacetRefined(attribute);
} else if (this.state.isDisjunctiveFacet(attribute)) {
return this.state.isDisjunctiveFacetRefined(attribute);
} else if (this.state.isHierarchicalFacet(attribute)) {
return this.state.isHierarchicalFacetRefined(attribute);
}
// there's currently no way to know that the user did call `addNumericRefinement` at some point
// thus we cannot distinguish if there once was a numeric refinement that was cleared
// so we will return false in every other situations to be consistent
// while what we should do here is throw because we did not find the attribute in any type
// of refinement
return false;
};
/**
* Check if a value is excluded for a specific faceted attribute. If the value
* is omitted then the function checks if there is any excluding refinements.
*
* @param {string} facet name of the attribute for used for faceting
* @param {string} [value] optional value. If passed will test that this value
* is filtering the given facet.
* @return {boolean} true if refined
* @example
* helper.isExcludeRefined('color'); // false
* helper.isExcludeRefined('color', 'blue') // false
* helper.isExcludeRefined('color', 'red') // false
*
* helper.addFacetExclusion('color', 'red');
*
* helper.isExcludeRefined('color'); // true
* helper.isExcludeRefined('color', 'blue') // false
* helper.isExcludeRefined('color', 'red') // true
*/ AlgoliaSearchHelper.prototype.isExcluded = function(facet, value) {
return this.state.isExcludeRefined(facet, value);
};
// eslint-disable-next-line valid-jsdoc
/**
* @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasRefinements}
*/ AlgoliaSearchHelper.prototype.isDisjunctiveRefined = function(facet, value) {
return this.state.isDisjunctiveFacetRefined(facet, value);
};
/**
* Check if the string is a currently filtering tag.
* @param {string} tag tag to check
* @return {boolean} true if the tag is currently refined
*/ AlgoliaSearchHelper.prototype.hasTag = function(tag) {
return this.state.isTagRefined(tag);
};
// eslint-disable-next-line valid-jsdoc
/**
* @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasTag}
*/ AlgoliaSearchHelper.prototype.isTagRefined = function() {
return this.hasTagRefinements.apply(this, arguments);
};
/**
* Get the name of the currently used index.
* @return {string} name of the index
* @example
* helper.setIndex('highestPrice_products').getIndex();
* // returns 'highestPrice_products'
*/ AlgoliaSearchHelper.prototype.getIndex = function() {
return this.state.index;
};
function getCurrentPage() {
return this.state.page;
}
/**
* Get the currently selected page
* @deprecated
* @return {number} the current page
*/ AlgoliaSearchHelper.prototype.getCurrentPage = getCurrentPage;
/**
* Get the currently selected page
* @function
* @return {number} the current page
*/ AlgoliaSearchHelper.prototype.getPage = getCurrentPage;
/**
* Get all the tags currently set to filters the results.
*
* @return {string[]} The list of tags currently set.
*/ AlgoliaSearchHelper.prototype.getTags = function() {
return this.state.tagRefinements;
};
/**
* Get the list of refinements for a given attribute. This method works with
* conjunctive, disjunctive, excluding and numerical filters.
*
* See also SearchResults#getRefinements
*
* @param {string} facetName attribute name used for faceting
* @return {Array.<FacetRefinement|NumericRefinement>} All Refinement are objects that contain a value, and
* a type. Numeric also contains an operator.
* @example
* helper.addNumericRefinement('price', '>', 100);
* helper.getRefinements('price');
* // [
* // {
* // "value": [
* // 100
* // ],
* // "operator": ">",
* // "type": "numeric"
* // }
* // ]
* @example
* helper.addFacetRefinement('color', 'blue');
* helper.addFacetExclusion('color', 'red');
* helper.getRefinements('color');
* // [
* // {
* // "value": "blue",
* // "type": "conjunctive"
* // },
* // {
* // "value": "red",
* // "type": "exclude"
* // }
* // ]
* @example
* helper.addDisjunctiveFacetRefinement('material', 'plastic');
* // [
* // {
* // "value": "plastic",
* // "type": "disjunctive"
* // }
* // ]
*/ AlgoliaSearchHelper.prototype.getRefinements = function(facetName) {
var refinements = [];
if (this.state.isConjunctiveFacet(facetName)) {
var conjRefinements = this.state.getConjunctiveRefinements(facetName);
conjRefinements.forEach(function(r) {
refinements.push({
value: r,
type: 'conjunctive'
});
});
var excludeRefinements = this.state.getExcludeRefinements(facetName);
excludeRefinements.forEach(function(r) {
refinements.push({
value: r,
type: 'exclude'
});
});
} else if (this.state.isDisjunctiveFacet(facetName)) {
var disjunctiveRefinements = this.state.getDisjunctiveRefinements(facetName);
disjunctiveRefinements.forEach(function(r) {
refinements.push({
value: r,
type: 'disjunctive'
});
});
}
var numericRefinements = this.state.getNumericRefinements(facetName);
Object.keys(numericRefinements).forEach(function(operator) {
var value = numericRefinements[operator];
refinements.push({
value: value,
operator: operator,
type: 'numeric'
});
});
return refinements;
};
/**
* Return the current refinement for the (attribute, operator)
* @param {string} attribute attribute in the record
* @param {string} operator operator applied on the refined values
* @return {Array.<number|number[]>} refined values
*/ AlgoliaSearchHelper.prototype.getNumericRefinement = function(attribute, operator) {
return this.state.getNumericRefinement(attribute, operator);
};
/**
* Get the current breadcrumb for a hierarchical facet, as an array
* @param {string} facetName Hierarchical facet name
* @return {array.<string>} the path as an array of string
*/ AlgoliaSearchHelper.prototype.getHierarchicalFacetBreadcrumb = function(facetName) {
return this.state.getHierarchicalFacetBreadcrumb(facetName);
};
// /////////// PRIVATE
/**
* Perform the underlying queries
* @private
* @param {object} options options for the query
* @param {boolean} [options.onlyWithDerivedHelpers=false] if true, only the derived helpers will be queried
* @return {undefined} does not return anything
* @fires search
* @fires result
* @fires error
*/ AlgoliaSearchHelper.prototype._search = function(options) {
var state = this.state;
var states = [];
var mainQueries = [];
if (!options.onlyWithDerivedHelpers) {
mainQueries = requestBuilder._getQueries(state.index, state);
states.push({
state: state,
queriesCount: mainQueries.length,
helper: this
});
this.emit('search', {
state: state,
results: this.lastResults
});
}
var derivedQueries = this.derivedHelpers.map(function(derivedHelper) {
var derivedState = derivedHelper.getModifiedState(state);
var derivedStateQueries = derivedState.index ? requestBuilder._getQueries(derivedState.index, derivedState) : [];
states.push({
state: derivedState,
queriesCount: derivedStateQueries.length,
helper: derivedHelper
});
derivedHelper.emit('search', {
state: derivedState,
results: derivedHelper.lastResults
});
return derivedStateQueries;
});
var queries = Array.prototype.concat.apply(mainQueries, derivedQueries);
var queryId = this._queryId++;
this._currentNbQueries++;
if (!queries.length) {
return Promise.resolve({
results: []
}).then(this._dispatchAlgoliaResponse.bind(this, states, queryId));
}
try {
this.client.search(queries).then(this._dispatchAlgoliaResponse.bind(this, states, queryId)).catch(this._dispatchAlgoliaError.bind(this, queryId));
} catch (error) {
// If we reach this part, we're in an internal error state
this.emit('error', {
error: error
});
}
return undefined;
};
/**
* Perform the underlying queries
* @private
* @param {boolean} [options.onlyWithDerivedHelpers=false] if true, only the derived helpers will be queried
* @return {undefined} does not return anything
* @fires search
* @fires result
* @fires error
*/ AlgoliaSearchHelper.prototype._runComposition = function() {
var state = this.state;
var states = [];
var mainQueries = [];
var derivedQueries = this.derivedHelpers.map(function(derivedHelper) {
var derivedState = derivedHelper.getModifiedState(state);
var derivedStateQueries = requestBuilder._getCompositionQueries(derivedState);
states.push({
state: derivedState,
helper: derivedHelper
});
derivedHelper.emit('search', {
state: derivedState,
results: derivedHelper.lastResults
});
return derivedStateQueries;
});
var queries = Array.prototype.concat.apply(mainQueries, derivedQueries);
var queryId = this._queryId++;
this._currentNbQueries++;
if (!queries.length) {
return Promise.resolve({
results: []
}).then(this._dispatchAlgoliaResponse.bind(this, states, queryId));
}
if (queries.length > 1) {
throw new Error('Only one query is allowed when using a composition.');
}
var query = queries[0];
try {
this.client.search(query).then(this._dispatchAlgoliaResponse.bind(this, states, queryId)).catch(this._dispatchAlgoliaError.bind(this, queryId));
} catch (error) {
// If we reach this part, we're in an internal error state
this.emit('error', {
error: error
});
}
return undefined;
};
AlgoliaSearchHelper.prototype._recommend = function() {
var searchState = this.state;
var recommendState = this.recommendState;
var index = this.getIndex();
var states = [
{
state: recommendState,
index: index,
helper: this
}
];
var ids = recommendState.params.map(function(param) {
return param.$$id;
});
this.emit('fetch', {
recommend: {
state: recommendState,
results: this.lastRecommendResults
}
});
var cache = this._recommendCache;
var derivedQueries = this.derivedHelpers.map(function(derivedHelper) {
var derivedIndex = derivedHelper.getModifiedState(searchState).index;
if (!derivedIndex) {
return [];
}
// Contrary to what is done when deriving the search state, we don't want to
// provide the current recommend state to the derived helper, as it would
// inherit unwanted queries. We instead provide an empty recommend state.
var derivedState = derivedHelper.getModifiedRecommendState(new RecommendParameters());
states.push({
state: derivedState,
index: derivedIndex,
helper: derivedHelper
});
ids = Array.prototype.concat.apply(ids, derivedState.params.map(function(param) {
return param.$$id;
}));
derivedHelper.emit('fetch', {
recommend: {
state: derivedState,
results: derivedHelper.lastRecommendResults
}
});
return derivedState._buildQueries(derivedIndex, cache);
});
var queries = Array.prototype.concat.apply(this.recommendState._buildQueries(index, cache), derivedQueries);
if (queries.length === 0) {
return;
}
if (queries.length > 0 && typeof this.client.getRecommendations === 'undefined') {
// eslint-disable-next-line no-console
console.warn('Please update algoliasearch/lite to the latest version in order to use recommend widgets.');
return;
}
var queryId = this._recommendQueryId++;
this._currentNbRecommendQueries++;
try {
this.client.getRecommendations(queries).then(this._dispatchRecommendResponse.bind(this, queryId, states, ids)).catch(this._dispatchRecommendError.bind(this, queryId));
} catch (error) {
// If we reach this part, we're in an internal error state
this.emit('error', {
error: error
});
}
return;
};
/**
* Transform the responses as sent by the server and transform them into a user
* usable object that merge the results of all the batch requests. It will dispatch
* over the different helper + derived helpers (when there are some).
* @private
* @param {array.<{SearchParameters, AlgoliaQueries, AlgoliaSearchHelper}>} states state used to generate the request
* @param {number} queryId id of the current request
* @param {object} content content of the response
* @return {undefined}
*/ AlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function(states, queryId, content) {
// eslint-disable-next-line consistent-this
var self = this;
// @TODO remove the number of outdated queries discarded instead of just one
if (queryId < this._lastQueryIdReceived) {
// Outdated answer
return;
}
this._currentNbQueries -= queryId - this._lastQueryIdReceived;
this._lastQueryIdReceived = queryId;
if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');
var results = content.results.slice();
var rawContent = Object.keys(content).reduce(function(value, key) {
if (key !== 'results') value[key] = content[key];
return value;
}, {});
if (Object.keys(rawContent).length <= 0) {
rawContent = undefined;
}
states.forEach(function(s) {
var state = s.state;
var queriesCount = s.queriesCount;
var helper = s.helper;
var specificResults = queriesCount !== undefined ? results.splice(0, queriesCount) : results;
if (!state.index) {
helper.emit('result', {
results: null,
state: state
});
return;
}
// Multifeed composition: build ordered SearchResults array on lastResults
if (specificResults.length > 0 && specificResults[0].feedID) {
var feeds = specificResults.map(function(r) {
var sr = new SearchResults(state, [
r
], self._searchResultsOptions);
if (rawContent !== undefined) sr._rawContent = rawContent;
return sr;
});
helper.lastResults = new SearchResults(state, [
specificResults[0]
], self._searchResultsOptions);
helper.lastResults.feeds = feeds;
if (rawContent !== undefined) helper.lastResults._rawContent = rawContent;
} else {
helper.lastResults = new SearchResults(state, specificResults, self._searchResultsOptions);
if (rawContent !== undefined) helper.lastResults._rawContent = rawContent;
}
helper.emit('result', {
results: helper.lastResults,
state: state
});
});
};
AlgoliaSearchHelper.prototype._dispatchRecommendResponse = function(queryId, states, ids, content) {
// @TODO remove the number of outdated queries discarded instead of just one
if (queryId < this._lastRecommendQueryIdReceived) {
// Outdated answer
return;
}
this._currentNbRecommendQueries -= queryId - this._lastRecommendQueryIdReceived;
this._lastRecommendQueryIdReceived = queryId;
if (this._currentNbRecommendQueries === 0) this.emit('recommendQueueEmpty');
var cache = this._recommendCache;
var idsMap = {};
ids.filter(function(id) {
return cache[id] === undefined;
}).forEach(function(id, index) {
if (!idsMap[id]) idsMap[id] = [];
idsMap[id].push(index);
});
Object.keys(idsMap).forEach(function(id) {
var indices = idsMap[id];
var firstResult = content.results[indices[0]];
if (indices.length === 1) {
cache[id] = firstResult;
return;
}
cache[id] = Object.assign({}, firstResult, {
hits: sortAndMergeRecommendations(ids, indices.map(function(idx) {
return content.results[idx].hits;
}))
});
});
var results = {};
ids.forEach(function(id) {
results[id] = cache[id];
});
states.forEach(function(s) {
var state = s.state;
var helper = s.helper;
if (!s.index) {
// eslint-disable-next-line no-warning-comments
// TODO: emit "result" event when events for Recommend are implemented
helper.emit('recommend:result', {
results: null,
state: state
});
return;
}
helper.lastRecommendResults = new RecommendResults(state, results);
// eslint-disable-next-line no-warning-comments
// TODO: emit "result" event when events for Recommend are implemented
helper.emit('recommend:result', {
recommend: {
results: helper.lastRecommendResults,
state: state
}
});
});
};
AlgoliaSearchHelper.prototype._dispatchAlgoliaError = function(queryId, error) {
if (queryId < this._lastQueryIdReceived) {
// Outdated answer
return;
}
this._currentNbQueries -= queryId - this._lastQueryIdReceived;
this._lastQueryIdReceived = queryId;
this.emit('error', {
error: error
});
if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');
};
AlgoliaSearchHelper.prototype._dispatchRecommendError = function(queryId, error) {
if (queryId < this._lastRecommendQueryIdReceived) {
// Outdated answer
return;
}
this._currentNbRecommendQueries -= queryId - this._lastRecommendQueryIdReceived;
this._lastRecommendQueryIdReceived = queryId;
this.emit('error', {
error: error
});
if (this._currentNbRecommendQueries === 0) this.emit('recommendQueueEmpty');
};
AlgoliaSearchHelper.prototype.containsRefinement = function(query, facetFilters, numericFilters, tagFilters) {
return query || facetFilters.length !== 0 || numericFilters.length !== 0 || tagFilters.length !== 0;
};
/**
* Test if there are some disjunctive refinements on the facet
* @private
* @param {string} facet the attribute to test
* @return {boolean} true if there are refinements on this attribute
*/ AlgoliaSearchHelper.prototype._hasDisjunctiveRefinements = function(facet) {
return this.state.disjunctiveRefinements[facet] && this.state.disjunctiveRefinements[facet].length > 0;
};
AlgoliaSearchHelper.prototype._change = function(event) {
var state = event.state;
var isPageReset = event.isPageReset;
if (state !== this.state) {
this.state = state;
this.emit('change', {
state: this.state,
results: this.lastResults,
isPageReset: isPageReset
});
}
};
AlgoliaSearchHelper.prototype._recommendChange = function(event) {
var state = event.state;
if (state !== this.recommendState) {
this.recommendState = state;
// eslint-disable-next-line no-warning-comments
// TODO: emit "change" event when events for Recommend are implemented
this.emit('recommend:change', {
search: {
results: this.lastResults,
state: this.state
},
recommend: {
results: this.lastRecommendResults,
state: this.recommendState
}
});
}
};
/**
* Clears the cache of the underlying Algolia client.
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
*/ AlgoliaSearchHelper.prototype.clearCache = function() {
if (this.client.clearCache) this.client.clearCache();
return this;
};
/**
* Updates the internal client instance. If the reference of the clients
* are equal then no update is actually done.
* @param {AlgoliaSearch} newClient an AlgoliaSearch client
* @return {AlgoliaSearchHelper} Method is chainable, it returns itself
*/ AlgoliaSearchHelper.prototype.setClient = function(newClient) {
if (this.client === newClient) return this;
if (typeof newClient.addAlgoliaAgent === 'function') {
newClient.addAlgoliaAgent('JS Helper (' + version + ')');
}
this.client = newClient;
return this;
};
/**
* Gets the instance of the currently used client.
* @return {AlgoliaSearch} the currently used client
*/ AlgoliaSearchHelper.prototype.getClient = function() {
return this.client;
};
/**
* Creates an derived instance of the Helper. A derived helper
* is a way to request other indices synchronised with the lifecycle
* of the main Helper. This mechanism uses the multiqueries feature
* of Algolia to aggregate all the requests in a single network call.
*
* This method takes a function that is used to create a new SearchParameter
* that will be used to create requests to Algolia. Those new requests
* are created just before the `search` event. The signature of the function
* is `SearchParameters -> SearchParameters`.
*
* This method returns a new DerivedHelper which is an EventEmitter
* that fires the same `search`, `result` and `error` events. Those
* events, however, will receive data specific to this DerivedHelper
* and the SearchParameters that is returned by the call of the
* parameter function.
* @param {function} fn SearchParameters -> SearchParameters
* @param {function} recommendFn RecommendParameters -> RecommendParameters
* @return {DerivedHelper} a new DerivedHelper
*/ AlgoliaSearchHelper.prototype.derive = function(fn, recommendFn) {
var derivedHelper = new DerivedHelper(this, fn, recommendFn);
this.derivedHelpers.push(derivedHelper);
return derivedHelper;
};
/**
* This method detaches a derived Helper from the main one. Prefer using the one from the
* derived helper itself, to remove the event listeners too.
* @private
* @param {DerivedHelper} derivedHelper the derived helper to detach
* @return {undefined} nothing is returned
* @throws Error
*/ AlgoliaSearchHelper.prototype.detachDerivedHelper = function(derivedHelper) {
var pos = this.derivedHelpers.indexOf(derivedHelper);
if (pos === -1) throw new Error('Derived helper already detached');
this.derivedHelpers.splice(pos, 1);
};
/**
* This method returns true if there is currently at least one on-going search.
* @return {boolean} true if there is a search pending
*/ AlgoliaSearchHelper.prototype.hasPendingRequests = function() {
return this._currentNbQueries > 0;
};
/**
* @typedef AlgoliaSearchHelper.NumericRefinement
* @type {object}
* @property {number[]} value the numbers that are used for filtering this attribute with
* the operator specified.
* @property {string} operator the faceting data: value, number of entries
* @property {string} type will be 'numeric'
*/ /**
* @typedef AlgoliaSearchHelper.FacetRefinement
* @type {object}
* @property {string} value the string use to filter the attribute
* @property {string} type the type of filter: 'conjunctive', 'disjunctive', 'exclude'
*/ algoliasearch_helper = AlgoliaSearchHelper;
return algoliasearch_helper;
}
var algoliasearchHelper_1;
var hasRequiredAlgoliasearchHelper;
function requireAlgoliasearchHelper() {
if (hasRequiredAlgoliasearchHelper) return algoliasearchHelper_1;
hasRequiredAlgoliasearchHelper = 1;
var AlgoliaSearchHelper = requireAlgoliasearch_helper();
var RecommendParameters = requireRecommendParameters();
var RecommendResults = requireRecommendResults();
var SearchParameters = requireSearchParameters();
var SearchResults = requireSearchResults();
/**
* The algoliasearchHelper module is the function that will let its
* contains everything needed to use the Algoliasearch
* Helper. It is a also a function that instanciate the helper.
* To use the helper, you also need the Algolia JS client v3.
* @example
* //using the UMD build
* var client = algoliasearch('latency', '6be0576ff61c053d5f9a3225e2a90f76');
* var helper = algoliasearchHelper(client, 'bestbuy', {
* facets: ['shipping'],
* disjunctiveFacets: ['category']
* });
* helper.on('result', function(event) {
* console.log(event.results);
* });
* helper
* .toggleFacetRefinement('category', 'Movies & TV Shows')
* .toggleFacetRefinement('shipping', 'Free shipping')
* .search();
* @example
* // The helper is an event emitter using the node API
* helper.on('result', updateTheResults);
* helper.once('result', updateTheResults);
* helper.removeListener('result', updateTheResults);
* helper.removeAllListeners('result');
* @module algoliasearchHelper
* @param {AlgoliaSearch} client an AlgoliaSearch client
* @param {string} index the name of the index to query
* @param {SearchParameters|object} opts an object defining the initial config of the search. It doesn't have to be a {SearchParameters}, just an object containing the properties you need from it.
* @param {SearchResultsOptions|object} searchResultsOptions an object defining the options to use when creating the search results.
* @return {AlgoliaSearchHelper} The helper instance
*/ function algoliasearchHelper(client, index, opts, searchResultsOptions) {
return new AlgoliaSearchHelper(client, index, opts, searchResultsOptions);
}
/**
* The version currently used
* @member module:algoliasearchHelper.version
* @type {number}
*/ algoliasearchHelper.version = requireVersion();
/**
* Constructor for the Helper.
* @member module:algoliasearchHelper.AlgoliaSearchHelper
* @type {AlgoliaSearchHelper}
*/ algoliasearchHelper.AlgoliaSearchHelper = AlgoliaSearchHelper;
/**
* Constructor for the object containing all the parameters of the search.
* @member module:algoliasearchHelper.SearchParameters
* @type {SearchParameters}
*/ algoliasearchHelper.SearchParameters = SearchParameters;
/**
* Constructor for the object containing all the parameters for Recommend.
* @member module:algoliasearchHelper.RecommendParameters
* @type {RecommendParameters}
*/ algoliasearchHelper.RecommendParameters = RecommendParameters;
/**
* Constructor for the object containing the results of the search.
* @member module:algoliasearchHelper.SearchResults
* @type {SearchResults}
*/ algoliasearchHelper.SearchResults = SearchResults;
/**
* Constructor for the object containing the results for Recommend.
* @member module:algoliasearchHelper.RecommendResults
* @type {RecommendResults}
*/ algoliasearchHelper.RecommendResults = RecommendResults;
algoliasearchHelper_1 = algoliasearchHelper;
return algoliasearchHelper_1;
}
var algoliasearchHelperExports = requireAlgoliasearchHelper();
var algoliasearchHelper = /*@__PURE__*/getDefaultExportFromCjs(algoliasearchHelperExports);
/**
* This implementation is taken from Lodash implementation.
* See: https://github.com/lodash/lodash/blob/master/isPlainObject.js
*/ function getTag(value) {
if (value === null) {
return value === undefined ? '[object Undefined]' : '[object Null]';
}
return Object.prototype.toString.call(value);
}
function isObjectLike(value) {
return (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && value !== null;
}
/**
* Checks if `value` is a plain object.
*
* A plain object is an object created by the `Object`
* constructor or with a `[[Prototype]]` of `null`.
*/ function isPlainObject(value) {
if (!isObjectLike(value) || getTag(value) !== '[object Object]') {
return false;
}
if (Object.getPrototypeOf(value) === null) {
return true;
}
var proto = value;
while(Object.getPrototypeOf(proto) !== null){
proto = Object.getPrototypeOf(proto);
}
return Object.getPrototypeOf(value) === proto;
}
function createDocumentationLink(param) {
var name = param.name, _param_connector = param.connector, connector = _param_connector === void 0 ? false : _param_connector;
return [
'https://www.algolia.com/doc/api-reference/widgets/',
name,
'/js/',
connector ? '#connector' : ''
].join('');
}
function createDocumentationMessageGenerator() {
for(var _len = arguments.length, widgets = new Array(_len), _key = 0; _key < _len; _key++){
widgets[_key] = arguments[_key];
}
var links = widgets.map(function(widget) {
return createDocumentationLink(widget);
}).join(', ');
return function(message) {
return [
message,
"See documentation: ".concat(links)
].filter(Boolean).join('\n\n');
};
}
function _object_without_properties_loose(source, excluded) {
if (source == null) return {};
var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
target[key] = source[key];
}
return target;
}
function _object_without_properties(source, excluded) {
if (source == null) return {};
var target = {}, sourceKeys, key, i;
if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
sourceKeys = Reflect.ownKeys(source);
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
target[key] = source[key];
}
return target;
}
target = _object_without_properties_loose(source, excluded);
if (Object.getOwnPropertySymbols) {
sourceKeys = Object.getOwnPropertySymbols(source);
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
target[key] = source[key];
}
}
return target;
}
// We aren't using the native `Array.prototype.findIndex` because the refactor away from Lodash is not
// published as a major version.
// Relying on the `findIndex` polyfill on user-land, which before was only required for niche use-cases,
// was decided as too risky.
// @MAJOR Replace with the native `Array.prototype.findIndex` method
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex
function findIndex(array, comparator) {
if (!Array.isArray(array)) {
return -1;
}
for(var i = 0; i < array.length; i++){
if (comparator(array[i])) {
return i;
}
}
return -1;
}
function uniq(array) {
return array.filter(function(value, index, self) {
return self.indexOf(value) === index;
});
}
var mergeWithRest = function mergeWithRest(left, right) {
right.facets;
right.disjunctiveFacets;
right.facetsRefinements;
right.facetsExcludes;
right.disjunctiveFacetsRefinements;
right.numericRefinements;
right.tagRefinements;
right.hierarchicalFacets;
right.hierarchicalFacetsRefinements;
right.ruleContexts;
var rest = _object_without_properties(right, [
"facets",
"disjunctiveFacets",
"facetsRefinements",
"facetsExcludes",
"disjunctiveFacetsRefinements",
"numericRefinements",
"tagRefinements",
"hierarchicalFacets",
"hierarchicalFacetsRefinements",
"ruleContexts"
]);
return left.setQueryParameters(rest);
};
// Merge facets
var mergeFacets = function mergeFacets(left, right) {
return right.facets.reduce(function(_, name) {
return _.addFacet(name);
}, left);
};
var mergeDisjunctiveFacets = function mergeDisjunctiveFacets(left, right) {
return right.disjunctiveFacets.reduce(function(_, name) {
return _.addDisjunctiveFacet(name);
}, left);
};
var mergeHierarchicalFacets = function mergeHierarchicalFacets(left, right) {
return left.setQueryParameters({
hierarchicalFacets: right.hierarchicalFacets.reduce(function(facets, facet) {
var index = findIndex(facets, function(_) {
return _.name === facet.name;
});
if (index === -1) {
return facets.concat(facet);
}
var nextFacets = facets.slice();
nextFacets.splice(index, 1, facet);
return nextFacets;
}, left.hierarchicalFacets)
});
};
// Merge facet refinements
var mergeTagRefinements = function mergeTagRefinements(left, right) {
return right.tagRefinements.reduce(function(_, value) {
return _.addTagRefinement(value);
}, left);
};
var mergeFacetRefinements = function mergeFacetRefinements(left, right) {
return left.setQueryParameters({
facetsRefinements: _object_spread({}, left.facetsRefinements, right.facetsRefinements)
});
};
var mergeFacetsExcludes = function mergeFacetsExcludes(left, right) {
return left.setQueryParameters({
facetsExcludes: _object_spread({}, left.facetsExcludes, right.facetsExcludes)
});
};
var mergeDisjunctiveFacetsRefinements = function mergeDisjunctiveFacetsRefinements(left, right) {
return left.setQueryParameters({
disjunctiveFacetsRefinements: _object_spread({}, left.disjunctiveFacetsRefinements, right.disjunctiveFacetsRefinements)
});
};
var mergeNumericRefinements = function mergeNumericRefinements(left, right) {
return left.setQueryParameters({
numericRefinements: _object_spread({}, left.numericRefinements, right.numericRefinements)
});
};
var mergeHierarchicalFacetsRefinements = function mergeHierarchicalFacetsRefinements(left, right) {
return left.setQueryParameters({
hierarchicalFacetsRefinements: _object_spread({}, left.hierarchicalFacetsRefinements, right.hierarchicalFacetsRefinements)
});
};
var mergeRuleContexts = function mergeRuleContexts(left, right) {
var ruleContexts = uniq([].concat(left.ruleContexts).concat(right.ruleContexts).filter(Boolean));
if (ruleContexts.length > 0) {
return left.setQueryParameters({
ruleContexts: ruleContexts
});
}
return left;
};
var mergeSearchParameters = function mergeSearchParameters() {
for(var _len = arguments.length, parameters = new Array(_len), _key = 0; _key < _len; _key++){
parameters[_key] = arguments[_key];
}
return parameters.reduce(function(left, right) {
var hierarchicalFacetsRefinementsMerged = mergeHierarchicalFacetsRefinements(left, right);
var hierarchicalFacetsMerged = mergeHierarchicalFacets(hierarchicalFacetsRefinementsMerged, right);
var tagRefinementsMerged = mergeTagRefinements(hierarchicalFacetsMerged, right);
var numericRefinementsMerged = mergeNumericRefinements(tagRefinementsMerged, right);
var disjunctiveFacetsRefinementsMerged = mergeDisjunctiveFacetsRefinements(numericRefinementsMerged, right);
var facetsExcludesMerged = mergeFacetsExcludes(disjunctiveFacetsRefinementsMerged, right);
var facetRefinementsMerged = mergeFacetRefinements(facetsExcludesMerged, right);
var disjunctiveFacetsMerged = mergeDisjunctiveFacets(facetRefinementsMerged, right);
var ruleContextsMerged = mergeRuleContexts(disjunctiveFacetsMerged, right);
var facetsMerged = mergeFacets(ruleContextsMerged, right);
return mergeWithRest(facetsMerged, right);
});
};
function noop() {
for(var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++){
_args[_key] = arguments[_key];
}
}
var withUsage$x = createDocumentationMessageGenerator({
name: 'configure',
connector: true
});
function getInitialSearchParameters(state, widgetParams) {
// We leverage the helper internals to remove the `widgetParams` from
// the state. The function `setQueryParameters` omits the values that
// are `undefined` on the next state.
return state.setQueryParameters(Object.keys(widgetParams.searchParameters).reduce(function(acc, key) {
return _object_spread_props(_object_spread({}, acc), _define_property({}, key, undefined));
}, {}));
}
var connectConfigure = function connectConfigure() {
var renderFn = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : noop, unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
return function(widgetParams) {
if (!widgetParams || !isPlainObject(widgetParams.searchParameters)) {
throw new Error(withUsage$x('The `searchParameters` option expects an object.'));
}
var connectorState = {};
function refine(helper) {
return function(searchParameters) {
// Merge new `searchParameters` with the ones set from other widgets
var actualState = getInitialSearchParameters(helper.state, widgetParams);
var nextSearchParameters = mergeSearchParameters(actualState, new algoliasearchHelper.SearchParameters(searchParameters));
// Update original `widgetParams.searchParameters` to the new refined one
widgetParams.searchParameters = searchParameters;
// Trigger a search with the resolved search parameters
helper.setState(nextSearchParameters).search();
};
}
return {
$$type: 'ais.configure',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
return getInitialSearchParameters(state, widgetParams);
},
getRenderState: function getRenderState(renderState, renderOptions) {
var _renderState_configure;
var widgetRenderState = this.getWidgetRenderState(renderOptions);
return _object_spread_props(_object_spread({}, renderState), {
configure: _object_spread_props(_object_spread({}, widgetRenderState), {
widgetParams: _object_spread_props(_object_spread({}, widgetRenderState.widgetParams), {
searchParameters: mergeSearchParameters(new algoliasearchHelper.SearchParameters((_renderState_configure = renderState.configure) === null || _renderState_configure === void 0 ? void 0 : _renderState_configure.widgetParams.searchParameters), new algoliasearchHelper.SearchParameters(widgetRenderState.widgetParams.searchParameters)).getQueryParams()
})
})
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var helper = param.helper;
if (!connectorState.refine) {
connectorState.refine = refine(helper);
}
return {
refine: connectorState.refine,
widgetParams: widgetParams
};
},
getWidgetSearchParameters: function getWidgetSearchParameters(state, param) {
var uiState = param.uiState;
return mergeSearchParameters(state, new algoliasearchHelper.SearchParameters(_object_spread({}, uiState.configure, widgetParams.searchParameters)));
},
getWidgetUiState: function getWidgetUiState(uiState) {
return _object_spread_props(_object_spread({}, uiState), {
configure: _object_spread({}, uiState.configure, widgetParams.searchParameters)
});
}
};
};
};
function _array_with_holes(arr) {
if (Array.isArray(arr)) return arr;
}
function _iterable_to_array_limit(arr, i) {
var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
if (_i == null) return;
var _arr = [];
var _n = true;
var _d = false;
var _s, _e;
try {
for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i["return"] != null) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
function _non_iterable_rest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _array_like_to_array(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _unsupported_iterable_to_array(o, minLen) {
if (!o) return;
if (typeof o === "string") return _array_like_to_array(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(n);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
function _sliced_to_array(arr, i) {
return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
}
function _iterable_to_array(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
return Array.from(iter);
}
}
function _to_array(arr) {
return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_rest();
}
/* eslint-disable complexity */ /*
* Code taken from dequal/lite v2.0.0
* https://github.com/lukeed/dequal/blob/9aa73181ac7e081cd330cac67d313632ac04bb02/src/lite.js
*
* It adds a 3rd argument `compare(a, b)` that lets execute custom logic to
* compare values.
* We use it to skip comparing function references.
*/ // eslint-disable-next-line typescript/unbound-method
var has = Object.prototype.hasOwnProperty;
function dequal(foo, bar, compare) {
// start of custom implementation
if (compare === null || compare === void 0 ? void 0 : compare(foo, bar)) {
return true;
}
// end of custom implementation
var ctor;
var len;
if (foo === bar) return true;
if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
if (ctor === Date) return foo.getTime() === bar.getTime();
if (ctor === RegExp) return foo.toString() === bar.toString();
if (ctor === Array) {
if ((len = foo.length) === bar.length) {
while(len-- && dequal(foo[len], bar[len], compare));
}
return len === -1;
}
if (!ctor || (typeof foo === "undefined" ? "undefined" : _type_of(foo)) === 'object') {
len = 0;
// eslint-disable-next-line guard-for-in, instantsearch/no-for-in
for(ctor in foo){
if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor], compare)) return false;
}
return Object.keys(bar).length === len;
}
}
// eslint-disable-next-line no-self-compare
return foo !== foo && bar !== bar;
}
function createSearchResults(state) {
var _state_query, _state_page, _state_hitsPerPage;
return new algoliasearchHelper.SearchResults(state, [
{
query: (_state_query = state.query) !== null && _state_query !== void 0 ? _state_query : '',
page: (_state_page = state.page) !== null && _state_page !== void 0 ? _state_page : 0,
hitsPerPage: (_state_hitsPerPage = state.hitsPerPage) !== null && _state_hitsPerPage !== void 0 ? _state_hitsPerPage : 20,
hits: [],
nbHits: 0,
nbPages: 0,
params: '',
exhaustiveNbHits: true,
exhaustiveFacetsCount: true,
processingTimeMS: 0,
index: state.index
}
], {
/** used by connectors to prevent persisting these results */ __isArtificial: true
});
}
function getIndexSearchResults(indexWidget) {
var helper = indexWidget.getHelper();
var results = indexWidget.getResults() || // On the browser, we create fallback results based on the helper state.
createSearchResults(helper.state);
var scopedResults = indexWidget.getScopedResults().map(function(scopedResult) {
var fallbackResults = scopedResult.indexId === indexWidget.getIndexId() ? results : createSearchResults(scopedResult.helper.state);
return _object_spread_props(_object_spread({}, scopedResult), {
// We keep `results` from being `null`.
results: scopedResult.results || fallbackResults
});
});
return {
results: results,
scopedResults: scopedResults,
recommendResults: helper.lastRecommendResults
};
}
var IndexContext = /*#__PURE__*/ React.createContext(null);
/**
* Throws an error if the condition is not met.
*
* The error is exhaustive in development, and becomes generic in production.
*
* This is used to make development a better experience to provide guidance as
* to where the error comes from.
*/ function invariant(condition, message) {
if (condition) {
return;
}
{
throw new Error('Invariant failed');
}
}
function useIndexContext() {
var context = React.useContext(IndexContext);
invariant(context !== null);
return context;
}
var InstantSearchContext = /*#__PURE__*/ React.createContext(null);
function useInstantSearchContext() {
var search = React.useContext(InstantSearchContext);
invariant(search !== null);
return search;
}
var InstantSearchServerContext = /*#__PURE__*/ React.createContext(null);
function useInstantSearchServerContext() {
return React.useContext(InstantSearchServerContext);
}
var InstantSearchSSRContext = /*#__PURE__*/ React.createContext(null);
function useInstantSearchSSRContext() {
return React.useContext(InstantSearchSSRContext);
}
function useStableValue(value) {
var _useState = _sliced_to_array(React.useState(function() {
return value;
}), 2), stableValue = _useState[0], setStableValue = _useState[1];
if (!dequal(stableValue, value)) {
setStableValue(value);
}
return stableValue;
}
/**
* Forwards the insights-related search parameters to every Recommend query.
*
* The insights middleware writes `userToken` and `clickAnalytics` on the main
* helper's search state, which only feeds search queries: Recommend queries are
* built from their own parameters and never read the search state. Without this,
* recommendations can't be personalized, and their responses carry no `queryID`
* for the connectors to attribute click and conversion events with.
*
* Parameters set on a widget win, so an explicit `queryParameters.userToken`
* keeps overriding the middleware.
*
* The fallback query is a regular search, so it gets the same treatment — but
* only merged into a `fallbackParameters` the widget already set. See below.
*/ function addInsightsToRecommendParameters(recommendParameters, param) {
var userToken = param.userToken, clickAnalytics = param.clickAnalytics;
if (userToken === undefined && clickAnalytics === undefined) {
return recommendParameters;
}
var insightsParameters = _object_spread({}, clickAnalytics === undefined ? {} : {
clickAnalytics: clickAnalytics
}, userToken === undefined ? {} : {
userToken: userToken
});
return new algoliasearchHelper.RecommendParameters({
params: recommendParameters.params.map(function(params) {
// v4 `TrendingFacetsQuery` doesn't include `queryParameters` or
// `fallbackParameters`, but the v5 API and the helper support them, like
// `connectTrendingFacets` does.
var queryParameters = params.queryParameters, fallbackParameters = params.fallbackParameters;
return _object_spread(_object_spread_props(_object_spread({}, params), {
queryParameters: _object_spread({}, insightsParameters, queryParameters)
}), fallbackParameters && {
fallbackParameters: _object_spread({}, insightsParameters, fallbackParameters)
});
})
});
}
var id$1 = 0;
function addWidgetId(widget) {
if (widget.dependsOn !== 'recommend') {
return;
}
widget.$$id = id$1++;
}
function resetWidgetId() {
id$1 = 0;
}
function _array_without_holes(arr) {
if (Array.isArray(arr)) return _array_like_to_array(arr);
}
function _non_iterable_spread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _to_consumable_array(arr) {
return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
function getObjectType(object) {
return Object.prototype.toString.call(object).slice(8, -1);
}
function checkRendering(rendering, usage) {
if (rendering === undefined || typeof rendering !== 'function') {
throw new Error("The render function is not valid (received type ".concat(getObjectType(rendering), ").\n\n").concat(usage));
}
}
/**
* Clears the refinements of a SearchParameters object based on rules provided.
* The included attributes list is applied before the excluded attributes list. If the list
* is not provided, this list of all the currently refined attributes is used as included attributes.
* @returns search parameters with refinements cleared
*/ function clearRefinements(param) {
var helper = param.helper, _param_attributesToClear = param.attributesToClear, attributesToClear = _param_attributesToClear === void 0 ? [] : _param_attributesToClear;
var finalState = helper.state.setPage(0);
finalState = attributesToClear.reduce(function(state, attribute) {
if (finalState.isNumericRefined(attribute)) {
return state.removeNumericRefinement(attribute);
}
if (finalState.isHierarchicalFacet(attribute)) {
return state.removeHierarchicalFacetRefinement(attribute);
}
if (finalState.isDisjunctiveFacet(attribute)) {
return state.removeDisjunctiveFacetRefinement(attribute);
}
if (finalState.isConjunctiveFacet(attribute)) {
return state.removeFacetRefinement(attribute);
}
return state;
}, finalState);
if (attributesToClear.indexOf('query') !== -1) {
finalState = finalState.setQuery('');
}
return finalState;
}
function _extends() {
_extends = Object.assign || function assign(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
}
return target;
};
return _extends.apply(this, arguments);
}
function _object_destructuring_empty(o) {
if (o === null || o === void 0) throw new TypeError("Cannot destructure " + o);
return o;
}
/**
* This implementation is taken from Lodash implementation.
* See: https://github.com/lodash/lodash/blob/4.17.11-npm/escape.js
*/ // Used to map characters to HTML entities.
var htmlEntities = {
'&': '&',
'<': '<',
'>': '>',
'"': '"',
"'": '''
};
// Used to match HTML entities and HTML characters.
var regexUnescapedHtml = /[&<>"']/g;
var regexHasUnescapedHtml = RegExp(regexUnescapedHtml.source);
/**
* Converts the characters "&", "<", ">", '"', and "'" in `string` to their
* corresponding HTML entities.
*/ function escape$1(value) {
return value && regexHasUnescapedHtml.test(value) ? value.replace(regexUnescapedHtml, function(character) {
return htmlEntities[character];
}) : value;
}
/**
* This implementation is taken from Lodash implementation.
* See: https://github.com/lodash/lodash/blob/4.17.11-npm/unescape.js
*/ // Used to map HTML entities to characters.
var htmlCharacters = {
'&': '&',
'<': '<',
'>': '>',
'"': '"',
''': "'"
};
// Used to match HTML entities and HTML characters.
var regexEscapedHtml = /&(amp|quot|lt|gt|#39);/g;
var regexHasEscapedHtml = RegExp(regexEscapedHtml.source);
/**
* Converts the HTML entities "&", "<", ">", '"', and "'" in `string` to their
* characters.
*/ function unescape$1(value) {
return value && regexHasEscapedHtml.test(value) ? value.replace(regexEscapedHtml, function(character) {
return htmlCharacters[character];
}) : value;
}
var TAG_PLACEHOLDER = {
highlightPreTag: '__ais-highlight__',
highlightPostTag: '__/ais-highlight__'
};
var TAG_REPLACEMENT = {
highlightPreTag: '<mark>',
highlightPostTag: '</mark>'
};
// @MAJOR: in the future, this should only escape, not replace
function replaceTagsAndEscape(value) {
return escape$1(value).replace(new RegExp(TAG_PLACEHOLDER.highlightPreTag, 'g'), TAG_REPLACEMENT.highlightPreTag).replace(new RegExp(TAG_PLACEHOLDER.highlightPostTag, 'g'), TAG_REPLACEMENT.highlightPostTag);
}
function recursiveEscape(input) {
if (isPlainObject(input) && typeof input.value !== 'string') {
return Object.keys(input).reduce(function(acc, key) {
return _object_spread_props(_object_spread({}, acc), _define_property({}, key, recursiveEscape(input[key])));
}, {});
}
if (Array.isArray(input)) {
return input.map(recursiveEscape);
}
return _object_spread_props(_object_spread({}, input), {
value: replaceTagsAndEscape(input.value)
});
}
function escapeHits(hits) {
if (hits.__escaped === undefined) {
// We don't override the value on hit because it will mutate the raw results
// instead we make a shallow copy and we assign the escaped values on it.
hits = hits.map(function(_0) {
_object_destructuring_empty(_0);
var hit = _extends({}, _0);
if (hit._highlightResult) {
hit._highlightResult = recursiveEscape(hit._highlightResult);
}
if (hit._snippetResult) {
hit._snippetResult = recursiveEscape(hit._snippetResult);
}
return hit;
});
hits.__escaped = true;
}
return hits;
}
function escapeFacets(facetHits) {
return facetHits.map(function(h) {
return _object_spread_props(_object_spread({}, h), {
highlighted: replaceTagsAndEscape(h.highlighted)
});
});
}
function concatHighlightedParts(parts) {
var highlightPreTag = TAG_REPLACEMENT.highlightPreTag, highlightPostTag = TAG_REPLACEMENT.highlightPostTag;
return parts.map(function(part) {
return part.isHighlighted ? highlightPreTag + part.value + highlightPostTag : part.value;
}).join('');
}
function isFacetRefined(helper, facet, value) {
if (helper.state.isHierarchicalFacet(facet)) {
return helper.state.isHierarchicalFacetRefined(facet, value);
} else if (helper.state.isConjunctiveFacet(facet)) {
return helper.state.isFacetRefined(facet, value);
} else {
return helper.state.isDisjunctiveFacetRefined(facet, value);
}
}
function createSendEventForFacet(param) {
var instantSearchInstance = param.instantSearchInstance, helper = param.helper, attr = param.attribute, widgetType = param.widgetType;
var sendEventForFacet = function sendEventForFacet() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
var _args = _sliced_to_array(args, 4), facetValue = _args[1], tmp = _args[2], eventName = tmp === void 0 ? 'Filter Applied' : tmp, tmp1 = _args[3], additionalData = tmp1 === void 0 ? {} : tmp1;
var _args__split = _sliced_to_array(args[0].split(':'), 2), eventType = _args__split[0], eventModifier = _args__split[1];
var attribute = typeof attr === 'string' ? attr : attr(facetValue);
if (args.length === 1 && _type_of(args[0]) === 'object') {
instantSearchInstance.sendEventToInsights(args[0]);
} else if (eventType === 'click' && args.length >= 2 && args.length <= 4) {
if (!isFacetRefined(helper, attribute, facetValue)) {
var _helper_lastResults;
// send event only when the facet is being checked "ON"
instantSearchInstance.sendEventToInsights({
insightsMethod: 'clickedFilters',
widgetType: widgetType,
eventType: eventType,
eventModifier: eventModifier,
payload: _object_spread({
eventName: eventName,
index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
filters: [
"".concat(attribute, ":").concat(facetValue)
]
}, additionalData),
attribute: attribute
});
}
} else ;
};
return sendEventForFacet;
}
function serializePayload(payload) {
return btoa(encodeURIComponent(JSON.stringify(payload)));
}
function chunk(arr) {
var chunkSize = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 20;
var chunks = [];
for(var i = 0; i < Math.ceil(arr.length / chunkSize); i++){
chunks.push(arr.slice(i * chunkSize, (i + 1) * chunkSize));
}
return chunks;
}
function _buildEventPayloadsForHits(param) {
var helper = param.helper, widgetType = param.widgetType;
param.methodName;
var args = param.args, instantSearchInstance = param.instantSearchInstance;
// when there's only one argument, that means it's custom
if (args.length === 1 && _type_of(args[0]) === 'object') {
return [
args[0]
];
}
var _args__split = _sliced_to_array(args[0].split(':'), 2), eventType = _args__split[0], eventModifier = _args__split[1];
var hits = args[1];
var eventName = args[2];
var additionalData = args[3] || {};
if (!hits) {
{
return [];
}
}
if ((eventType === 'click' || eventType === 'conversion') && !eventName) {
{
return [];
}
}
var hitsArray = Array.isArray(hits) ? hits : [
hits
];
if (hitsArray.length === 0) {
return [];
}
var queryID = hitsArray[0].__queryID;
var hitsChunks = chunk(hitsArray);
var objectIDsByChunk = hitsChunks.map(function(batch) {
return batch.map(function(hit) {
return hit.objectID;
});
});
var positionsByChunk = hitsChunks.map(function(batch) {
return batch.map(function(hit) {
return hit.__position;
});
});
if (eventType === 'view') {
if (instantSearchInstance.status !== 'idle') {
return [];
}
return hitsChunks.map(function(batch, i) {
var _helper_lastResults;
return {
insightsMethod: 'viewedObjectIDs',
widgetType: widgetType,
eventType: eventType,
payload: _object_spread({
eventName: eventName || 'Hits Viewed',
index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
objectIDs: objectIDsByChunk[i]
}, additionalData),
hits: batch,
eventModifier: eventModifier
};
});
} else if (eventType === 'click') {
return hitsChunks.map(function(batch, i) {
var _helper_lastResults;
return {
insightsMethod: 'clickedObjectIDsAfterSearch',
widgetType: widgetType,
eventType: eventType,
payload: _object_spread({
eventName: eventName || 'Hit Clicked',
index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
queryID: queryID,
objectIDs: objectIDsByChunk[i],
positions: positionsByChunk[i]
}, additionalData),
hits: batch,
eventModifier: eventModifier
};
});
} else if (eventType === 'conversion') {
return hitsChunks.map(function(batch, i) {
var _helper_lastResults;
return {
insightsMethod: 'convertedObjectIDsAfterSearch',
widgetType: widgetType,
eventType: eventType,
payload: _object_spread({
eventName: eventName || 'Hit Converted',
index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
queryID: queryID,
objectIDs: objectIDsByChunk[i]
}, additionalData),
hits: batch,
eventModifier: eventModifier
};
});
} else {
return [];
}
}
function createSendEventForHits(param) {
var instantSearchInstance = param.instantSearchInstance, helper = param.helper, widgetType = param.widgetType;
var sentEvents = {};
var timer = undefined;
var sendEventForHits = function sendEventForHits() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
var payloads = _buildEventPayloadsForHits({
widgetType: widgetType,
helper: helper,
methodName: 'sendEvent',
args: args,
instantSearchInstance: instantSearchInstance
});
payloads.forEach(function(payload) {
if (payload.eventType === 'click' && payload.eventModifier === 'internal' && sentEvents[payload.eventType]) {
return;
}
sentEvents[payload.eventType] = true;
instantSearchInstance.sendEventToInsights(payload);
});
clearTimeout(timer);
timer = setTimeout(function() {
sentEvents = {};
}, 0);
};
return sendEventForHits;
}
function createBindEventForHits(param) {
var helper = param.helper, widgetType = param.widgetType, instantSearchInstance = param.instantSearchInstance;
var bindEventForHits = function bindEventForHits() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
var payloads = _buildEventPayloadsForHits({
widgetType: widgetType,
helper: helper,
methodName: 'bindEvent',
args: args,
instantSearchInstance: instantSearchInstance
});
return payloads.length ? "data-insights-event=".concat(serializePayload(payloads)) : '';
};
return bindEventForHits;
}
var indexWidgetTypes = [
'ais.index',
'ais.feedContainer'
];
function isIndexWidget(widget) {
return indexWidgetTypes.includes(widget.$$type);
}
function setIndexHelperState(finalUiState, indexWidget) {
var nextIndexUiState = finalUiState[indexWidget.getIndexId()] || {};
indexWidget.getHelper().setState(indexWidget.getWidgetSearchParameters(indexWidget.getHelper().state, {
uiState: nextIndexUiState
}));
indexWidget.getWidgets().filter(isIndexWidget).forEach(function(widget) {
return setIndexHelperState(finalUiState, widget);
});
}
var nextMicroTask = Promise.resolve();
function defer(callback, // arguments: the first caller of the window decides what the single run
// receives. Pass this to fold every later argument into the pending ones
// instead.
mergeArguments) {
var progress = null;
var cancelled = false;
var pendingArgs = null;
var fn = function fn() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
if (progress !== null) {
if (mergeArguments && pendingArgs !== null) {
pendingArgs = mergeArguments(pendingArgs, args);
}
return;
}
pendingArgs = args;
progress = nextMicroTask.then(function() {
progress = null;
var runArgs = pendingArgs;
pendingArgs = null;
if (cancelled) {
cancelled = false;
return;
}
callback.apply(void 0, _to_consumable_array(runArgs));
});
};
fn.wait = function() {
if (progress === null) {
throw new Error('The deferred function should be called before calling `wait()`');
}
return progress;
};
fn.cancel = function() {
if (progress === null) {
return;
}
cancelled = true;
};
return fn;
}
function sendChatMessageFeedback(param) {
var agentId = param.agentId, vote = param.vote, messageId = param.messageId, appId = param.appId, apiKey = param.apiKey;
return fetch("https://".concat(appId, ".algolia.net/agent-studio/1/feedback"), {
method: 'POST',
body: JSON.stringify({
messageId: messageId,
agentId: agentId,
vote: vote
}),
headers: {
'x-algolia-application-id': appId,
'x-algolia-api-key': apiKey,
'content-type': 'application/json'
}
}).then(function(response) {
if (response.status >= 300) {
return response.json().then(function(data) {
throw new Error("Feedback request failed with status ".concat(response.status, ": ").concat(data.message));
});
}
return response.json();
});
}
function unescapeFacetValue(value) {
if (typeof value === 'string') {
return value.replace(/^\\-/, '-');
}
return value;
}
function escapeFacetValue(value) {
if (typeof value === 'number' && value < 0 || typeof value === 'string') {
return String(value).replace(/^-/, '\\-');
}
return value;
}
// We aren't using the native `Array.prototype.find` because the refactor away from Lodash is not
// published as a major version.
// Relying on the `find` polyfill on user-land, which before was only required for niche use-cases,
// was decided as too risky.
// @MAJOR Replace with the native `Array.prototype.find` method
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
function find$1(items, predicate) {
var value;
for(var i = 0; i < items.length; i++){
value = items[i];
// inlined for performance: if (Call(predicate, thisArg, [value, i, list])) {
if (predicate(value, i, items)) {
return value;
}
}
return undefined;
}
var latLngRegExp = /^(-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)$/;
function aroundLatLngToPosition(value) {
var pattern = value.match(latLngRegExp);
// Since the value provided is the one send with the request, the API should
// throw an error due to the wrong format. So throw an error should be safe.
if (!pattern) {
throw new Error('Invalid value for "aroundLatLng" parameter: "'.concat(value, '"'));
}
return {
lat: parseFloat(pattern[1]),
lng: parseFloat(pattern[2])
};
}
function insideBoundingBoxArrayToBoundingBox(value) {
var _value = _sliced_to_array(value, 1), tmp = _value[0], _ref = _sliced_to_array(tmp === void 0 ? [
undefined,
undefined,
undefined,
undefined
] : tmp, 4), neLat = _ref[0], neLng = _ref[1], swLat = _ref[2], swLng = _ref[3];
// Since the value provided is the one send with the request, the API should
// throw an error due to the wrong format. So throw an error should be safe.
if (!neLat || !neLng || !swLat || !swLng) {
throw new Error('Invalid value for "insideBoundingBox" parameter: ['.concat(value, "]"));
}
return {
northEast: {
lat: neLat,
lng: neLng
},
southWest: {
lat: swLat,
lng: swLng
}
};
}
function insideBoundingBoxStringToBoundingBox(value) {
var _value_split_map = _sliced_to_array(value.split(',').map(parseFloat), 4), neLat = _value_split_map[0], neLng = _value_split_map[1], swLat = _value_split_map[2], swLng = _value_split_map[3];
// Since the value provided is the one send with the request, the API should
// throw an error due to the wrong format. So throw an error should be safe.
if (!neLat || !neLng || !swLat || !swLng) {
throw new Error('Invalid value for "insideBoundingBox" parameter: "'.concat(value, '"'));
}
return {
northEast: {
lat: neLat,
lng: neLng
},
southWest: {
lat: swLat,
lng: swLng
}
};
}
function insideBoundingBoxToBoundingBox(value) {
if (Array.isArray(value)) {
return insideBoundingBoxArrayToBoundingBox(value);
}
return insideBoundingBoxStringToBoundingBox(value);
}
function getAlgoliaAgent(client) {
var clientTyped = client;
return clientTyped.transporter && clientTyped.transporter.userAgent ? clientTyped.transporter.userAgent.value : clientTyped._ua;
}
// typed as any, since it accepts the _real_ js clients, not the interface we otherwise expect
function getAppIdAndApiKey(searchClient) {
if (searchClient.appId && searchClient.apiKey) {
// searchClient v5
return [
searchClient.appId,
searchClient.apiKey
];
} else if (searchClient.transporter) {
// searchClient v4 or v5
var transporter = searchClient.transporter;
var headers = transporter.headers || transporter.baseHeaders;
var queryParameters = transporter.queryParameters || transporter.baseQueryParameters;
var APP_ID = 'x-algolia-application-id';
var API_KEY = 'x-algolia-api-key';
var appId = headers[APP_ID] || queryParameters[APP_ID];
var apiKey = headers[API_KEY] || queryParameters[API_KEY];
return [
appId,
apiKey
];
} else {
// searchClient v3
return [
searchClient.applicationID,
searchClient.apiKey
];
}
}
function getHighlightedParts(highlightedValue) {
// @MAJOR: this should use TAG_PLACEHOLDER
var highlightPostTag = TAG_REPLACEMENT.highlightPostTag, highlightPreTag = TAG_REPLACEMENT.highlightPreTag;
var splitByPreTag = highlightedValue.split(highlightPreTag);
var firstValue = splitByPreTag.shift();
var elements = !firstValue ? [] : [
{
value: firstValue,
isHighlighted: false
}
];
splitByPreTag.forEach(function(split) {
var splitByPostTag = split.split(highlightPostTag);
elements.push({
value: splitByPostTag[0],
isHighlighted: true
});
if (splitByPostTag[1] !== '') {
elements.push({
value: splitByPostTag[1],
isHighlighted: false
});
}
});
return elements;
}
var hasAlphanumeric = new RegExp(/\w/i);
function getHighlightFromSiblings(parts, i) {
var _ref, _ref1;
var _parts_, _parts_1;
var current = parts[i];
var isNextHighlighted = (_ref = (_parts_ = parts[i + 1]) === null || _parts_ === void 0 ? void 0 : _parts_.isHighlighted) !== null && _ref !== void 0 ? _ref : true;
var isPreviousHighlighted = (_ref1 = (_parts_1 = parts[i - 1]) === null || _parts_1 === void 0 ? void 0 : _parts_1.isHighlighted) !== null && _ref1 !== void 0 ? _ref1 : true;
if (!hasAlphanumeric.test(unescape$1(current.value)) && isPreviousHighlighted === isNextHighlighted) {
return isPreviousHighlighted;
}
return current.isHighlighted;
}
function getPropertyByPath(object, path) {
var parts = Array.isArray(path) ? path : path.split('.');
return parts.reduce(function(current, key) {
return current && current[key];
}, object);
}
function getRefinement(state, type, attribute, name) {
var resultsFacets = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : [];
var res = {
type: type,
attribute: attribute,
name: name,
escapedValue: escapeFacetValue(name)
};
var facet = find$1(resultsFacets, function(resultsFacet) {
return resultsFacet.name === attribute;
});
var count;
if (type === 'hierarchical') {
var _loop = function _loop(i) {
facet = facet && facet.data && find$1(Object.keys(facet.data).map(getFacetRefinement(facet.data)), function(refinement) {
return refinement.name === nameParts[i];
});
};
var facetDeclaration = state.getHierarchicalFacetByName(attribute);
var nameParts = name.split(facetDeclaration.separator);
var getFacetRefinement = function getFacetRefinement(facetData) {
return function(refinementKey) {
return facetData[refinementKey];
};
};
for(var i = 0; facet !== undefined && i < nameParts.length; ++i)_loop(i);
count = facet && facet.count;
} else {
count = facet && facet.data && facet.data[res.name];
}
if (count !== undefined) {
res.count = count;
}
if (facet && facet.exhaustive !== undefined) {
res.exhaustive = facet.exhaustive;
}
return res;
}
function getRefinements(_results, state) {
var includesQuery = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
var results = _results || {};
var refinements = [];
var _state_facetsRefinements = state.facetsRefinements, facetsRefinements = _state_facetsRefinements === void 0 ? {} : _state_facetsRefinements, _state_facetsExcludes = state.facetsExcludes, facetsExcludes = _state_facetsExcludes === void 0 ? {} : _state_facetsExcludes, _state_disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements, disjunctiveFacetsRefinements = _state_disjunctiveFacetsRefinements === void 0 ? {} : _state_disjunctiveFacetsRefinements, _state_hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements, hierarchicalFacetsRefinements = _state_hierarchicalFacetsRefinements === void 0 ? {} : _state_hierarchicalFacetsRefinements, _state_numericRefinements = state.numericRefinements, numericRefinements = _state_numericRefinements === void 0 ? {} : _state_numericRefinements, _state_tagRefinements = state.tagRefinements, tagRefinements = _state_tagRefinements === void 0 ? [] : _state_tagRefinements;
Object.keys(facetsRefinements).forEach(function(attribute) {
var refinementNames = facetsRefinements[attribute];
refinementNames.forEach(function(refinementName) {
refinements.push(getRefinement(state, 'facet', attribute, refinementName, results.facets));
});
});
Object.keys(facetsExcludes).forEach(function(attribute) {
var refinementNames = facetsExcludes[attribute];
refinementNames.forEach(function(refinementName) {
refinements.push({
type: 'exclude',
attribute: attribute,
name: refinementName,
exclude: true
});
});
});
Object.keys(disjunctiveFacetsRefinements).forEach(function(attribute) {
var refinementNames = disjunctiveFacetsRefinements[attribute];
refinementNames.forEach(function(refinementName) {
refinements.push(getRefinement(state, 'disjunctive', attribute, // they can be escaped on negative numeric values with `escapeFacetValue`.
unescapeFacetValue(refinementName), results.disjunctiveFacets));
});
});
Object.keys(hierarchicalFacetsRefinements).forEach(function(attribute) {
var refinementNames = hierarchicalFacetsRefinements[attribute];
refinementNames.forEach(function(refinement) {
refinements.push(getRefinement(state, 'hierarchical', attribute, refinement, results.hierarchicalFacets));
});
});
Object.keys(numericRefinements).forEach(function(attribute) {
var operators = numericRefinements[attribute];
Object.keys(operators).forEach(function(operatorOriginal) {
var operator = operatorOriginal;
var valueOrValues = operators[operator];
var refinementNames = Array.isArray(valueOrValues) ? valueOrValues : [
valueOrValues
];
refinementNames.forEach(function(refinementName) {
refinements.push({
type: 'numeric',
attribute: attribute,
name: "".concat(refinementName),
numericValue: refinementName,
operator: operator
});
});
});
});
tagRefinements.forEach(function(refinementName) {
refinements.push({
type: 'tag',
attribute: '_tags',
name: refinementName
});
});
if (includesQuery && state.query && state.query.trim()) {
refinements.push({
attribute: 'query',
type: 'query',
name: state.query,
query: state.query
});
}
return refinements;
}
function getWidgetAttribute$1(widget, initOptions) {
var _widget_getWidgetRenderState;
var renderState = (_widget_getWidgetRenderState = widget.getWidgetRenderState) === null || _widget_getWidgetRenderState === void 0 ? void 0 : _widget_getWidgetRenderState.call(widget, initOptions);
var attribute = null;
if (renderState && renderState.widgetParams) {
// casting as widgetParams is checked just before
var widgetParams = renderState.widgetParams;
if (widgetParams.attribute) {
attribute = widgetParams.attribute;
} else if (Array.isArray(widgetParams.attributes)) {
attribute = widgetParams.attributes[0];
}
}
if (typeof attribute !== 'string') {
throw new Error("Could not find the attribute of the widget:\n\n".concat(JSON.stringify(widget), "\n\nPlease check whether the widget's getWidgetRenderState returns widgetParams.attribute correctly."));
}
return attribute;
}
function addAbsolutePosition$1(hits, page, hitsPerPage) {
return hits.map(function(hit, idx) {
return _object_spread_props(_object_spread({}, hit), {
__position: hitsPerPage * page + idx + 1
});
});
}
function addQueryID$1(hits, queryID) {
if (!queryID) {
return hits;
}
return hits.map(function(hit) {
return _object_spread_props(_object_spread({}, hit), {
__queryID: queryID
});
});
}
function hydrateRecommendCache(helper, initialResults) {
var recommendCache = Object.keys(initialResults).reduce(function(acc, indexName) {
var initialResult = initialResults[indexName];
if (initialResult.recommendResults) {
// @MAJOR: Use `Object.assign` instead of spread operator
return _object_spread({}, acc, initialResult.recommendResults.results);
}
return acc;
}, {});
helper._recommendCache = recommendCache;
}
function getServerResults(entry) {
var _entry_compositionFeedsResults;
return ((_entry_compositionFeedsResults = entry.compositionFeedsResults) === null || _entry_compositionFeedsResults === void 0 ? void 0 : _entry_compositionFeedsResults.length) ? entry.compositionFeedsResults : entry.results || [];
}
function hydrateSearchClient(client, results) {
if (!results) {
return;
}
// Disable cache hydration on:
// - Algoliasearch API Client < v4 with cache disabled
// - Third party clients (detected by the `addAlgoliaAgent` function missing)
if ((!('transporter' in client) || client._cacheHydrated) && (!client._useCache || typeof client.addAlgoliaAgent !== 'function')) {
return;
}
var cachedRequest = [
Object.keys(results).reduce(function(acc, key) {
var entry = results[key];
var state = entry.state, requestParams = entry.requestParams;
var serverResults = getServerResults(entry);
var mappedResults = serverResults && state ? serverResults.map(function(result, idx) {
return _object_spread({
indexName: state.index || result.index
}, (requestParams === null || requestParams === void 0 ? void 0 : requestParams[idx]) || result.params ? {
params: serializeQueryParameters((requestParams === null || requestParams === void 0 ? void 0 : requestParams[idx]) || deserializeQueryParameters(result.params))
} : {});
}) : [];
return acc.concat(mappedResults);
}, [])
];
var cachedResults = Object.keys(results).reduce(function(acc, key) {
var res = getServerResults(results[key]);
if (!res) {
return acc;
}
return acc.concat(res);
}, []);
// Algoliasearch API Client >= v4
// To hydrate the client we need to populate the cache with the data from
// the server (done in `hydrateSearchClientWithMultiIndexRequest` or
// `hydrateSearchClientWithSingleIndexRequest`). But since there is no way
// for us to compute the key the same way as `algoliasearch-client` we need
// to populate it on a custom key and override the `search` method to
// search on it first.
if ('transporter' in client && !client._cacheHydrated) {
client._cacheHydrated = true;
var baseMethod = client.search.bind(client);
client.search = function(requests) {
for(var _len = arguments.length, methodArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
methodArgs[_key - 1] = arguments[_key];
}
var requestsWithSerializedParams = Array.isArray(requests) ? requests.map(function(request) {
return _object_spread_props(_object_spread({}, request), {
params: serializeQueryParameters(request.params)
});
}) : serializeQueryParameters(requests.requestBody.params);
return client.transporter.responsesCache.get({
method: 'search',
args: [
requestsWithSerializedParams
].concat(_to_consumable_array(methodArgs))
}, function() {
return baseMethod.apply(void 0, [
requests
].concat(_to_consumable_array(methodArgs)));
});
};
client.transporter.responsesCache.set({
method: 'search',
args: cachedRequest
}, {
results: cachedResults
});
}
// Algoliasearch API Client < v4
// Prior to client v4 we didn't have a proper API to hydrate the client
// cache from the outside. The following code populates the cache with
// a single-index result. You can find more information about the
// computation of the key inside the client (see link below).
// https://github.com/algolia/algoliasearch-client-javascript/blob/c27e89ff92b2a854ae6f40dc524bffe0f0cbc169/src/AlgoliaSearchCore.js#L232-L240
if (!('transporter' in client)) {
var cacheKey = "/1/indexes/*/queries_body_".concat(JSON.stringify({
requests: cachedRequest
}));
client.cache = _object_spread_props(_object_spread({}, client.cache), _define_property({}, cacheKey, JSON.stringify({
results: Object.keys(results).map(function(key) {
return getServerResults(results[key]);
})
})));
}
}
function deserializeQueryParameters(parameters) {
return parameters.split('&').reduce(function(acc, parameter) {
var _parameter_split = _sliced_to_array(parameter.split('='), 2), key = _parameter_split[0], value = _parameter_split[1];
acc[key] = value ? decodeURIComponent(value) : '';
return acc;
}, {});
}
// This function is copied from the algoliasearch v4 API Client. If modified,
// consider updating it also in `serializeQueryParameters` from `@algolia/transporter`.
function serializeQueryParameters(parameters) {
var isObjectOrArray = function isObjectOrArray(value) {
return Object.prototype.toString.call(value) === '[object Object]' || Object.prototype.toString.call(value) === '[object Array]';
};
var encode = function encode(format) {
for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
args[_key - 1] = arguments[_key];
}
var i = 0;
return format.replace(/%s/g, function() {
return encodeURIComponent(args[i++]);
});
};
return Object.keys(parameters).map(function(key) {
return encode('%s=%s', key, isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key]);
}).join('&');
}
function isPrimitive(obj) {
return obj !== Object(obj);
}
function isEqual(first, second) {
if (first === second) {
return true;
}
if (isPrimitive(first) || isPrimitive(second) || typeof first === 'function' || typeof second === 'function') {
return first === second;
}
if (Object.keys(first).length !== Object.keys(second).length) {
return false;
}
var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
try {
// @TODO avoid for..of because of the large polyfill
// eslint-disable-next-line instantsearch/no-for-of
for(var _iterator = Object.keys(first)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
var key = _step.value;
if (!(key in second)) {
return false;
}
if (!isEqual(first[key], second[key])) {
return false;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally{
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally{
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return true;
}
// This is the `Number.isFinite()` polyfill recommended by MDN.
// We do not provide any tests for this function.
// See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill
// @MAJOR Replace with the native `Number.isFinite` method
function isFiniteNumber(value) {
return typeof value === 'number' && isFinite(value);
}
/**
* Recurse over all child indices
*/ function walkIndex(indexWidget, callback) {
callback(indexWidget);
indexWidget.getWidgets().forEach(function(widget) {
if (isIndexWidget(widget)) {
walkIndex(widget, callback);
}
});
}
/**
* Returns true if the widget requires a second SSR pass to discover and
* mount child widgets (e.g. DynamicWidgets, Feeds).
*/ function isTwoPassWidget(widget) {
return widget.$$type === 'ais.dynamicWidgets' || widget.$$type === 'ais.feeds';
}
/**
* Logs a warning when this function is called, in development environment only.
*/ var deprecate = function deprecate(fn, // eslint-disable-next-line no-unused-vars
message) {
return fn;
};
/**
* Logs a warning
* This is used to log issues in development environment only.
*/ var warn = noop;
/**
* Creates a new object with the same keys as the original object, but without the excluded keys.
* @param source original object
* @param excluded keys to remove from the original object
* @returns the new object
*/ function omit(source, excluded) {
if (source === null || source === undefined) {
return source;
}
return Object.keys(source).reduce(function(target, key) {
if (excluded.indexOf(key) >= 0) {
return target;
}
var validKey = key;
target[validKey] = source[validKey];
return target;
}, {});
}
function createInitArgs(instantSearchInstance, parent, uiState) {
var helper = parent.getHelper();
return {
uiState: uiState,
helper: helper,
parent: parent,
instantSearchInstance: instantSearchInstance,
state: helper.state,
renderState: instantSearchInstance.renderState,
templatesConfig: instantSearchInstance.templatesConfig,
createURL: parent.createURL,
scopedResults: [],
searchMetadata: {
isSearchStalled: instantSearchInstance.status === 'stalled'
},
status: instantSearchInstance.status,
error: instantSearchInstance.error
};
}
function createRenderArgs(instantSearchInstance, parent, widget) {
var results = parent.getResultsForWidget(widget);
var helper = parent.getHelper();
return {
helper: helper,
parent: parent,
instantSearchInstance: instantSearchInstance,
results: results,
scopedResults: parent.getScopedResults(),
state: results && '_state' in results ? results._state : helper.state,
renderState: instantSearchInstance.renderState,
templatesConfig: instantSearchInstance.templatesConfig,
createURL: parent.createURL,
searchMetadata: {
isSearchStalled: instantSearchInstance.status === 'stalled'
},
status: instantSearchInstance.status,
error: instantSearchInstance.error
};
}
function storeRenderState(param) {
var renderState = param.renderState, instantSearchInstance = param.instantSearchInstance, parent = param.parent;
var parentIndexName = parent ? parent.getIndexId() : instantSearchInstance.mainIndex.getIndexId();
instantSearchInstance.renderState = _object_spread_props(_object_spread({}, instantSearchInstance.renderState), _define_property({}, parentIndexName, _object_spread({}, instantSearchInstance.renderState[parentIndexName], renderState)));
}
function serializeParamValue(value) {
if (value === undefined || value === null) {
return null;
}
var t = typeof value === "undefined" ? "undefined" : _type_of(value);
if (t === 'string' || t === 'number' || t === 'boolean') {
return {
value: String(value),
type: t
};
}
if (Array.isArray(value) || t === 'object') {
var type = Array.isArray(value) ? 'array' : 'object';
try {
return {
value: JSON.stringify(value),
type: type
};
} catch (unused) {
return {
type: type
};
}
}
if (t === 'function') {
return {
value: value.name,
type: 'function'
};
}
// symbols, DOM elements: name only
return null;
}
/**
* Turns a `widgetParams`-style record into the serialized `WidgetTreeParam[]`
* shape used throughout the usage events. Shared between the widget tree and
* the root `ais.instantSearch` node so every node reports params identically.
*/ function serializeWidgetParams(widgetParams) {
var params = [];
Object.keys(widgetParams).forEach(function(key) {
var raw = widgetParams[key];
if (raw === undefined) {
return;
}
var serialized = serializeParamValue(raw);
if (serialized) {
params.push(_object_spread({
name: key
}, serialized));
} else {
params.push({
name: key
});
}
});
return params;
}
function buildWidgetTree(widgets, instantSearchInstance) {
var parent = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : instantSearchInstance.mainIndex;
var initOptions = createInitArgs(instantSearchInstance, parent, instantSearchInstance._initialUiState);
return widgets.map(function(widget) {
var widgetParams = {};
if (widget.getWidgetRenderState) {
var renderState = widget.getWidgetRenderState(initOptions);
if (renderState && renderState.widgetParams) {
widgetParams = renderState.widgetParams;
}
}
var params = serializeWidgetParams(widgetParams);
var children = isIndexWidget(widget) ? buildWidgetTree(widget.getWidgets(), instantSearchInstance, widget) : [];
return {
type: widget.$$widgetType || widget.$$type || 'unknown',
params: params,
children: children
};
});
}
function extractWidgetPayload(widgets, instantSearchInstance, payload) {
var parent = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : instantSearchInstance.mainIndex;
var initOptions = createInitArgs(instantSearchInstance, parent, instantSearchInstance._initialUiState);
widgets.forEach(function(widget) {
var widgetParams = {};
if (widget.getWidgetRenderState) {
var renderState = widget.getWidgetRenderState(initOptions);
if (renderState && renderState.widgetParams) {
// casting, as we just earlier checked widgetParams exists, and thus an object
widgetParams = renderState.widgetParams;
}
}
// since we destructure in all widgets, the parameters with defaults are set to "undefined"
var params = Object.keys(widgetParams).filter(function(key) {
return widgetParams[key] !== undefined;
});
payload.widgets.push({
type: widget.$$type,
widgetType: widget.$$widgetType,
params: params
});
if (isIndexWidget(widget)) {
extractWidgetPayload(widget.getWidgets(), instantSearchInstance, payload, widget);
}
});
}
var now = typeof performance !== 'undefined' ? function() {
return performance.now();
} : function() {
return Date.now();
};
function range(param) {
var _param_start = param.start, start = _param_start === void 0 ? 0 : _param_start, end = param.end, _param_step = param.step, step = _param_step === void 0 ? 1 : _param_step;
// We can't divide by 0 so we re-assign the step to 1 if it happens.
var limitStep = step === 0 ? 1 : step;
// In some cases the array to create has a decimal length.
// We therefore need to round the value.
// Example:
// { start: 1, end: 5000, step: 500 }
// => Array length = (5000 - 1) / 500 = 9.998
var arrayLength = Math.round((end - start) / limitStep);
return _to_consumable_array(Array(arrayLength)).map(function(_, current) {
return start + current * limitStep;
});
}
function resolveSearchParameters(current) {
var parent = current.getParent();
var states = [
current.getHelper().state
];
while(parent !== null){
states = [
parent.getHelper().state
].concat(states);
parent = parent.getParent();
}
return states;
}
function reverseHighlightedParts(parts) {
if (!parts.some(function(part) {
return part.isHighlighted;
})) {
return parts.map(function(part) {
return _object_spread_props(_object_spread({}, part), {
isHighlighted: false
});
});
}
return parts.map(function(part, i) {
return _object_spread_props(_object_spread({}, part), {
isHighlighted: !getHighlightFromSiblings(parts, i)
});
});
}
// eslint-disable-next-line no-restricted-globals
/**
* Runs code on browser environments safely.
*/ function safelyRunOnBrowser(callback) {
var fallback = (arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
fallback: function fallback() {
return undefined;
}
}).fallback;
// eslint-disable-next-line no-restricted-globals
if (typeof window === 'undefined') {
return fallback();
}
// eslint-disable-next-line no-restricted-globals
return callback({
window: window
});
}
function toArray(value) {
return Array.isArray(value) ? value : [
value
];
}
var useKey = 'use';
// @TODO: Remove this file and import directly from React when available.
var use = React__namespace[useKey];
/**
* `useLayoutEffect` that doesn't show a warning when server-side rendering.
*
* It uses `useEffect` on the server (no-op), and `useLayoutEffect` on the browser.
*/ var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;
var InstantSearchRSCContext = /*#__PURE__*/ React.createContext({
countRef: {
current: 0
},
waitForResultsRef: null,
resolveWaitForResultsRef: {
current: null
},
ignoreMultipleHooksWarning: false
});
function useRSCContext() {
return React.useContext(InstantSearchRSCContext);
}
function useWidget(param) {
var widget = param.widget, parentIndex = param.parentIndex, props = param.props, shouldSsr = param.shouldSsr, skipSuspense = param.skipSuspense;
var _waitForResultsRef_current, _waitForResultsRef_current1;
var _useRSCContext = useRSCContext(), waitForResultsRef = _useRSCContext.waitForResultsRef, countRef = _useRSCContext.countRef;
_useRSCContext.ignoreMultipleHooksWarning;
var prevPropsRef = React.useRef(props);
React.useEffect(function() {
prevPropsRef.current = props;
}, [
props
]);
var prevWidgetRef = React.useRef(widget);
React.useEffect(function() {
prevWidgetRef.current = widget;
}, [
widget
]);
var cleanupTimerRef = React.useRef(null);
var shouldAddWidgetEarly = shouldSsr && !parentIndex.getWidgets().includes(widget);
var search = useInstantSearchContext();
// This effect is responsible for adding, removing, and updating the widget.
// We need to support scenarios where the widget is remounted quickly, like in
// Strict Mode, so that we don't lose its state, and therefore that we don't
// break routing.
useIsomorphicLayoutEffect(function() {
var previousWidget = prevWidgetRef.current;
// Scenario 1: the widget is added for the first time.
if (!cleanupTimerRef.current) {
if (!shouldSsr) {
parentIndex.addWidgets([
widget
]);
}
} else {
// We cancel the original effect cleanup because it may not be necessary if
// props haven't changed. (We manually call it if it is below.)
clearTimeout(cleanupTimerRef.current);
// Warning: if an unstable function prop is provided, `dequal` is not able
// to keep its reference and therefore will consider that props did change.
// This unintentionally replaces the widget, which is wasteful (it causes
// a search), even though `updateWidget` below keeps its state.
// If users face this issue, we should advise them to provide stable function
// references.
var arePropsEqual = dequal(props, prevPropsRef.current);
// If props did change, then we replace the widget instantly instead of
// waiting for the scheduled cleanup function to finish (that we canceled
// above). `updateWidget` hands the previous widget's `uiState` over to the
// new one, so that a parameter change doesn't reset the state the widget
// still owns — which would otherwise break routing.
if (!arePropsEqual) {
parentIndex.updateWidget(previousWidget, widget);
}
}
return function() {
// We don't remove the widget right away, but rather schedule it so that
// we're able to cancel it in the next effect.
cleanupTimerRef.current = setTimeout(function() {
search._schedule(function() {
if (search._preventWidgetCleanup) return;
parentIndex.removeWidgets([
previousWidget
]);
});
});
};
}, [
parentIndex,
widget,
shouldSsr,
search,
props
]);
if (shouldAddWidgetEarly || (waitForResultsRef === null || waitForResultsRef === void 0 ? void 0 : (_waitForResultsRef_current = waitForResultsRef.current) === null || _waitForResultsRef_current === void 0 ? void 0 : _waitForResultsRef_current.status) === 'pending') {
parentIndex.addWidgets([
widget
]);
}
if ((waitForResultsRef === null || waitForResultsRef === void 0 ? void 0 : waitForResultsRef.current) && !skipSuspense) {
var _search_helper;
use(waitForResultsRef.current);
// If we made a second request because of two-pass widgets, we need to
// wait for the second result — except for the two-pass widgets themselves
// which need to render their children after the first result.
if (!isTwoPassWidget(widget) && ((_search_helper = search.helper) === null || _search_helper === void 0 ? void 0 : _search_helper.lastResults)) {
use(waitForResultsRef.current);
}
}
if ((waitForResultsRef === null || waitForResultsRef === void 0 ? void 0 : (_waitForResultsRef_current1 = waitForResultsRef.current) === null || _waitForResultsRef_current1 === void 0 ? void 0 : _waitForResultsRef_current1.status) === 'fulfilled') {
countRef.current += 1;
}
}
function useConnector(connector) {
var _1 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0, _2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : void 0;
var _ref = [
_1,
_2
], _ref1 = _to_array(_ref), tmp = _ref1[0], props = tmp === void 0 ? {} : tmp, _rest = _ref1.slice(1), _rest1 = _sliced_to_array(_rest, 1), tmp1 = _rest1[0], _ref2 = tmp1 === void 0 ? {} : tmp1, _ref_skipSuspense = _ref2.skipSuspense, skipSuspense = _ref_skipSuspense === void 0 ? false : _ref_skipSuspense, additionalWidgetProperties = _object_without_properties(_ref2, [
"skipSuspense"
]);
var serverContext = useInstantSearchServerContext();
var ssrContext = useInstantSearchSSRContext();
var search = useInstantSearchContext();
var parentIndex = useIndexContext();
var stableProps = useStableValue(props);
var stableAdditionalWidgetProperties = useStableValue(additionalWidgetProperties);
var shouldSetStateRef = React.useRef(true);
var previousRenderStateRef = React.useRef(null);
var previousStatusRef = React.useRef(search.status);
var widget = React.useMemo(function() {
var createWidget = connector(function(connectorState, isFirstRender) {
// We skip the `init` widget render because:
// - We rely on `getWidgetRenderState` to compute the initial state before
// the InstantSearch.js lifecycle starts.
// - It prevents UI flashes when updating the widget props.
if (isFirstRender) {
shouldSetStateRef.current = true;
return;
}
// There are situations where InstantSearch.js may render widgets slightly
// after they're removed by React, and thus try to update the React state
// on unmounted components. React 16 and 17 consider them as memory leaks
// and display a warning.
// This happens in <DynamicWidgets> when `attributesToRender` contains a
// value without an attribute previously mounted. React will unmount the
// component controlled by that attribute, but InstantSearch.js will stay
// unaware of this change until the render pass finishes, and therefore
// notifies of a state change.
// This ref lets us track this situation and ignore these state updates.
if (shouldSetStateRef.current) {
var instantSearchInstance = connectorState.instantSearchInstance;
connectorState.widgetParams;
var renderState = _object_without_properties(connectorState, [
"instantSearchInstance",
"widgetParams"
]);
// We only update the state when a widget render state param changes,
// except for functions. We ignore function reference changes to avoid
// infinite loops. It's safe to omit them because they get updated
// every time another render param changes.
if (!dequal(renderState, previousRenderStateRef.current, function(a, b) {
return (a === null || a === void 0 ? void 0 : a.constructor) === Function && (b === null || b === void 0 ? void 0 : b.constructor) === Function;
}) || instantSearchInstance.status !== previousStatusRef.current) {
// eslint-disable-next-line @typescript-eslint/no-use-before-define
setState(renderState);
previousRenderStateRef.current = renderState;
previousStatusRef.current = instantSearchInstance.status;
}
}
}, function() {
// We'll ignore the next state update until we know for sure that
// InstantSearch.js re-inits the component.
shouldSetStateRef.current = false;
});
return _object_spread({}, createWidget(stableProps), stableAdditionalWidgetProperties);
}, [
connector,
stableProps,
stableAdditionalWidgetProperties
]);
var _useState = _sliced_to_array(React.useState(function() {
if (widget.getWidgetRenderState) {
var _widget_getWidgetSearchParameters;
// The helper exists because we've started InstantSearch.
var helper = parentIndex.getHelper();
var uiState = parentIndex.getWidgetUiState({})[parentIndex.getIndexId()];
helper.state = ((_widget_getWidgetSearchParameters = widget.getWidgetSearchParameters) === null || _widget_getWidgetSearchParameters === void 0 ? void 0 : _widget_getWidgetSearchParameters.call(widget, helper.state, {
uiState: uiState
})) || helper.state;
var _getIndexSearchResults = getIndexSearchResults(parentIndex), results = _getIndexSearchResults.results, scopedResults = _getIndexSearchResults.scopedResults, recommendResults = _getIndexSearchResults.recommendResults;
// We get the widget render state by providing the same parameters as
// InstantSearch provides to the widget's `render` method.
// See https://github.com/algolia/instantsearch/blob/019cd18d0de6dd320284aa4890541b7fe2198c65/src/widgets/index/index.ts#L604-L617
var _widget_getWidgetRenderState = widget.getWidgetRenderState({
helper: helper,
parent: parentIndex,
instantSearchInstance: search,
results: widget.dependsOn === 'recommend' && recommendResults && ssrContext ? recommendResults[ssrContext.recommendIdx.current++] : results,
scopedResults: scopedResults,
state: helper.state,
renderState: search.renderState,
templatesConfig: search.templatesConfig,
createURL: parentIndex.createURL,
searchMetadata: {
isSearchStalled: search.status === 'stalled'
},
status: search.status,
error: search.error
});
_widget_getWidgetRenderState.widgetParams;
var renderState = _object_without_properties(_widget_getWidgetRenderState, [
"widgetParams"
]);
return renderState;
}
return {};
}), 2), state = _useState[0], setState = _useState[1];
useWidget({
widget: widget,
parentIndex: parentIndex,
props: [
stableProps,
stableAdditionalWidgetProperties
],
shouldSsr: Boolean(serverContext),
skipSuspense: skipSuspense
});
return state;
}
function useConfigure(props, additionalWidgetProperties) {
return useConnector(connectConfigure, {
searchParameters: props
}, additionalWidgetProperties);
}
function Configure(props) {
useConfigure(_object_spread({}, props), {
$$widgetType: 'ais.configure'
});
return null;
}
var withUsage$w = createDocumentationMessageGenerator({
name: 'dynamic-widgets',
connector: true
});
var connectDynamicWidgets = function connectDynamicWidgets(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$w());
return function(widgetParams) {
var widgets = widgetParams.widgets, _widgetParams_maxValuesPerFacet = widgetParams.maxValuesPerFacet, maxValuesPerFacet = _widgetParams_maxValuesPerFacet === void 0 ? 20 : _widgetParams_maxValuesPerFacet, _widgetParams_facets = widgetParams.facets, facets = _widgetParams_facets === void 0 ? [
'*'
] : _widgetParams_facets, _widgetParams_transformItems = widgetParams.transformItems, transformItems = _widgetParams_transformItems === void 0 ? function(items) {
return items;
} : _widgetParams_transformItems, fallbackWidget = widgetParams.fallbackWidget;
if (!(widgets && Array.isArray(widgets) && widgets.every(function(widget) {
return (typeof widget === "undefined" ? "undefined" : _type_of(widget)) === 'object';
}))) {
throw new Error(withUsage$w('The `widgets` option expects an array of widgets.'));
}
if (!Array.isArray(facets)) {
throw new Error(withUsage$w("The `facets` option only accepts an array of facets, you passed ".concat(JSON.stringify(facets))));
}
var localWidgets = new Map();
return {
$$type: 'ais.dynamicWidgets',
init: function init(initOptions) {
widgets.forEach(function(widget) {
var attribute = getWidgetAttribute$1(widget, initOptions);
localWidgets.set(attribute, {
widget: widget,
isMounted: false
});
});
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var parent = renderOptions.parent;
var renderState = this.getWidgetRenderState(renderOptions);
var widgetsToUnmount = [];
var widgetsToMount = [];
if (fallbackWidget) {
renderState.attributesToRender.forEach(function(attribute) {
if (!localWidgets.has(attribute)) {
var widget = fallbackWidget({
attribute: attribute
});
localWidgets.set(attribute, {
widget: widget,
isMounted: false
});
}
});
}
localWidgets.forEach(function(param, attribute) {
var widget = param.widget, isMounted = param.isMounted;
var shouldMount = renderState.attributesToRender.indexOf(attribute) > -1;
if (!isMounted && shouldMount) {
widgetsToMount.push(widget);
localWidgets.set(attribute, {
widget: widget,
isMounted: true
});
} else if (isMounted && !shouldMount) {
widgetsToUnmount.push(widget);
localWidgets.set(attribute, {
widget: widget,
isMounted: false
});
}
});
parent.addWidgets(widgetsToMount);
// make sure this only happens after the regular render, otherwise it
// happens too quick, since render is "deferred" for the next microtask,
// so this needs to be a whole task later
setTimeout(function() {
return parent.removeWidgets(widgetsToUnmount);
}, 0);
renderFn(_object_spread_props(_object_spread({}, renderState), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
dispose: function dispose(param) {
var parent = param.parent;
var toRemove = [];
localWidgets.forEach(function(param) {
var widget = param.widget, isMounted = param.isMounted;
if (isMounted) {
toRemove.push(widget);
}
});
parent.removeWidgets(toRemove);
unmountFn();
},
getWidgetSearchParameters: function getWidgetSearchParameters(state) {
return facets.reduce(function(acc, curr) {
return acc.addFacet(curr);
}, state.setQueryParameters({
maxValuesPerFacet: Math.max(maxValuesPerFacet || 0, state.maxValuesPerFacet || 0)
}));
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
dynamicWidgets: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results;
param.state;
var _ref;
var _results_renderingContent_facetOrdering_facets, _results_renderingContent_facetOrdering, _results_renderingContent;
if (!results) {
return {
attributesToRender: [],
widgetParams: widgetParams
};
}
var attributesToRender = transformItems((_ref = (_results_renderingContent = results.renderingContent) === null || _results_renderingContent === void 0 ? void 0 : (_results_renderingContent_facetOrdering = _results_renderingContent.facetOrdering) === null || _results_renderingContent_facetOrdering === void 0 ? void 0 : (_results_renderingContent_facetOrdering_facets = _results_renderingContent_facetOrdering.facets) === null || _results_renderingContent_facetOrdering_facets === void 0 ? void 0 : _results_renderingContent_facetOrdering_facets.order) !== null && _ref !== void 0 ? _ref : [], {
results: results
});
if (!Array.isArray(attributesToRender)) {
throw new Error(withUsage$w('The `transformItems` option expects a function that returns an Array.'));
}
return {
attributesToRender: attributesToRender,
widgetParams: widgetParams
};
}
};
};
};
function useDynamicWidgets(props, additionalWidgetProperties) {
return useConnector(connectDynamicWidgets, _object_spread_props(_object_spread({}, props), {
// We don't rely on InstantSearch.js for rendering widgets because React
// directly manipulates the children.
widgets: []
}), additionalWidgetProperties);
}
function DefaultFallbackComponent() {
return null;
}
function DynamicWidgets(_0) {
var children = _0.children, tmp = _0.fallbackComponent, Fallback = tmp === void 0 ? DefaultFallbackComponent : tmp, props = _object_without_properties(_0, [
"children",
"fallbackComponent"
]);
var FallbackComponent = React.useRef(Fallback);
var attributesToRender = useDynamicWidgets(props, {
$$widgetType: 'ais.dynamicWidgets'
}).attributesToRender;
var widgets = new Map();
React.Children.forEach(children, function(child) {
var attribute = getWidgetAttribute(child);
invariant(attribute !== undefined);
widgets.set(attribute, child);
});
return /*#__PURE__*/ React.createElement(React.Fragment, null, attributesToRender.map(function(attribute) {
return /*#__PURE__*/ React.createElement(React.Fragment, {
key: attribute
}, widgets.get(attribute) || /*#__PURE__*/ React.createElement(FallbackComponent.current, {
attribute: attribute
}));
}));
}
function isReactElement(element) {
return (typeof element === "undefined" ? "undefined" : _type_of(element)) === 'object' && element.props;
}
function getWidgetAttribute(element) {
if (!isReactElement(element)) {
return undefined;
}
if (element.props.attribute) {
return element.props.attribute;
}
if (Array.isArray(element.props.attributes)) {
return element.props.attributes[0];
}
if (element.props.children) {
invariant(React.Children.count(element.props.children) === 1);
return getWidgetAttribute(React.Children.only(element.props.children));
}
return undefined;
}
function reduceChildrenUiState(widgets, uiState, widgetUiStateOptions) {
return widgets.reduce(function(state, widget) {
return widget.getWidgetUiState ? widget.getWidgetUiState(state, widgetUiStateOptions) : state;
}, uiState);
}
function createFeedContainer(feedID, parentIndex, instantSearchInstance) {
var localWidgets = [];
var initialized = false;
var container = {
$$type: 'ais.feedContainer',
$$widgetType: 'ais.feedContainer',
_isolated: true,
getIndexName: function getIndexName() {
return parentIndex.getIndexName();
},
getIndexId: function getIndexId() {
return feedID;
},
getHelper: function getHelper() {
return parentIndex.getHelper();
},
getResults: function getResults() {
var parentResults = parentIndex.getResults();
if (!parentResults) return null;
if (!parentResults.feeds) {
// Single-feed backward compat: no feeds array means the parent result
// itself is the only feed.
if (feedID === '') {
parentResults._state = parentIndex.getHelper().state;
return parentResults;
}
return null;
}
var feed = parentResults.feeds.find(function(f) {
return f.feedID === feedID;
});
if (!feed) return null;
// Optimistic state patching — same as index widget (index.ts:365-370)
feed._state = parentIndex.getHelper().state;
return feed;
},
getResultsForWidget: function getResultsForWidget() {
return this.getResults();
},
getParent: function getParent() {
return parentIndex;
},
getWidgets: function getWidgets() {
return localWidgets;
},
getScopedResults: function getScopedResults() {
return parentIndex.getScopedResults();
},
getPreviousState: function getPreviousState() {
return null;
},
createURL: function createURL(nextState) {
return parentIndex.createURL(nextState);
},
scheduleLocalSearch: function scheduleLocalSearch() {
return parentIndex.scheduleLocalSearch();
},
addWidgets: function addWidgets(widgets) {
var flatWidgets = widgets.reduce(function(acc, w) {
return acc.concat(Array.isArray(w) ? w : [
w
]);
}, []);
flatWidgets.forEach(function(widget) {
widget.parent = container;
});
localWidgets = localWidgets.concat(flatWidgets);
if (initialized) {
flatWidgets.forEach(function(widget) {
if (widget.getRenderState) {
var renderState = widget.getRenderState(instantSearchInstance.renderState[container.getIndexId()] || {}, createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
storeRenderState({
renderState: renderState,
instantSearchInstance: instantSearchInstance,
parent: container
});
}
});
flatWidgets.forEach(function(widget) {
if (widget.init) {
widget.init(createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
}
});
// Merge children's search params (e.g. disjunctiveFacets) into the
// parent's helper state so they're included in the composition request.
// uiState is {} because URL-derived refinements are already on the
// parent state; children only need to declare structural params.
var parentHelper = parentIndex.getHelper();
var withChildParams = container.getWidgetSearchParameters(parentHelper.state, {
uiState: {}
});
if (withChildParams !== parentHelper.state) {
parentHelper.setState(withChildParams);
}
}
return container;
},
removeWidgets: function removeWidgets(widgets) {
var flatWidgets = widgets.reduce(function(acc, w) {
return acc.concat(Array.isArray(w) ? w : [
w
]);
}, []);
var helper = parentIndex.getHelper();
if (!helper) {
localWidgets = localWidgets.filter(function(w) {
return !flatWidgets.includes(w);
});
return container;
}
// Chain through children's dispose so widgets clean up the
// SearchParameters they declared (e.g. RefinementList removes its
// disjunctiveFacet) instead of leaving them stale on the parent helper.
var cleanedState = helper.state;
flatWidgets.forEach(function(widget) {
if (widget.dispose) {
var next = widget.dispose({
helper: helper,
state: cleanedState,
recommendState: helper.recommendState,
parent: container
});
if (_instanceof(next, algoliasearchHelper.RecommendParameters)) ;
else if (next) {
cleanedState = next;
}
}
});
localWidgets = localWidgets.filter(function(w) {
return !flatWidgets.includes(w);
});
if (cleanedState !== helper.state) {
helper.setState(cleanedState);
}
return container;
},
init: function init() {
initialized = true;
localWidgets.forEach(function(widget) {
if (widget.getRenderState) {
var renderState = widget.getRenderState(instantSearchInstance.renderState[container.getIndexId()] || {}, createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
storeRenderState({
renderState: renderState,
instantSearchInstance: instantSearchInstance,
parent: container
});
}
});
localWidgets.forEach(function(widget) {
if (widget.init) {
widget.init(createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
}
});
},
render: function render() {
localWidgets.forEach(function(widget) {
if (widget.getRenderState) {
var renderState = widget.getRenderState(instantSearchInstance.renderState[container.getIndexId()] || {}, createRenderArgs(instantSearchInstance, container, widget));
storeRenderState({
renderState: renderState,
instantSearchInstance: instantSearchInstance,
parent: container
});
}
});
localWidgets.forEach(function(widget) {
if (widget.render) {
widget.render(createRenderArgs(instantSearchInstance, container, widget));
}
});
},
dispose: function dispose(disposeOptions) {
var _ref;
var helper = parentIndex.getHelper();
// Chain through children's dispose to return a cleaned state
// (e.g. RefinementList.dispose removes its disjunctiveFacet declaration).
// This mirrors how the index widget's removeWidgets chains dispose calls.
var cleanedState = (_ref = disposeOptions === null || disposeOptions === void 0 ? void 0 : disposeOptions.state) !== null && _ref !== void 0 ? _ref : helper === null || helper === void 0 ? void 0 : helper.state;
localWidgets.forEach(function(widget) {
if (widget.dispose && helper) {
var next = widget.dispose({
helper: helper,
state: cleanedState,
recommendState: helper.recommendState,
parent: container
});
if (_instanceof(next, algoliasearchHelper.RecommendParameters)) ;
else if (next) {
cleanedState = next;
}
}
});
localWidgets = [];
initialized = false;
return cleanedState;
},
getWidgetState: function getWidgetState(uiState) {
return this.getWidgetUiState(uiState);
},
getWidgetUiState: function getWidgetUiState(uiState) {
var helper = parentIndex.getHelper();
return reduceChildrenUiState(localWidgets, uiState, {
searchParameters: helper.state,
helper: helper
});
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
return localWidgets.reduce(function(params, widget) {
return widget.getWidgetSearchParameters ? widget.getWidgetSearchParameters(params, {
uiState: uiState
}) : params;
}, searchParameters);
},
updateWidget: function updateWidget(previousWidget, nextWidget) {
var helper = parentIndex.getHelper();
// The `uiState` the children own, read before the previous widget is
// detached, so that the state it owns can be handed over to the next one.
var previousUiState = helper ? reduceChildrenUiState(localWidgets, {}, {
searchParameters: helper.state,
helper: helper
}) : {};
previousWidget.parent = undefined;
nextWidget.parent = container;
// The next widget takes the place of the previous one, so that the order
// in which children contribute to the search parameters is unchanged.
var nextWidgets = localWidgets.slice();
var position = nextWidgets.indexOf(previousWidget);
if (position === -1) {
nextWidgets.push(nextWidget);
} else {
nextWidgets[position] = nextWidget;
}
localWidgets = nextWidgets;
if (!helper || !initialized) {
return container;
}
// We still dispose the previous widget, for its side effects and so that
// it drops the search parameters it declared on the parent helper.
var cleanedState = helper.state;
if (previousWidget.dispose) {
var next = previousWidget.dispose({
helper: helper,
state: cleanedState,
recommendState: helper.recommendState,
parent: container
});
if (next && !_instanceof(next, algoliasearchHelper.RecommendParameters)) {
cleanedState = next;
}
}
// We hand the previous `uiState` over to the children, then read the
// `uiState` back from them, so that state no mounted child claims anymore
// is dropped. This mirrors the index widget's `updateWidget`.
var narrowedUiState = reduceChildrenUiState(localWidgets, {}, {
searchParameters: container.getWidgetSearchParameters(cleanedState, {
uiState: previousUiState
}),
helper: helper
});
// The search parameters are then computed again from that narrowed
// `uiState`, so that they can't hold state the `uiState` doesn't describe.
var newState = container.getWidgetSearchParameters(cleanedState, {
uiState: narrowedUiState
});
if (nextWidget.getRenderState) {
var renderState = nextWidget.getRenderState(instantSearchInstance.renderState[container.getIndexId()] || {}, createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
storeRenderState({
renderState: renderState,
instantSearchInstance: instantSearchInstance,
parent: container
});
}
if (nextWidget.init) {
nextWidget.init(createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
}
if (newState !== helper.state) {
helper.setState(newState);
}
return container;
},
refreshUiState: function refreshUiState() {
// no-op: FeedContainer doesn't own UI state
},
setIndexUiState: function setIndexUiState() {
// no-op: FeedContainer delegates to parent
}
};
return container;
}
function toFeedSearchResults(state, raw) {
return Object.assign(new algoliasearchHelper.SearchResults(state, [
raw
]), {
feedID: raw.feedID
});
}
/**
* Rebuild `lastResults.feeds` from `_initialResults.compositionFeedsResults`
* because the index-widget hydration only restores `lastResults` (the merged
* view), not the per-feed breakdown that the Feeds connector needs.
*/ function hydrateFeedsFromInitialResultsIfNeeded(instantSearchInstance, parent) {
var _instantSearchInstance__initialResults, _parent_getHelper;
var initial = (_instantSearchInstance__initialResults = instantSearchInstance._initialResults) === null || _instantSearchInstance__initialResults === void 0 ? void 0 : _instantSearchInstance__initialResults[parent.getIndexId()];
var compositionFeedsResults = (initial === null || initial === void 0 ? void 0 : initial.compositionFeedsResults) || [];
if (compositionFeedsResults.length === 0) {
return;
}
var lastResults = (_parent_getHelper = parent.getHelper()) === null || _parent_getHelper === void 0 ? void 0 : _parent_getHelper.lastResults;
if (!lastResults) {
return;
}
if (lastResults.feeds && lastResults.feeds.length > 0) {
return;
}
lastResults.feeds = compositionFeedsResults.map(function(raw) {
return toFeedSearchResults(lastResults._state, raw);
});
}
var withUsage$v = createDocumentationMessageGenerator({
name: 'feeds',
connector: true
});
var connectFeeds = function connectFeeds(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$v());
return function(widgetParams) {
var isolated = widgetParams.isolated, _widgetParams_transformFeeds = widgetParams.transformFeeds, transformFeeds = _widgetParams_transformFeeds === void 0 ? function(feeds) {
return feeds;
} : _widgetParams_transformFeeds;
if (isolated !== false) {
throw new Error(withUsage$v('The `isolated` option currently only supports `false`.'));
}
return {
$$type: 'ais.feeds',
$$widgetType: 'ais.feeds',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
if (!instantSearchInstance.compositionID) {
throw new Error(withUsage$v('The `feeds` widget requires a composition-based InstantSearch instance (compositionID must be set).'));
}
hydrateFeedsFromInitialResultsIfNeeded(instantSearchInstance, initOptions.parent);
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose() {
unmountFn();
},
getWidgetSearchParameters: function getWidgetSearchParameters(state) {
return state;
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
feeds: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results;
if (!results) {
return {
feedIDs: [],
widgetParams: widgetParams
};
}
if (Array.isArray(results.feeds) && results.feeds.length > 0 && !results.feeds.every(function(feed) {
return _instanceof(feed, algoliasearchHelper.SearchResults);
})) {
results.feeds = results.feeds.map(function(feed) {
return _instanceof(feed, algoliasearchHelper.SearchResults) ? feed : toFeedSearchResults(results._state, feed);
});
}
var feedIDs = results.feeds ? results.feeds.map(function(f) {
return f.feedID;
}) : [
''
];
feedIDs = transformFeeds(feedIDs);
if (!Array.isArray(feedIDs)) {
throw new Error(withUsage$v('The `transformFeeds` option expects a function that returns an Array.'));
}
if (!feedIDs.every(function(feedID) {
return typeof feedID === 'string';
})) {
throw new Error(withUsage$v('The `transformFeeds` option expects a function that returns an array of feed IDs (strings).'));
}
return {
feedIDs: feedIDs,
widgetParams: widgetParams
};
}
};
};
};
function useFeeds(props, additionalWidgetProperties) {
return useConnector(connectFeeds, props, additionalWidgetProperties);
}
function Feeds(_0) {
var renderFeed = _0.renderFeed, props = _object_without_properties(_0, [
"renderFeed"
]);
var feedIDs = useFeeds(props, {
$$widgetType: 'ais.feeds'
}).feedIDs;
var parentIndex = useIndexContext();
var instantSearchInstance = useInstantSearchContext();
var feedContainersRef = React.useRef(new Map());
var removalTimerRef = React.useRef(null);
var pendingRemovalsRef = React.useRef(new Map());
// Create and register new FeedContainers synchronously so SSR and the first
// client render can provide the matching feed index context to children.
var toAdd = [];
feedIDs.forEach(function(feedID) {
if (!feedContainersRef.current.has(feedID)) {
var pendingContainer = pendingRemovalsRef.current.get(feedID);
if (pendingContainer) {
pendingRemovalsRef.current.delete(feedID);
feedContainersRef.current.set(feedID, pendingContainer);
return;
}
var container = createFeedContainer(feedID, parentIndex, instantSearchInstance);
feedContainersRef.current.set(feedID, container);
toAdd.push(container);
}
});
if (toAdd.length > 0) {
parentIndex.addWidgets(toAdd);
}
// Remove containers that are no longer in feedIDs (deferred to match useWidget pattern).
React.useEffect(function() {
var containers = feedContainersRef.current;
var activeSet = new Set(feedIDs);
var toRemove = [];
containers.forEach(function(container, id) {
if (!activeSet.has(id)) {
toRemove.push([
id,
container
]);
containers.delete(id);
}
});
if (toRemove.length > 0) {
toRemove.forEach(function(param) {
var _param = _sliced_to_array(param, 2), id = _param[0], container = _param[1];
pendingRemovalsRef.current.set(id, container);
});
if (removalTimerRef.current !== null) {
clearTimeout(removalTimerRef.current);
}
removalTimerRef.current = setTimeout(function() {
var widgetsToRemove = Array.from(pendingRemovalsRef.current.values());
pendingRemovalsRef.current.clear();
removalTimerRef.current = null;
if (widgetsToRemove.length > 0) {
parentIndex.removeWidgets(widgetsToRemove);
}
}, 0);
}
}, [
feedIDs,
parentIndex
]);
React.useEffect(function() {
return function() {
if (removalTimerRef.current !== null) {
clearTimeout(removalTimerRef.current);
removalTimerRef.current = null;
}
var containers = feedContainersRef.current;
var toRemove = Array.from(new Set(_to_consumable_array(containers.values()).concat(_to_consumable_array(pendingRemovalsRef.current.values()))));
pendingRemovalsRef.current.clear();
containers.clear();
if (toRemove.length > 0) {
parentIndex.removeWidgets(toRemove);
}
};
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []);
return /*#__PURE__*/ React.createElement(React.Fragment, null, feedIDs.map(function(feedID) {
var container = feedContainersRef.current.get(feedID);
if (!container) {
return null;
}
return /*#__PURE__*/ React.createElement(IndexContext.Provider, {
key: feedID,
value: container
}, renderFeed({
feedID: feedID
}));
}));
}
var withUsage$u = createDocumentationMessageGenerator({
name: 'index-widget'
});
/**
* This is the same content as helper._change / setState, but allowing for extra
* UiState to be synchronized.
* see: https://github.com/algolia/algoliasearch-helper-js/blob/6b835ffd07742f2d6b314022cce6848f5cfecd4a/src/algoliasearch.helper.js#L1311-L1324
*/ function privateHelperSetState(helper, param) {
var state = param.state, recommendState = param.recommendState, isPageReset = param.isPageReset, _uiState = param._uiState;
if (state !== helper.state) {
helper.state = state;
helper.emit('change', {
state: helper.state,
results: helper.lastResults,
isPageReset: isPageReset,
_uiState: _uiState
});
}
if (recommendState !== helper.recommendState) {
helper.recommendState = recommendState;
// eslint-disable-next-line no-warning-comments
// TODO: emit "change" event when events for Recommend are implemented
}
}
function getLocalWidgetsUiState(widgets, widgetStateOptions) {
var initialUiState = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
return widgets.reduce(function(uiState, widget) {
if (isIndexWidget(widget)) {
return uiState;
}
if (!widget.getWidgetUiState && !widget.getWidgetState) {
return uiState;
}
if (widget.getWidgetUiState) {
return widget.getWidgetUiState(uiState, widgetStateOptions);
}
return widget.getWidgetState(uiState, widgetStateOptions);
}, initialUiState);
}
function getLocalWidgetsSearchParameters(widgets, widgetSearchParametersOptions) {
var initialSearchParameters = widgetSearchParametersOptions.initialSearchParameters, rest = _object_without_properties(widgetSearchParametersOptions, [
"initialSearchParameters"
]);
return widgets.reduce(function(state, widget) {
if (!widget.getWidgetSearchParameters || isIndexWidget(widget)) {
return state;
}
if (widget.dependsOn === 'search' && widget.getWidgetParameters) {
return widget.getWidgetParameters(state, rest);
}
return widget.getWidgetSearchParameters(state, rest);
}, initialSearchParameters);
}
function getLocalWidgetsRecommendParameters(widgets, widgetRecommendParametersOptions) {
var initialRecommendParameters = widgetRecommendParametersOptions.initialRecommendParameters, rest = _object_without_properties(widgetRecommendParametersOptions, [
"initialRecommendParameters"
]);
return widgets.reduce(function(state, widget) {
if (!isIndexWidget(widget) && widget.dependsOn === 'recommend' && widget.getWidgetParameters) {
return widget.getWidgetParameters(state, rest);
}
return state;
}, initialRecommendParameters);
}
function resetPageFromWidgets(widgets) {
var indexWidgets = widgets.filter(isIndexWidget);
if (indexWidgets.length === 0) {
return;
}
indexWidgets.forEach(function(widget) {
var widgetHelper = widget.getHelper();
privateHelperSetState(widgetHelper, {
state: widgetHelper.state.resetPage(),
recommendState: widgetHelper.recommendState,
isPageReset: true
});
resetPageFromWidgets(widget.getWidgets());
});
}
function resolveScopedResultsFromWidgets(widgets) {
var indexWidgets = widgets.filter(isIndexWidget);
return indexWidgets.reduce(function(scopedResults, current) {
var _scopedResults;
return (_scopedResults = scopedResults).concat.apply(_scopedResults, [
{
indexId: current.getIndexId(),
results: current.getResults(),
helper: current.getHelper()
}
].concat(_to_consumable_array(resolveScopedResultsFromWidgets(current.getWidgets()))));
}, []);
}
function getWidgetsRequestDependencies(widgets) {
return widgets.reduce(function(dependencies, widget) {
if (isIndexWidget(widget)) {
if (widget._isolated) {
return dependencies;
}
var childDependencies = getWidgetsRequestDependencies(widget.getWidgets());
return {
hasSearchWidget: dependencies.hasSearchWidget || childDependencies.hasSearchWidget,
hasRecommendWidget: dependencies.hasRecommendWidget || childDependencies.hasRecommendWidget
};
}
if (widget.dependsOn === 'recommend') {
return _object_spread_props(_object_spread({}, dependencies), {
hasRecommendWidget: true
});
}
if (widget.dependsOn === 'none') {
return dependencies;
}
return _object_spread_props(_object_spread({}, dependencies), {
hasSearchWidget: true
});
}, {
hasSearchWidget: false,
hasRecommendWidget: false
});
}
function recomputeInstantSearchRequestDependencies(instantSearchInstance) {
var _getWidgetsRequestDependencies = getWidgetsRequestDependencies(instantSearchInstance.mainIndex.getWidgets()), hasSearchWidget = _getWidgetsRequestDependencies.hasSearchWidget, hasRecommendWidget = _getWidgetsRequestDependencies.hasRecommendWidget;
instantSearchInstance._hasSearchWidget = hasSearchWidget;
instantSearchInstance._hasRecommendWidget = hasRecommendWidget;
}
var index = function index(widgetParams) {
var _widgetParams_EXPERIMENTAL_isolated;
if (widgetParams === undefined || widgetParams.indexName === undefined && !widgetParams.isolated && !widgetParams.EXPERIMENTAL_isolated) {
throw new Error(withUsage$u('The `indexName` option is required.'));
}
// When isolated=true, we use an empty string as the default indexName.
// This is intentional: isolated indices do not require a real index name.
var _widgetParams_indexName = widgetParams.indexName, indexName = _widgetParams_indexName === void 0 ? '' : _widgetParams_indexName, _widgetParams_indexId = widgetParams.indexId, indexId = _widgetParams_indexId === void 0 ? indexName : _widgetParams_indexId, _widgetParams_isolated = widgetParams.isolated, isolated = _widgetParams_isolated === void 0 ? (_widgetParams_EXPERIMENTAL_isolated = widgetParams.EXPERIMENTAL_isolated) !== null && _widgetParams_EXPERIMENTAL_isolated !== void 0 ? _widgetParams_EXPERIMENTAL_isolated : false : _widgetParams_isolated;
var localWidgets = [];
var localUiState = {};
var localInstantSearchInstance = null;
var localParent = null;
var helper = null;
var derivedHelper = null;
var lastValidSearchParameters = null;
// The error this index has already rolled back for. Renders also happen for
// reasons unrelated to a search (a chat panel opening, a recommend result,
// the stalled timer), and rolling back on every one of them would discard
// state written after the failed search.
var restoredForError;
var recomputeLocalRequestDependencies = function recomputeLocalRequestDependencies() {
if (localInstantSearchInstance) {
recomputeInstantSearchRequestDependencies(localInstantSearchInstance);
}
};
return {
$$type: 'ais.index',
$$widgetType: 'ais.index',
_isolated: isolated,
getIndexName: function getIndexName() {
return indexName;
},
getIndexId: function getIndexId() {
return indexId;
},
getHelper: function getHelper() {
return helper;
},
getResults: function getResults() {
if (!(derivedHelper === null || derivedHelper === void 0 ? void 0 : derivedHelper.lastResults)) return null;
// To make the UI optimistic, we patch the state to display to the current
// one instead of the one associated with the latest results.
// This means user-driven UI changes (e.g., checked checkbox) are reflected
// immediately instead of waiting for Algolia to respond, regardless of
// the status of the network request.
derivedHelper.lastResults._state = helper.state;
return derivedHelper.lastResults;
},
getResultsForWidget: function getResultsForWidget(widget) {
if (widget.dependsOn !== 'recommend' || isIndexWidget(widget) || widget.$$id === undefined) {
return this.getResults();
}
if (!(helper === null || helper === void 0 ? void 0 : helper.lastRecommendResults)) {
return null;
}
return helper.lastRecommendResults[widget.$$id];
},
getPreviousState: function getPreviousState() {
return lastValidSearchParameters;
},
getScopedResults: function getScopedResults() {
var widgetParent = this.getParent();
var widgetSiblings;
if (widgetParent) {
widgetSiblings = widgetParent.getWidgets();
} else if (indexName.length === 0) {
// The widget is the root but has no index name:
// we resolve results from its children index widgets
widgetSiblings = this.getWidgets();
} else {
// The widget is the root and has an index name:
// we consider itself as the only sibling
widgetSiblings = [
this
];
}
return resolveScopedResultsFromWidgets(widgetSiblings);
},
getParent: function getParent() {
return isolated ? null : localParent;
},
createURL: function createURL(nextState) {
if (typeof nextState === 'function') {
return localInstantSearchInstance._createURL(_define_property({}, indexId, nextState(localUiState)));
}
return localInstantSearchInstance._createURL(_define_property({}, indexId, getLocalWidgetsUiState(localWidgets, {
searchParameters: nextState,
helper: helper
})));
},
scheduleLocalSearch: defer(function() {
if (isolated) {
helper === null || helper === void 0 ? void 0 : helper.search();
}
}),
getWidgets: function getWidgets() {
return localWidgets;
},
addWidgets: function addWidgets(widgets) {
var _this = this;
if (!Array.isArray(widgets)) {
throw new Error(withUsage$u('The `addWidgets` method expects an array of widgets.'));
}
var flatWidgets = widgets.reduce(function(acc, w) {
return acc.concat(Array.isArray(w) ? w : [
w
]);
}, []);
if (flatWidgets.some(function(widget) {
return typeof widget.init !== 'function' && typeof widget.render !== 'function';
})) {
throw new Error(withUsage$u('The widget definition expects a `render` and/or an `init` method.'));
}
flatWidgets.forEach(function(widget) {
widget.parent = _this;
if (!isIndexWidget(widget)) {
addWidgetId(widget);
}
});
localWidgets = localWidgets.concat(flatWidgets);
recomputeLocalRequestDependencies();
if (localInstantSearchInstance && Boolean(flatWidgets.length)) {
privateHelperSetState(helper, {
state: getLocalWidgetsSearchParameters(localWidgets, {
uiState: localUiState,
initialSearchParameters: helper.state
}),
recommendState: getLocalWidgetsRecommendParameters(localWidgets, {
uiState: localUiState,
initialRecommendParameters: helper.recommendState
}),
_uiState: localUiState
});
// We compute the render state before calling `init` in a separate loop
// to construct the whole render state object that is then passed to
// `init`.
flatWidgets.forEach(function(widget) {
if (widget.getRenderState) {
var renderState = widget.getRenderState(localInstantSearchInstance.renderState[_this.getIndexId()] || {}, createInitArgs(localInstantSearchInstance, _this, localInstantSearchInstance._initialUiState));
storeRenderState({
renderState: renderState,
instantSearchInstance: localInstantSearchInstance,
parent: _this
});
}
});
flatWidgets.forEach(function(widget) {
if (widget.init) {
widget.init(createInitArgs(localInstantSearchInstance, _this, localInstantSearchInstance._initialUiState));
}
});
if (isolated) {
this.scheduleLocalSearch();
} else {
localInstantSearchInstance.scheduleSearch();
}
}
return this;
},
updateWidget: function updateWidget(previousWidget, nextWidget) {
if (typeof previousWidget.dispose !== 'function') {
throw new Error(withUsage$u('The widget definition expects a `dispose` method.'));
}
if (typeof nextWidget.init !== 'function' && typeof nextWidget.render !== 'function') {
throw new Error(withUsage$u('The widget definition expects a `render` and/or an `init` method.'));
}
// The `uiState` as it is before the previous widget is detached, so that
// the state it owns can be handed over to the next widget.
var previousUiState = localUiState;
previousWidget.parent = undefined;
nextWidget.parent = this;
if (!isIndexWidget(nextWidget)) {
addWidgetId(nextWidget);
}
// The next widget takes the place of the previous one, so that the order
// in which widgets contribute to the search parameters is unchanged.
var nextWidgets = localWidgets.slice();
var position = nextWidgets.indexOf(previousWidget);
if (position === -1) {
nextWidgets.push(nextWidget);
} else {
nextWidgets[position] = nextWidget;
}
localWidgets = nextWidgets;
recomputeLocalRequestDependencies();
if (!localInstantSearchInstance) {
return this;
}
// We still dispose the previous widget, for its side effects. The search
// state it returns is only used as a base when shared state isn't preserved
// on unmount, like in `removeWidgets`.
var disposedState = previousWidget.dispose({
helper: helper,
state: helper.state,
recommendState: helper.recommendState,
parent: this
});
var cleanedRecommendState = _instanceof(disposedState, algoliasearchHelper.RecommendParameters) ? disposedState : helper.recommendState;
var cleanedSearchState = disposedState && !_instanceof(disposedState, algoliasearchHelper.RecommendParameters) ? disposedState : helper.state;
var initialSearchParameters = localInstantSearchInstance.future.preserveSharedStateOnUnmount ? new algoliasearchHelper.SearchParameters({
index: this.getIndexName()
}) : cleanedSearchState;
// We hand the previous `uiState` over to the next widgets, then read the
// `uiState` back from them. Widgets only pick up the state they claim, so
// this drops state that no mounted widget owns anymore (an attribute that
// changed, for instance) instead of seeding it with `previousUiState`.
localUiState = getLocalWidgetsUiState(localWidgets, {
searchParameters: getLocalWidgetsSearchParameters(localWidgets, {
uiState: previousUiState,
initialSearchParameters: initialSearchParameters
}),
helper: helper
});
// The search parameters are then computed again from that narrowed
// `uiState`, so that they can't hold state the `uiState` doesn't describe.
var newState = getLocalWidgetsSearchParameters(localWidgets, {
uiState: localUiState,
initialSearchParameters: initialSearchParameters
});
privateHelperSetState(helper, {
state: newState,
recommendState: getLocalWidgetsRecommendParameters(localWidgets, {
uiState: localUiState,
initialRecommendParameters: cleanedRecommendState
}),
_uiState: localUiState
});
if (nextWidget.getRenderState) {
var renderState = nextWidget.getRenderState(localInstantSearchInstance.renderState[this.getIndexId()] || {}, createInitArgs(localInstantSearchInstance, this, localInstantSearchInstance._initialUiState));
storeRenderState({
renderState: renderState,
instantSearchInstance: localInstantSearchInstance,
parent: this
});
}
if (nextWidget.init) {
nextWidget.init(createInitArgs(localInstantSearchInstance, this, localInstantSearchInstance._initialUiState));
}
if (isolated) {
this.scheduleLocalSearch();
} else {
localInstantSearchInstance.scheduleSearch();
}
return this;
},
removeWidgets: function removeWidgets(widgets) {
var _this = this;
if (!Array.isArray(widgets)) {
throw new Error(withUsage$u('The `removeWidgets` method expects an array of widgets.'));
}
var flatWidgets = widgets.reduce(function(acc, w) {
return acc.concat(Array.isArray(w) ? w : [
w
]);
}, []);
if (flatWidgets.some(function(widget) {
return typeof widget.dispose !== 'function';
})) {
throw new Error(withUsage$u('The widget definition expects a `dispose` method.'));
}
localWidgets = localWidgets.filter(function(widget) {
return flatWidgets.indexOf(widget) === -1;
});
flatWidgets.forEach(function(widget) {
widget.parent = undefined;
});
recomputeLocalRequestDependencies();
if (localInstantSearchInstance && Boolean(flatWidgets.length)) {
var _flatWidgets_reduce = flatWidgets.reduce(function(states, widget) {
// the `dispose` method exists at this point we already assert it
var next = widget.dispose({
helper: helper,
state: states.cleanedSearchState,
recommendState: states.cleanedRecommendState,
parent: _this
});
if (_instanceof(next, algoliasearchHelper.RecommendParameters)) {
states.cleanedRecommendState = next;
} else if (next) {
states.cleanedSearchState = next;
}
return states;
}, {
cleanedSearchState: helper.state,
cleanedRecommendState: helper.recommendState
}), cleanedSearchState = _flatWidgets_reduce.cleanedSearchState, cleanedRecommendState = _flatWidgets_reduce.cleanedRecommendState;
var newState = localInstantSearchInstance.future.preserveSharedStateOnUnmount ? getLocalWidgetsSearchParameters(localWidgets, {
uiState: localUiState,
initialSearchParameters: new algoliasearchHelper.SearchParameters({
index: this.getIndexName()
})
}) : getLocalWidgetsSearchParameters(localWidgets, {
uiState: getLocalWidgetsUiState(localWidgets, {
searchParameters: cleanedSearchState,
helper: helper
}),
initialSearchParameters: cleanedSearchState
});
localUiState = getLocalWidgetsUiState(localWidgets, {
searchParameters: newState,
helper: helper
});
helper.setState(newState);
helper.recommendState = cleanedRecommendState;
if (localWidgets.length) {
if (isolated) {
this.scheduleLocalSearch();
} else {
localInstantSearchInstance.scheduleSearch();
}
}
}
return this;
},
init: function init(param) {
var _this = this;
var instantSearchInstance = param.instantSearchInstance, parent = param.parent, uiState = param.uiState;
var _instantSearchInstance__initialResults;
if (helper !== null) {
// helper is already initialized, therefore we do not need to set up
// any listeners
return;
}
localInstantSearchInstance = instantSearchInstance;
localParent = parent;
localUiState = uiState[indexId] || {};
// The `mainHelper` is already defined at this point. The instance is created
// inside InstantSearch at the `start` method, which occurs before the `init`
// step.
var mainHelper = instantSearchInstance.mainHelper;
var parameters = getLocalWidgetsSearchParameters(localWidgets, {
uiState: localUiState,
initialSearchParameters: new algoliasearchHelper.SearchParameters({
index: indexName
})
});
var recommendParameters = getLocalWidgetsRecommendParameters(localWidgets, {
uiState: localUiState,
initialRecommendParameters: new algoliasearchHelper.RecommendParameters()
});
// This Helper is only used for state management we do not care about the
// `searchClient`. Only the "main" Helper created at the `InstantSearch`
// level is aware of the client.
helper = algoliasearchHelper(mainHelper.getClient(), parameters.index, parameters);
helper.recommendState = recommendParameters;
// We forward the call to `search` to the "main" instance of the Helper
// which is responsible for managing the queries (it's the only one that is
// aware of the `searchClient`).
helper.search = function() {
if (isolated) {
instantSearchInstance.status = 'loading';
_this.render({
instantSearchInstance: instantSearchInstance
});
return instantSearchInstance.compositionID ? helper.searchWithComposition() : helper.searchOnlyWithDerivedHelpers();
}
if (instantSearchInstance.onStateChange) {
instantSearchInstance.onStateChange({
uiState: instantSearchInstance.mainIndex.getWidgetUiState({}),
setUiState: function setUiState(nextState) {
return instantSearchInstance.setUiState(nextState, false);
}
});
// We don't trigger a search when controlled because it becomes the
// responsibility of `setUiState`.
return mainHelper;
}
return mainHelper.search();
};
helper.searchWithoutTriggeringOnStateChange = function() {
return mainHelper.search();
};
// We use the same pattern for the `searchForFacetValues`.
helper.searchForFacetValues = function(facetName, facetValue, maxFacetHits, userState) {
var state = mergeSearchParameters.apply(void 0, [
mainHelper.state
].concat(_to_consumable_array(resolveSearchParameters(_this)))).setQueryParameters(userState);
return mainHelper.searchForFacetValues(facetName, facetValue, maxFacetHits, state);
};
var isolatedHelper = indexName ? helper : algoliasearchHelper({}, '__empty_index__', {});
var derivingHelper = isolated ? isolatedHelper : nearestIsolatedHelper(parent, mainHelper);
derivedHelper = derivingHelper.derive(function() {
return mergeSearchParameters.apply(void 0, [
mainHelper.state
].concat(_to_consumable_array(resolveSearchParameters(_this))));
}, function() {
return addInsightsToRecommendParameters(_this.getHelper().recommendState, mainHelper.state);
});
var indexInitialResults = (_instantSearchInstance__initialResults = instantSearchInstance._initialResults) === null || _instantSearchInstance__initialResults === void 0 ? void 0 : _instantSearchInstance__initialResults[this.getIndexId()];
if (indexInitialResults === null || indexInitialResults === void 0 ? void 0 : indexInitialResults.results) {
// We restore the shape of the results provided to the instance to respect
// the helper's structure.
var results = new algoliasearchHelper.SearchResults(new algoliasearchHelper.SearchParameters(indexInitialResults.state), indexInitialResults.results);
derivedHelper.lastResults = results;
helper.lastResults = results;
}
if (indexInitialResults === null || indexInitialResults === void 0 ? void 0 : indexInitialResults.recommendResults) {
var recommendResults = new algoliasearchHelper.RecommendResults(new algoliasearchHelper.RecommendParameters({
params: indexInitialResults.recommendResults.params
}), indexInitialResults.recommendResults.results);
derivedHelper.lastRecommendResults = recommendResults;
helper.lastRecommendResults = recommendResults;
}
// Subscribe to the Helper state changes for the page before widgets
// are initialized. This behavior mimics the original one of the Helper.
// It makes sense to replicate it at the `init` step. We have another
// listener on `change` below, once `init` is done.
helper.on('change', function(param) {
var isPageReset = param.isPageReset;
if (isPageReset) {
resetPageFromWidgets(localWidgets);
}
});
derivedHelper.on('search', function() {
// The index does not manage the "staleness" of the search. This is the
// responsibility of the main instance. It does not make sense to manage
// it at the index level because it's either: all of them or none of them
// that are stalled. The queries are performed into a single network request.
instantSearchInstance.scheduleStalledRender();
});
derivedHelper.on('result', function(param) {
var results = param.results;
// The index does not render the results it schedules a new render
// to let all the other indices emit their own results. It allows us to
// run the render process in one pass.
instantSearchInstance.scheduleRender();
// the derived helper is the one which actually searches, but the helper
// which is exposed e.g. via instance.helper, doesn't search, and thus
// does not have access to lastResults, which it used to in pre-federated
// search behavior.
helper.lastResults = results;
lastValidSearchParameters = results === null || results === void 0 ? void 0 : results._state;
});
// eslint-disable-next-line no-warning-comments
// TODO: listen to "result" event when events for Recommend are implemented
derivedHelper.on('recommend:result', function(param) {
var recommend = param.recommend;
// The index does not render the results it schedules a new render
// to let all the other indices emit their own results. It allows us to
// run the render process in one pass.
instantSearchInstance.scheduleRender();
// the derived helper is the one which actually searches, but the helper
// which is exposed e.g. via instance.helper, doesn't search, and thus
// does not have access to lastRecommendResults.
helper.lastRecommendResults = recommend.results;
});
// We compute the render state before calling `init` in a separate loop
// to construct the whole render state object that is then passed to
// `init`.
localWidgets.forEach(function(widget) {
if (widget.getRenderState) {
var renderState = widget.getRenderState(instantSearchInstance.renderState[_this.getIndexId()] || {}, createInitArgs(instantSearchInstance, _this, uiState));
storeRenderState({
renderState: renderState,
instantSearchInstance: instantSearchInstance,
parent: _this
});
}
});
localWidgets.forEach(function(widget) {
if (widget.init) {
widget.init(createInitArgs(instantSearchInstance, _this, uiState));
}
});
// Subscribe to the Helper state changes for the `uiState` once widgets
// are initialized. Until the first render, state changes are part of the
// configuration step. This is mainly for backward compatibility with custom
// widgets. When the subscription happens before the `init` step, the (static)
// configuration of the widget is pushed in the URL. That's what we want to avoid.
// https://github.com/algolia/instantsearch/pull/994/commits/4a672ae3fd78809e213de0368549ef12e9dc9454
helper.on('change', function(event) {
var state = event.state;
var _uiState = event._uiState;
localUiState = getLocalWidgetsUiState(localWidgets, {
searchParameters: state,
helper: helper
}, _uiState || {});
// We don't trigger an internal change when controlled because it
// becomes the responsibility of `setUiState`.
if (!instantSearchInstance.onStateChange) {
instantSearchInstance.onInternalStateChange();
}
});
if (indexInitialResults) {
// If there are initial results, we're not notified of the next results
// because we don't trigger an initial search. We therefore need to directly
// schedule a render that will render the results injected on the helper.
instantSearchInstance.scheduleRender();
}
recomputeLocalRequestDependencies();
},
render: function render(param) {
var _this = this;
var instantSearchInstance = param.instantSearchInstance;
// we can't attach a listener to the error event of search, as the error
// then would no longer be thrown for global handlers.
if (instantSearchInstance.status !== 'error') {
restoredForError = undefined;
} else if (instantSearchInstance.error !== restoredForError && !instantSearchInstance.mainHelper.hasPendingRequests() && lastValidSearchParameters) {
restoredForError = instantSearchInstance.error;
helper.setState(lastValidSearchParameters);
}
// We only render index widgets if there are no results.
// This makes sure `render` is never called with `results` being `null`.
// If it's an isolated index without an index name, we render all widgets,
// as there are no results to display for the isolated index itself.
var widgetsToRender = this.getResults() || (derivedHelper === null || derivedHelper === void 0 ? void 0 : derivedHelper.lastRecommendResults) || isolated && !indexName ? localWidgets : localWidgets.filter(function(widget) {
return widget.shouldRender;
});
widgetsToRender = widgetsToRender.filter(function(widget) {
if (!widget.shouldRender) {
return true;
}
return widget.shouldRender({
instantSearchInstance: instantSearchInstance
});
});
widgetsToRender.forEach(function(widget) {
if (widget.getRenderState) {
var renderState = widget.getRenderState(instantSearchInstance.renderState[_this.getIndexId()] || {}, createRenderArgs(instantSearchInstance, _this, widget));
storeRenderState({
renderState: renderState,
instantSearchInstance: instantSearchInstance,
parent: _this
});
}
});
widgetsToRender.forEach(function(widget) {
// At this point, all the variables used below are set. Both `helper`
// and `derivedHelper` have been created at the `init` step. The attribute
// `lastResults` might be `null` though. It's possible that a stalled render
// happens before the result e.g with a dynamically added index the request might
// be delayed. The render is triggered for the complete tree but some parts do
// not have results yet.
if (widget.render) {
widget.render(createRenderArgs(instantSearchInstance, _this, widget));
}
});
},
dispose: function dispose() {
var _this = this;
localWidgets.forEach(function(widget) {
if (widget.dispose && helper) {
// The dispose function is always called once the instance is started
// (it's an effect of `removeWidgets`). The index is initialized and
// the Helper is available. We don't care about the return value of
// `dispose` because the index is removed. We can't call `removeWidgets`
// because we want to keep the widgets on the instance, to allow idempotent
// operations on `add` & `remove`.
widget.dispose({
helper: helper,
state: helper.state,
recommendState: helper.recommendState,
parent: _this
});
}
});
localInstantSearchInstance = null;
localParent = null;
helper === null || helper === void 0 ? void 0 : helper.removeAllListeners();
helper = null;
derivedHelper === null || derivedHelper === void 0 ? void 0 : derivedHelper.detach();
derivedHelper = null;
},
getWidgetUiState: function getWidgetUiState(uiState) {
return localWidgets.filter(isIndexWidget).filter(function(w) {
return !w._isolated;
}).reduce(function(previousUiState, innerIndex) {
return innerIndex.getWidgetUiState(previousUiState);
}, _object_spread_props(_object_spread({}, uiState), _define_property({}, indexId, _object_spread({}, uiState[indexId], localUiState))));
},
getWidgetState: function getWidgetState(uiState) {
return this.getWidgetUiState(uiState);
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
return getLocalWidgetsSearchParameters(localWidgets, {
uiState: uiState,
initialSearchParameters: searchParameters
});
},
shouldRender: function shouldRender() {
return true;
},
refreshUiState: function refreshUiState() {
localUiState = getLocalWidgetsUiState(localWidgets, {
searchParameters: this.getHelper().state,
helper: this.getHelper()
}, localUiState);
},
setIndexUiState: function setIndexUiState(indexUiState) {
var nextIndexUiState = typeof indexUiState === 'function' ? indexUiState(localUiState) : indexUiState;
localInstantSearchInstance.setUiState(function(state) {
return _object_spread_props(_object_spread({}, state), _define_property({}, indexId, nextIndexUiState));
});
}
};
};
/**
* Walk up the parent chain to find the closest isolated index, or fall back to mainHelper
*/ function nearestIsolatedHelper(current, mainHelper) {
while(current){
if (current._isolated) {
return current.getHelper();
}
current = current.getParent();
}
return mainHelper;
}
/**
* Forces a React update that triggers a rerender.
* @link https://reactjs.org/docs/hooks-faq.html#is-there-something-like-forceupdate
*/ function useForceUpdate() {
var _useReducer = _sliced_to_array(React.useReducer(function(x) {
return x + 1;
}, 0), 2), forceUpdate = _useReducer[1];
return forceUpdate;
}
function useIndex(props) {
var serverContext = useInstantSearchServerContext();
var ssrContext = useInstantSearchSSRContext();
var initialResults = ssrContext === null || ssrContext === void 0 ? void 0 : ssrContext.initialResults;
var parentIndex = useIndexContext();
var stableProps = useStableValue(props);
var indexWidget = React.useMemo(function() {
return index(stableProps);
}, [
stableProps
]);
var helper = indexWidget.getHelper();
var forceUpdate = useForceUpdate();
useIsomorphicLayoutEffect(function() {
forceUpdate();
}, [
helper,
forceUpdate
]);
useWidget({
widget: indexWidget,
parentIndex: parentIndex,
props: stableProps,
shouldSsr: Boolean(serverContext || initialResults),
skipSuspense: true
});
return indexWidget;
}
function Index(_0) {
var children = _0.children, props = _object_without_properties(_0, [
"children"
]);
var index = useIndex(props);
if (index.getHelper() === null) {
return null;
}
return /*#__PURE__*/ React.createElement(IndexContext.Provider, {
value: index
}, children);
}
function _get_prototype_of(o) {
_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _get_prototype_of(o);
}
function _is_native_reflect_construct() {
// Since Reflect.construct can't be properly polyfilled, some
// implementations (e.g. core-js@2) don't set the correct internal slots.
// Those polyfills don't allow us to subclass built-ins, so we need to
// use our fallback implementation.
try {
// If the internal slots aren't set, this throws an error similar to
// TypeError: this is not a Boolean object.
var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
} catch (_) {}
return (_is_native_reflect_construct = function() {
return !!result;
})();
}
function _assert_this_initialized(self) {
if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
return self;
}
function _possible_constructor_return(self, call) {
if (call && (_type_of(call) === "object" || typeof call === "function")) return call;
return _assert_this_initialized(self);
}
function _call_super(_this, derived, args) {
// Super
derived = _get_prototype_of(derived);
return _possible_constructor_return(
_this,
_is_native_reflect_construct()
// NOTE: This doesn't work if this.__proto__.constructor has been modified.
? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor)
: derived.apply(_this, args)
);
}
function _class_call_check(instance, Constructor) {
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _create_class(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
return Constructor;
}
function _set_prototype_of(o, p) {
_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _set_prototype_of(o, p);
}
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function");
}
subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
if (superClass) _set_prototype_of(subClass, superClass);
}
var eventsExports = requireEvents();
var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
/**
* Create UUID according to
* https://www.ietf.org/rfc/rfc4122.txt.
*
* @returns Generated UUID.
*/ function createUUID() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
/* eslint-disable no-bitwise */ var r = Math.random() * 16 | 0;
var v = c === 'x' ? r : r & 0x3 | 0x8;
/* eslint-enable */ return v.toString(16);
});
}
var version = '4.117.0';
var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
function getCookie(name) {
if ((typeof document === "undefined" ? "undefined" : _type_of(document)) !== 'object' || typeof document.cookie !== 'string') {
return undefined;
}
var prefix = "".concat(name, "=");
var cookies = document.cookie.split(';');
for(var i = 0; i < cookies.length; i++){
var cookie = cookies[i];
while(cookie.charAt(0) === ' '){
cookie = cookie.substring(1);
}
if (cookie.indexOf(prefix) === 0) {
return cookie.substring(prefix.length, cookie.length);
}
}
return undefined;
}
function getInsightsAnonymousUserTokenInternal() {
return getCookie(ANONYMOUS_TOKEN_COOKIE_KEY);
}
var USAGE_SESSION_KEY = 'ais.usage.sessionId';
// Cache the id for the lifetime of the runtime so repeated calls don't hit
// `sessionStorage` again, and so we always return the same id even when
// storage is unavailable (SSR, privacy mode) and we fall back to a fresh UUID.
var usageSessionId = null;
function getUsageSessionId() {
if (usageSessionId) {
return usageSessionId;
}
try {
var existing = sessionStorage.getItem(USAGE_SESSION_KEY);
if (existing) {
usageSessionId = existing;
return usageSessionId;
}
usageSessionId = createUUID();
sessionStorage.setItem(USAGE_SESSION_KEY, usageSessionId);
return usageSessionId;
} catch (unused) {
// sessionStorage unavailable (SSR, privacy mode, etc.)
usageSessionId = createUUID();
return usageSessionId;
}
}
/** @deprecated use bindEvent instead */ function writeDataAttributes(param) {
var method = param.method, payload = param.payload;
if ((typeof payload === "undefined" ? "undefined" : _type_of(payload)) !== 'object') {
throw new Error("The insights helper expects the payload to be an object.");
}
var serializedPayload;
try {
serializedPayload = serializePayload(payload);
} catch (error) {
throw new Error("Could not JSON serialize the payload object.");
}
return 'data-insights-method="'.concat(method, '" data-insights-payload="').concat(serializedPayload, '"');
}
/**
* @deprecated This function will be still supported in 4.x releases, but not further. It is replaced by the `insights` middleware. For more information, visit https://www.algolia.com/doc/guides/getting-insights-and-analytics/search-analytics/click-through-and-conversions/how-to/send-click-and-conversion-events-with-instantsearch/js/
*/ function insights(method, payload) {
return writeDataAttributes({
method: method,
payload: payload
});
}
var ALGOLIA_INSIGHTS_VERSION = '2.17.2';
var ALGOLIA_INSIGHTS_SRC = "https://cdn.jsdelivr.net/npm/search-insights@".concat(ALGOLIA_INSIGHTS_VERSION, "/dist/search-insights.min.js");
// InstantSearch options that must never be sent in usage events because
// they carry credentials or end-user data. Everything else is reported as-is.
var SENSITIVE_OPTIONS = [
'searchClient',
'insightsClient',
'initialUiState'
];
function createInsightsMiddleware() {
var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var _insightsClient = props.insightsClient, insightsInitParams = props.insightsInitParams, onEvent = props.onEvent, _props_$$internal = props.$$internal, $$internal = _props_$$internal === void 0 ? false : _props_$$internal, _props_$$automatic = props.$$automatic, $$automatic = _props_$$automatic === void 0 ? false : _props_$$automatic;
var potentialInsightsClient = _insightsClient;
if (!_insightsClient && _insightsClient !== null) {
safelyRunOnBrowser(function(param) {
var window = param.window;
var pointer = window.AlgoliaAnalyticsObject || 'aa';
if (typeof pointer === 'string') {
potentialInsightsClient = window[pointer];
}
if (!potentialInsightsClient) {
window.AlgoliaAnalyticsObject = pointer;
if (!window[pointer]) {
window[pointer] = function() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
if (!window[pointer].queue) {
window[pointer].queue = [];
}
window[pointer].queue.push(args);
};
window[pointer].version = ALGOLIA_INSIGHTS_VERSION;
window[pointer].shouldAddScript = true;
}
potentialInsightsClient = window[pointer];
}
});
}
// if still no insightsClient was found, we use a noop
var insightsClient = potentialInsightsClient || noop;
return function(param) {
var instantSearchInstance = param.instantSearchInstance;
var _instantSearchInstance;
// remove existing default insights middleware
// user-provided insights middleware takes precedence
var existingInsightsMiddlewares = instantSearchInstance.middleware.filter(function(m) {
return m.instance.$$type === 'ais.insights' && m.instance.$$internal;
}).map(function(m) {
return m.creator;
});
(_instantSearchInstance = instantSearchInstance).unuse.apply(_instantSearchInstance, _to_consumable_array(existingInsightsMiddlewares));
var _getAppIdAndApiKey = _sliced_to_array(getAppIdAndApiKey(instantSearchInstance.client), 2), appId = _getAppIdAndApiKey[0], apiKey = _getAppIdAndApiKey[1];
var queuedInitParams = undefined;
var queuedUserToken = undefined;
var userTokenBeforeInit = undefined;
var queue = insightsClient.queue;
if (Array.isArray(queue)) {
var ref;
// Context: The umd build of search-insights is asynchronously loaded by the snippet.
//
// When user calls `aa('setUserToken', 'my-user-token')` before `search-insights` is loaded,
// ['setUserToken', 'my-user-token'] gets stored in `aa.queue`.
// Whenever `search-insights` is finally loaded, it will process the queue.
//
// But here's the reason why we handle it here:
// At this point, even though `search-insights` is not loaded yet,
// we still want to read the token from the queue.
// Otherwise, the first search call will be fired without the token.
ref = _sliced_to_array([
'setUserToken',
'init'
].map(function(key) {
var _ref = _sliced_to_array(find$1(queue.slice().reverse(), function(param) {
var _param = _sliced_to_array(param, 1), method = _param[0];
return method === key;
}) || [], 2), value = _ref[1];
return value;
}), 2), queuedUserToken = ref[0], queuedInitParams = ref[1];
}
// If user called `aa('setUserToken')` before creating the Insights middleware,
// we temporarily store the token and set it later on.
//
// Otherwise, the `init` call might override them with anonymous user token.
insightsClient('getUserToken', null, function(_error, userToken) {
userTokenBeforeInit = normalizeUserToken(userToken);
});
// Only `init` if the `insightsInitParams` option is passed or
// if the `insightsClient` version doesn't supports optional `init` calling.
if (insightsInitParams || !isModernInsightsClient(insightsClient)) {
insightsClient('init', _object_spread({
appId: appId,
apiKey: apiKey,
partial: true
}, insightsInitParams));
}
var initialParameters;
var helper;
var removeStartEventListener = null;
return {
$$type: 'ais.insights',
$$internal: $$internal,
$$automatic: $$automatic,
onStateChange: function onStateChange() {},
subscribe: function subscribe() {
if (!insightsClient.shouldAddScript) return;
var errorMessage = '[insights middleware]: could not load search-insights.js. Please load it manually following https://alg.li/insights-init';
try {
var script = document.createElement('script');
script.async = true;
script.src = ALGOLIA_INSIGHTS_SRC;
script.onerror = function() {
instantSearchInstance.emit('error', new Error(errorMessage));
};
document.body.appendChild(script);
insightsClient.shouldAddScript = false;
} catch (cause) {
insightsClient.shouldAddScript = false;
instantSearchInstance.emit('error', new Error(errorMessage));
}
},
started: function started() {
insightsClient('addAlgoliaAgent', 'insights-middleware');
helper = instantSearchInstance.mainHelper;
var queueAtStart = insightsClient.queue;
if (Array.isArray(queueAtStart)) {
var ref;
ref = _sliced_to_array([
'setUserToken',
'init'
].map(function(key) {
var _ref = _sliced_to_array(find$1(queueAtStart.slice().reverse(), function(param) {
var _param = _sliced_to_array(param, 1), method = _param[0];
return method === key;
}) || [], 2), value = _ref[1];
return value;
}), 2), queuedUserToken = ref[0], queuedInitParams = ref[1];
}
initialParameters = getInitialParameters(instantSearchInstance);
// We don't want to force clickAnalytics when the insights is enabled from the search response.
// This means we don't enable insights for indices that don't opt in
if (!$$automatic) {
helper.overrideStateWithoutTriggeringChangeEvent(_object_spread_props(_object_spread({}, helper.state), {
clickAnalytics: true
}));
}
if (!$$internal) {
instantSearchInstance.scheduleSearch();
}
var setUserTokenToSearch = function setUserTokenToSearch(userToken) {
var immediate = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
var normalizedUserToken = normalizeUserToken(userToken);
if (!normalizedUserToken) {
return;
}
var existingToken = helper.state.userToken;
function applyToken() {
helper.overrideStateWithoutTriggeringChangeEvent(_object_spread_props(_object_spread({}, helper.state), {
userToken: normalizedUserToken
}));
if (existingToken && existingToken !== normalizedUserToken) {
helper._recommendCache = {};
instantSearchInstance.scheduleSearch();
}
}
// Delay the token application to the next render cycle
if (!immediate) {
setTimeout(applyToken, 0);
} else {
applyToken();
}
};
function setUserToken(token) {
setUserTokenToSearch(token, true);
insightsClient('setUserToken', token);
}
var anonymousUserToken = undefined;
var anonymousTokenFromInsights = getInsightsAnonymousUserTokenInternal();
if (anonymousTokenFromInsights) {
// When `aa('init', { ... })` is called, it creates an anonymous user token in cookie.
// We can set it as userToken on instantsearch and insights. If it's not set as an insights
// userToken before a sendEvent, insights automatically generates a new anonymous token,
// causing a state change and an unnecessary query on instantsearch.
anonymousUserToken = anonymousTokenFromInsights;
} else {
var token = "anonymous-".concat(createUUID());
anonymousUserToken = token;
}
var userTokenFromInit;
// With SSR, the token could be be set on the state. We make sure
// that insights is in sync with that token since, there is no
// insights lib on the server.
var tokenFromSearchParameters = initialParameters.userToken;
// When the first query is sent, the token is possibly not yet set by
// the insights onChange callbacks (if insights isn't yet loaded).
// It is explicitly being set here so that the first query has the
// initial tokens set and ensure a second query isn't automatically
// made when the onChange callback actually changes the state.
if (insightsInitParams === null || insightsInitParams === void 0 ? void 0 : insightsInitParams.userToken) {
userTokenFromInit = insightsInitParams.userToken;
}
if (userTokenFromInit) {
setUserToken(userTokenFromInit);
} else if (tokenFromSearchParameters) {
setUserToken(tokenFromSearchParameters);
} else if (userTokenBeforeInit) {
setUserToken(userTokenBeforeInit);
} else if (queuedUserToken) {
setUserToken(queuedUserToken);
} else if (anonymousUserToken) {
setUserToken(anonymousUserToken);
if ((insightsInitParams === null || insightsInitParams === void 0 ? void 0 : insightsInitParams.useCookie) || (queuedInitParams === null || queuedInitParams === void 0 ? void 0 : queuedInitParams.useCookie)) {
saveTokenAsCookie(anonymousUserToken, (insightsInitParams === null || insightsInitParams === void 0 ? void 0 : insightsInitParams.cookieDuration) || (queuedInitParams === null || queuedInitParams === void 0 ? void 0 : queuedInitParams.cookieDuration));
}
}
// This updates userToken which is set explicitly by `aa('setUserToken', userToken)`
insightsClient('onUserTokenChange', function(token) {
return setUserTokenToSearch(token, true);
}, {
immediate: true
});
var insightsClientWithLocalCredentials = insightsClient;
if (isModernInsightsClient(insightsClient)) {
insightsClientWithLocalCredentials = function insightsClientWithLocalCredentials(method, payload) {
var _getAppIdAndApiKey = _sliced_to_array(getAppIdAndApiKey(instantSearchInstance.client), 2), latestAppId = _getAppIdAndApiKey[0], latestApiKey = _getAppIdAndApiKey[1];
var extraParams = {
headers: {
'X-Algolia-Application-Id': latestAppId,
'X-Algolia-API-Key': latestApiKey
}
};
// @ts-ignore we are calling this only when we know that the client actually is correct
return insightsClient(method, payload, extraParams);
};
}
var viewedObjectIDs = new Set();
var lastQueryId;
instantSearchInstance.mainHelper.derivedHelpers[0].on('result', function(param) {
var results = param.results;
if (results && (!results.queryID || results.queryID !== lastQueryId)) {
lastQueryId = results.queryID;
viewedObjectIDs.clear();
}
});
instantSearchInstance.sendEventToInsights = function(event) {
if (onEvent) {
onEvent(event, insightsClientWithLocalCredentials);
} else if (event.insightsMethod) {
if (event.insightsMethod === 'viewedObjectIDs') {
var payload = event.payload;
var getViewEventKey = function getViewEventKey(objectID) {
return payload.queryID ? "".concat(payload.queryID, ":").concat(objectID) : objectID;
};
var difference = payload.objectIDs.filter(function(objectID) {
return !viewedObjectIDs.has(getViewEventKey(objectID));
});
if (difference.length === 0) {
return;
}
difference.forEach(function(objectID) {
return viewedObjectIDs.add(getViewEventKey(objectID));
});
payload.objectIDs = difference;
}
// Source is used to differentiate events sent by instantsearch from those sent manually.
event.payload.algoliaSource = [
'instantsearch'
];
if ($$automatic) {
event.payload.algoliaSource.push('instantsearch-automatic');
}
if (event.eventModifier === 'internal') {
event.payload.algoliaSource.push('instantsearch-internal');
}
insightsClientWithLocalCredentials(event.insightsMethod, event.payload);
} else ;
};
// usage tracking (browser-only)
safelyRunOnBrowser(function() {
var usageSessionId = getUsageSessionId();
function sendUsageEvent(event) {
var _helper_state;
var userToken = (_helper_state = helper.state) === null || _helper_state === void 0 ? void 0 : _helper_state.userToken;
insightsClientWithLocalCredentials('sendEvents', [
_object_spread({
eventType: 'instantsearch',
timestamp: Date.now(),
sessionID: usageSessionId,
userToken: userToken ? String(userToken) : undefined
}, event)
]);
}
// Send the start event on the first `render`, by which point every
// flavor has registered its widgets. `bootstrapMs` then measures the
// time between the constructor running and that point, so for flavors
// that register widgets right at start (e.g. React) it captures the
// cost of adding them.
var sendStartEvent = function sendStartEvent() {
try {
var bootstrapMs = Math.round(now() - instantSearchInstance._createdAt);
sendUsageEvent({
eventName: '__start__',
algoliaAgent: getAlgoliaAgent(instantSearchInstance.client),
version: version,
applicationId: appId,
performance: {
bootstrapMs: bootstrapMs
},
widgets: [
{
type: 'ais.instantSearch',
// The options the instance was created with, serialized the
// same way every widget's params are. Derived dynamically from
// `_initialOptions` so new options are reported automatically,
// minus the keys that carry credentials or user data. Functions
// (`onStateChange`, `searchFunction`) report their `fn.name`
// when present, tagged `type: 'function'`.
params: instantSearchInstance._initialOptions ? serializeWidgetParams(omit(instantSearchInstance._initialOptions, _to_consumable_array(SENSITIVE_OPTIONS))) : [],
children: buildWidgetTree(instantSearchInstance.mainIndex.getWidgets(), instantSearchInstance)
}
]
});
} catch (unused) {
// usage tracking must never crash the host app
}
};
instantSearchInstance.once('render', sendStartEvent);
removeStartEventListener = function removeStartEventListener() {
return instantSearchInstance.removeListener('render', sendStartEvent);
};
});
},
unsubscribe: function unsubscribe() {
if (removeStartEventListener) {
removeStartEventListener();
}
insightsClient('onUserTokenChange', undefined);
instantSearchInstance.sendEventToInsights = noop;
if (helper && initialParameters) {
helper.overrideStateWithoutTriggeringChangeEvent(_object_spread({}, helper.state, initialParameters));
instantSearchInstance.scheduleSearch();
}
}
};
};
}
function getInitialParameters(instantSearchInstance) {
var _instantSearchInstance__initialResults_instantSearchInstance_indexName, _instantSearchInstance__initialResults;
// in SSR, the initial state we use in this domain is set on the main index
var stateFromInitialResults = ((_instantSearchInstance__initialResults = instantSearchInstance._initialResults) === null || _instantSearchInstance__initialResults === void 0 ? void 0 : (_instantSearchInstance__initialResults_instantSearchInstance_indexName = _instantSearchInstance__initialResults[instantSearchInstance.indexName]) === null || _instantSearchInstance__initialResults_instantSearchInstance_indexName === void 0 ? void 0 : _instantSearchInstance__initialResults_instantSearchInstance_indexName.state) || {};
var stateFromHelper = instantSearchInstance.mainHelper.state;
return {
userToken: stateFromInitialResults.userToken || stateFromHelper.userToken,
clickAnalytics: stateFromInitialResults.clickAnalytics || stateFromHelper.clickAnalytics
};
}
function saveTokenAsCookie(token, cookieDuration) {
var MONTH = 30 * 24 * 60 * 60 * 1000;
var d = new Date();
d.setTime(d.getTime() + (cookieDuration || MONTH * 6));
var expires = "expires=".concat(d.toUTCString());
document.cookie = "_ALGOLIA=".concat(token, ";").concat(expires, ";path=/");
}
/**
* Determines if a given insights `client` supports the optional call to `init`
* and the ability to set credentials via extra parameters when sending events.
*/ function isModernInsightsClient(client) {
var _split_map = _sliced_to_array((client.version || '').split('.').map(Number), 2), major = _split_map[0], minor = _split_map[1];
/* oxlint-disable instantsearch/naming-convention */ var v3 = major >= 3;
var v2_6 = major === 2 && minor >= 6;
var v1_10 = major === 1 && minor >= 10;
/* oxlint-enable instantsearch/naming-convention */ return v3 || v2_6 || v1_10;
}
/**
* While `search-insights` supports both string and number user tokens,
* the Search API only accepts strings. This function normalizes the user token.
*/ function normalizeUserToken(userToken) {
if (!userToken) {
return undefined;
}
return typeof userToken === 'number' ? userToken.toString() : userToken;
}
function isMetadataEnabled() {
return safelyRunOnBrowser(function(param) {
var window = param.window;
var _window_navigator_userAgent, _window_navigator;
return ((_window_navigator = window.navigator) === null || _window_navigator === void 0 ? void 0 : (_window_navigator_userAgent = _window_navigator.userAgent) === null || _window_navigator_userAgent === void 0 ? void 0 : _window_navigator_userAgent.indexOf('Algolia Crawler')) > -1;
}, {
fallback: function fallback() {
return false;
}
});
}
/**
* Exposes the metadata of mounted widgets in a custom
* `<meta name="instantsearch:widgets" />` tag. The metadata per widget is:
* - applied parameters
* - widget name
* - connector name
*/ function createMetadataMiddleware() {
var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_$$internal = _ref.$$internal, $$internal = _ref_$$internal === void 0 ? false : _ref_$$internal;
return function(param) {
var instantSearchInstance = param.instantSearchInstance;
var payload = {
widgets: []
};
var payloadContainer = document.createElement('meta');
var refNode = document.querySelector('head');
payloadContainer.name = 'instantsearch:widgets';
return {
$$type: 'ais.metadata',
$$internal: $$internal,
onStateChange: function onStateChange() {},
subscribe: function subscribe() {
// using setTimeout here to delay extraction until widgets have been added in a tick (e.g. Vue)
setTimeout(function() {
payload.ua = getAlgoliaAgent(instantSearchInstance.client);
extractWidgetPayload(instantSearchInstance.mainIndex.getWidgets(), instantSearchInstance, payload);
instantSearchInstance.middleware.forEach(function(middleware) {
return payload.widgets.push({
middleware: true,
type: middleware.instance.$$type,
internal: middleware.instance.$$internal
});
});
payloadContainer.content = JSON.stringify(payload);
refNode.appendChild(payloadContainer);
}, 0);
},
started: function started() {},
unsubscribe: function unsubscribe() {
payloadContainer.remove();
}
};
};
}
var formats;
var hasRequiredFormats;
function requireFormats () {
if (hasRequiredFormats) return formats;
hasRequiredFormats = 1;
var replace = String.prototype.replace;
var percentTwenties = /%20/g;
var Format = {
RFC1738: 'RFC1738',
RFC3986: 'RFC3986'
};
formats = {
'default': Format.RFC3986,
formatters: {
RFC1738: function (value) {
return replace.call(value, percentTwenties, '+');
},
RFC3986: function (value) {
return String(value);
}
},
RFC1738: Format.RFC1738,
RFC3986: Format.RFC3986
};
return formats;
}
var utils;
var hasRequiredUtils;
function requireUtils () {
if (hasRequiredUtils) return utils;
hasRequiredUtils = 1;
var formats = requireFormats();
var has = Object.prototype.hasOwnProperty;
var isArray = Array.isArray;
var hexTable = (function () {
var array = [];
for (var i = 0; i < 256; ++i) {
array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
}
return array;
}());
var compactQueue = function compactQueue(queue) {
while (queue.length > 1) {
var item = queue.pop();
var obj = item.obj[item.prop];
if (isArray(obj)) {
var compacted = [];
for (var j = 0; j < obj.length; ++j) {
if (typeof obj[j] !== 'undefined') {
compacted.push(obj[j]);
}
}
item.obj[item.prop] = compacted;
}
}
};
var arrayToObject = function arrayToObject(source, options) {
var obj = options && options.plainObjects ? Object.create(null) : {};
for (var i = 0; i < source.length; ++i) {
if (typeof source[i] !== 'undefined') {
obj[i] = source[i];
}
}
return obj;
};
var merge = function merge(target, source, options) {
/* eslint no-param-reassign: 0 */
if (!source) {
return target;
}
if (typeof source !== 'object') {
if (isArray(target)) {
target.push(source);
} else if (target && typeof target === 'object') {
if ((options && (options.plainObjects || options.allowPrototypes)) || !has.call(Object.prototype, source)) {
target[source] = true;
}
} else {
return [target, source];
}
return target;
}
if (!target || typeof target !== 'object') {
return [target].concat(source);
}
var mergeTarget = target;
if (isArray(target) && !isArray(source)) {
mergeTarget = arrayToObject(target, options);
}
if (isArray(target) && isArray(source)) {
source.forEach(function (item, i) {
if (has.call(target, i)) {
var targetItem = target[i];
if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
target[i] = merge(targetItem, item, options);
} else {
target.push(item);
}
} else {
target[i] = item;
}
});
return target;
}
return Object.keys(source).reduce(function (acc, key) {
var value = source[key];
if (has.call(acc, key)) {
acc[key] = merge(acc[key], value, options);
} else {
acc[key] = value;
}
return acc;
}, mergeTarget);
};
var assign = function assignSingleSource(target, source) {
return Object.keys(source).reduce(function (acc, key) {
acc[key] = source[key];
return acc;
}, target);
};
var decode = function (str, decoder, charset) {
var strWithoutPlus = str.replace(/\+/g, ' ');
if (charset === 'iso-8859-1') {
// unescape never throws, no try...catch needed:
return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
}
// utf-8
try {
return decodeURIComponent(strWithoutPlus);
} catch (e) {
return strWithoutPlus;
}
};
var encode = function encode(str, defaultEncoder, charset, kind, format) {
// This code was originally written by Brian White (mscdex) for the io.js core querystring library.
// It has been adapted here for stricter adherence to RFC 3986
if (str.length === 0) {
return str;
}
var string = str;
if (typeof str === 'symbol') {
string = Symbol.prototype.toString.call(str);
} else if (typeof str !== 'string') {
string = String(str);
}
if (charset === 'iso-8859-1') {
return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
});
}
var out = '';
for (var i = 0; i < string.length; ++i) {
var c = string.charCodeAt(i);
if (
c === 0x2D // -
|| c === 0x2E // .
|| c === 0x5F // _
|| c === 0x7E // ~
|| (c >= 0x30 && c <= 0x39) // 0-9
|| (c >= 0x41 && c <= 0x5A) // a-z
|| (c >= 0x61 && c <= 0x7A) // A-Z
|| (format === formats.RFC1738 && (c === 0x28 || c === 0x29)) // ( )
) {
out += string.charAt(i);
continue;
}
if (c < 0x80) {
out = out + hexTable[c];
continue;
}
if (c < 0x800) {
out = out + (hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)]);
continue;
}
if (c < 0xD800 || c >= 0xE000) {
out = out + (hexTable[0xE0 | (c >> 12)] + hexTable[0x80 | ((c >> 6) & 0x3F)] + hexTable[0x80 | (c & 0x3F)]);
continue;
}
i += 1;
c = 0x10000 + (((c & 0x3FF) << 10) | (string.charCodeAt(i) & 0x3FF));
/* eslint operator-linebreak: [2, "before"] */
out += hexTable[0xF0 | (c >> 18)]
+ hexTable[0x80 | ((c >> 12) & 0x3F)]
+ hexTable[0x80 | ((c >> 6) & 0x3F)]
+ hexTable[0x80 | (c & 0x3F)];
}
return out;
};
var compact = function compact(value) {
var queue = [{ obj: { o: value }, prop: 'o' }];
var refs = [];
for (var i = 0; i < queue.length; ++i) {
var item = queue[i];
var obj = item.obj[item.prop];
var keys = Object.keys(obj);
for (var j = 0; j < keys.length; ++j) {
var key = keys[j];
var val = obj[key];
if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
queue.push({ obj: obj, prop: key });
refs.push(val);
}
}
}
compactQueue(queue);
return value;
};
var isRegExp = function isRegExp(obj) {
return Object.prototype.toString.call(obj) === '[object RegExp]';
};
var isBuffer = function isBuffer(obj) {
if (!obj || typeof obj !== 'object') {
return false;
}
return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
};
var combine = function combine(a, b) {
return [].concat(a, b);
};
var maybeMap = function maybeMap(val, fn) {
if (isArray(val)) {
var mapped = [];
for (var i = 0; i < val.length; i += 1) {
mapped.push(fn(val[i]));
}
return mapped;
}
return fn(val);
};
utils = {
arrayToObject: arrayToObject,
assign: assign,
combine: combine,
compact: compact,
decode: decode,
encode: encode,
isBuffer: isBuffer,
isRegExp: isRegExp,
maybeMap: maybeMap,
merge: merge
};
return utils;
}
var stringify_1;
var hasRequiredStringify;
function requireStringify () {
if (hasRequiredStringify) return stringify_1;
hasRequiredStringify = 1;
var utils = requireUtils();
var formats = requireFormats();
var has = Object.prototype.hasOwnProperty;
var arrayPrefixGenerators = {
brackets: function brackets(prefix) {
return prefix + '[]';
},
comma: 'comma',
indices: function indices(prefix, key) {
return prefix + '[' + key + ']';
},
repeat: function repeat(prefix) {
return prefix;
}
};
var isArray = Array.isArray;
var split = String.prototype.split;
var push = Array.prototype.push;
var pushToArray = function (arr, valueOrArray) {
push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
};
var toISO = Date.prototype.toISOString;
var defaultFormat = formats['default'];
var defaults = {
addQueryPrefix: false,
allowDots: false,
charset: 'utf-8',
charsetSentinel: false,
delimiter: '&',
encode: true,
encoder: utils.encode,
encodeValuesOnly: false,
format: defaultFormat,
formatter: formats.formatters[defaultFormat],
// deprecated
indices: false,
serializeDate: function serializeDate(date) {
return toISO.call(date);
},
skipNulls: false,
strictNullHandling: false
};
var isNonNullishPrimitive = function isNonNullishPrimitive(v) {
return typeof v === 'string'
|| typeof v === 'number'
|| typeof v === 'boolean'
|| typeof v === 'symbol'
|| typeof v === 'bigint';
};
var stringify = function stringify(
object,
prefix,
generateArrayPrefix,
strictNullHandling,
skipNulls,
encoder,
filter,
sort,
allowDots,
serializeDate,
format,
formatter,
encodeValuesOnly,
charset
) {
var obj = object;
if (typeof filter === 'function') {
obj = filter(prefix, obj);
} else if (obj instanceof Date) {
obj = serializeDate(obj);
} else if (generateArrayPrefix === 'comma' && isArray(obj)) {
obj = utils.maybeMap(obj, function (value) {
if (value instanceof Date) {
return serializeDate(value);
}
return value;
});
}
if (obj === null) {
if (strictNullHandling) {
return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, 'key', format) : prefix;
}
obj = '';
}
if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {
if (encoder) {
var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, 'key', format);
if (generateArrayPrefix === 'comma' && encodeValuesOnly) {
var valuesArray = split.call(String(obj), ',');
var valuesJoined = '';
for (var i = 0; i < valuesArray.length; ++i) {
valuesJoined += (i === 0 ? '' : ',') + formatter(encoder(valuesArray[i], defaults.encoder, charset, 'value', format));
}
return [formatter(keyValue) + '=' + valuesJoined];
}
return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value', format))];
}
return [formatter(prefix) + '=' + formatter(String(obj))];
}
var values = [];
if (typeof obj === 'undefined') {
return values;
}
var objKeys;
if (generateArrayPrefix === 'comma' && isArray(obj)) {
// we need to join elements in
objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
} else if (isArray(filter)) {
objKeys = filter;
} else {
var keys = Object.keys(obj);
objKeys = sort ? keys.sort(sort) : keys;
}
for (var j = 0; j < objKeys.length; ++j) {
var key = objKeys[j];
var value = typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key];
if (skipNulls && value === null) {
continue;
}
var keyPrefix = isArray(obj)
? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(prefix, key) : prefix
: prefix + (allowDots ? '.' + key : '[' + key + ']');
pushToArray(values, stringify(
value,
keyPrefix,
generateArrayPrefix,
strictNullHandling,
skipNulls,
encoder,
filter,
sort,
allowDots,
serializeDate,
format,
formatter,
encodeValuesOnly,
charset
));
}
return values;
};
var normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
if (!opts) {
return defaults;
}
if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {
throw new TypeError('Encoder has to be a function.');
}
var charset = opts.charset || defaults.charset;
if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
}
var format = formats['default'];
if (typeof opts.format !== 'undefined') {
if (!has.call(formats.formatters, opts.format)) {
throw new TypeError('Unknown format option provided.');
}
format = opts.format;
}
var formatter = formats.formatters[format];
var filter = defaults.filter;
if (typeof opts.filter === 'function' || isArray(opts.filter)) {
filter = opts.filter;
}
return {
addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,
allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,
charset: charset,
charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,
encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,
encodeValuesOnly: typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
filter: filter,
format: format,
formatter: formatter,
serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,
skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,
sort: typeof opts.sort === 'function' ? opts.sort : null,
strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling
};
};
stringify_1 = function (object, opts) {
var obj = object;
var options = normalizeStringifyOptions(opts);
var objKeys;
var filter;
if (typeof options.filter === 'function') {
filter = options.filter;
obj = filter('', obj);
} else if (isArray(options.filter)) {
filter = options.filter;
objKeys = filter;
}
var keys = [];
if (typeof obj !== 'object' || obj === null) {
return '';
}
var arrayFormat;
if (opts && opts.arrayFormat in arrayPrefixGenerators) {
arrayFormat = opts.arrayFormat;
} else if (opts && 'indices' in opts) {
arrayFormat = opts.indices ? 'indices' : 'repeat';
} else {
arrayFormat = 'indices';
}
var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];
if (!objKeys) {
objKeys = Object.keys(obj);
}
if (options.sort) {
objKeys.sort(options.sort);
}
for (var i = 0; i < objKeys.length; ++i) {
var key = objKeys[i];
if (options.skipNulls && obj[key] === null) {
continue;
}
pushToArray(keys, stringify(
obj[key],
key,
generateArrayPrefix,
options.strictNullHandling,
options.skipNulls,
options.encode ? options.encoder : null,
options.filter,
options.sort,
options.allowDots,
options.serializeDate,
options.format,
options.formatter,
options.encodeValuesOnly,
options.charset
));
}
var joined = keys.join(options.delimiter);
var prefix = options.addQueryPrefix === true ? '?' : '';
if (options.charsetSentinel) {
if (options.charset === 'iso-8859-1') {
// encodeURIComponent('✓'), the "numeric entity" representation of a checkmark
prefix += 'utf8=%26%2310003%3B&';
} else {
// encodeURIComponent('✓')
prefix += 'utf8=%E2%9C%93&';
}
}
return joined.length > 0 ? prefix + joined : '';
};
return stringify_1;
}
var parse;
var hasRequiredParse;
function requireParse () {
if (hasRequiredParse) return parse;
hasRequiredParse = 1;
var utils = requireUtils();
var has = Object.prototype.hasOwnProperty;
var isArray = Array.isArray;
var defaults = {
allowDots: false,
allowPrototypes: false,
arrayLimit: 20,
charset: 'utf-8',
charsetSentinel: false,
comma: false,
decoder: utils.decode,
delimiter: '&',
depth: 5,
ignoreQueryPrefix: false,
interpretNumericEntities: false,
parameterLimit: 1000,
parseArrays: true,
plainObjects: false,
strictNullHandling: false
};
var interpretNumericEntities = function (str) {
return str.replace(/&#(\d+);/g, function ($0, numberStr) {
return String.fromCharCode(parseInt(numberStr, 10));
});
};
var parseArrayValue = function (val, options) {
if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {
return val.split(',');
}
return val;
};
// This is what browsers will submit when the ✓ character occurs in an
// application/x-www-form-urlencoded body and the encoding of the page containing
// the form is iso-8859-1, or when the submitted form has an accept-charset
// attribute of iso-8859-1. Presumably also with other charsets that do not contain
// the ✓ character, such as us-ascii.
var isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('✓')
// These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.
var charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')
var parseValues = function parseQueryStringValues(str, options) {
var obj = {};
var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str;
var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
var parts = cleanStr.split(options.delimiter, limit);
var skipIndex = -1; // Keep track of where the utf8 sentinel was found
var i;
var charset = options.charset;
if (options.charsetSentinel) {
for (i = 0; i < parts.length; ++i) {
if (parts[i].indexOf('utf8=') === 0) {
if (parts[i] === charsetSentinel) {
charset = 'utf-8';
} else if (parts[i] === isoSentinel) {
charset = 'iso-8859-1';
}
skipIndex = i;
i = parts.length; // The eslint settings do not allow break;
}
}
}
for (i = 0; i < parts.length; ++i) {
if (i === skipIndex) {
continue;
}
var part = parts[i];
var bracketEqualsPos = part.indexOf(']=');
var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;
var key, val;
if (pos === -1) {
key = options.decoder(part, defaults.decoder, charset, 'key');
val = options.strictNullHandling ? null : '';
} else {
key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');
val = utils.maybeMap(
parseArrayValue(part.slice(pos + 1), options),
function (encodedVal) {
return options.decoder(encodedVal, defaults.decoder, charset, 'value');
}
);
}
if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
val = interpretNumericEntities(val);
}
if (part.indexOf('[]=') > -1) {
val = isArray(val) ? [val] : val;
}
if (has.call(obj, key)) {
obj[key] = utils.combine(obj[key], val);
} else {
obj[key] = val;
}
}
return obj;
};
var parseObject = function (chain, val, options, valuesParsed) {
var leaf = valuesParsed ? val : parseArrayValue(val, options);
for (var i = chain.length - 1; i >= 0; --i) {
var obj;
var root = chain[i];
if (root === '[]' && options.parseArrays) {
obj = [].concat(leaf);
} else {
obj = options.plainObjects ? Object.create(null) : {};
var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
var index = parseInt(cleanRoot, 10);
if (!options.parseArrays && cleanRoot === '') {
obj = { 0: leaf };
} else if (
!isNaN(index)
&& root !== cleanRoot
&& String(index) === cleanRoot
&& index >= 0
&& (options.parseArrays && index <= options.arrayLimit)
) {
obj = [];
obj[index] = leaf;
} else if (cleanRoot !== '__proto__') {
obj[cleanRoot] = leaf;
}
}
leaf = obj;
}
return leaf;
};
var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
if (!givenKey) {
return;
}
// Transform dot notation to bracket notation
var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;
// The regex chunks
var brackets = /(\[[^[\]]*])/;
var child = /(\[[^[\]]*])/g;
// Get the parent
var segment = options.depth > 0 && brackets.exec(key);
var parent = segment ? key.slice(0, segment.index) : key;
// Stash the parent if it exists
var keys = [];
if (parent) {
// If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties
if (!options.plainObjects && has.call(Object.prototype, parent)) {
if (!options.allowPrototypes) {
return;
}
}
keys.push(parent);
}
// Loop through children appending to the array until we hit depth
var i = 0;
while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {
i += 1;
if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
if (!options.allowPrototypes) {
return;
}
}
keys.push(segment[1]);
}
// If there's a remainder, just add whatever is left
if (segment) {
keys.push('[' + key.slice(segment.index) + ']');
}
return parseObject(keys, val, options, valuesParsed);
};
var normalizeParseOptions = function normalizeParseOptions(opts) {
if (!opts) {
return defaults;
}
if (opts.decoder !== null && opts.decoder !== undefined && typeof opts.decoder !== 'function') {
throw new TypeError('Decoder has to be a function.');
}
if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
}
var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;
return {
allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,
allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,
arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,
charset: charset,
charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,
decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,
delimiter: typeof opts.delimiter === 'string' || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
// eslint-disable-next-line no-implicit-coercion, no-extra-parens
depth: (typeof opts.depth === 'number' || opts.depth === false) ? +opts.depth : defaults.depth,
ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities,
parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,
parseArrays: opts.parseArrays !== false,
plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,
strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling
};
};
parse = function (str, opts) {
var options = normalizeParseOptions(opts);
if (str === '' || str === null || typeof str === 'undefined') {
return options.plainObjects ? Object.create(null) : {};
}
var tempObj = typeof str === 'string' ? parseValues(str, options) : str;
var obj = options.plainObjects ? Object.create(null) : {};
// Iterate over the keys and setup the new object
var keys = Object.keys(tempObj);
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
var newObj = parseKeys(key, tempObj[key], options, typeof str === 'string');
obj = utils.merge(obj, newObj, options);
}
return utils.compact(obj);
};
return parse;
}
var lib;
var hasRequiredLib;
function requireLib () {
if (hasRequiredLib) return lib;
hasRequiredLib = 1;
var stringify = requireStringify();
var parse = requireParse();
var formats = requireFormats();
lib = {
formats: formats,
parse: parse,
stringify: stringify
};
return lib;
}
var libExports = requireLib();
var qs = /*@__PURE__*/getDefaultExportFromCjs(libExports);
var setWindowTitle = function setWindowTitle(title) {
if (title) {
// This function is only executed on browsers so we can disable this check.
// eslint-disable-next-line no-restricted-globals
window.document.title = title;
}
};
var BrowserHistory = /*#__PURE__*/ function() {
function BrowserHistory(param) {
var _this = this;
var windowTitle = param.windowTitle, _param_writeDelay = param.writeDelay, writeDelay = _param_writeDelay === void 0 ? 400 : _param_writeDelay, createURL = param.createURL, parseURL = param.parseURL, getLocation = param.getLocation, start = param.start, dispose = param.dispose, push = param.push, cleanUrlOnDispose = param.cleanUrlOnDispose;
_class_call_check(this, BrowserHistory);
_define_property(this, "$$type", 'ais.browser');
/**
* Transforms a UI state into a title for the page.
*/ _define_property(this, "windowTitle", void 0);
/**
* Time in milliseconds before performing a write in the history.
* It prevents from adding too many entries in the history and
* makes the back button more usable.
*
* @default 400
*/ _define_property(this, "writeDelay", void 0);
/**
* Creates a full URL based on the route state.
* The storage adaptor maps all syncable keys to the query string of the URL.
*/ _define_property(this, "_createURL", void 0);
/**
* Parses the URL into a route state.
* It should be symmetrical to `createURL`.
*/ _define_property(this, "parseURL", void 0);
/**
* Returns the location to store in the history.
* @default () => window.location
*/ _define_property(this, "getLocation", void 0);
_define_property(this, "writeTimer", void 0);
_define_property(this, "_onPopState", void 0);
/**
* Indicates if last action was back/forward in the browser.
*/ _define_property(this, "inPopState", false);
/**
* Indicates whether the history router is disposed or not.
*/ _define_property(this, "isDisposed", false);
/**
* Indicates the window.history.length before the last call to
* window.history.pushState (called in `write`).
* It allows to determine if a `pushState` has been triggered elsewhere,
* and thus to prevent the `write` method from calling `pushState`.
*/ _define_property(this, "latestAcknowledgedHistory", 0);
_define_property(this, "_start", void 0);
_define_property(this, "_dispose", void 0);
_define_property(this, "_push", void 0);
_define_property(this, "_cleanUrlOnDispose", void 0);
this.windowTitle = windowTitle;
this.writeTimer = undefined;
this.writeDelay = writeDelay;
this._createURL = createURL;
this.parseURL = parseURL;
this.getLocation = getLocation;
this._start = start;
this._dispose = dispose;
this._push = push;
this._cleanUrlOnDispose = typeof cleanUrlOnDispose === 'undefined' ? true : cleanUrlOnDispose;
safelyRunOnBrowser(function(param) {
var browserWindow = param.window;
var title = _this.windowTitle && _this.windowTitle(_this.read());
setWindowTitle(title);
_this.latestAcknowledgedHistory = browserWindow.history.length;
});
}
_create_class(BrowserHistory, [
{
key: "read",
value: /**
* Reads the URL and returns a syncable UI search state.
*/ function read() {
return this.parseURL({
qsModule: qs,
location: this.getLocation()
});
}
},
{
key: "write",
value: /**
* Pushes a search state into the URL.
*/ function write(routeState) {
var _this = this;
safelyRunOnBrowser(function(param) {
var browserWindow = param.window;
var url = _this.createURL(routeState);
var title = _this.windowTitle && _this.windowTitle(routeState);
if (_this.writeTimer) {
clearTimeout(_this.writeTimer);
}
_this.writeTimer = setTimeout(function() {
setWindowTitle(title);
if (_this.shouldWrite(url)) {
if (_this._push) {
_this._push(url);
} else {
browserWindow.history.pushState(routeState, title || '', url);
}
_this.latestAcknowledgedHistory = browserWindow.history.length;
}
_this.inPopState = false;
_this.writeTimer = undefined;
}, _this.writeDelay);
});
}
},
{
key: "onUpdate",
value: /**
* Sets a callback on the `onpopstate` event of the history API of the current page.
* It enables the URL sync to keep track of the changes.
*/ function onUpdate(callback) {
var _this = this;
if (this._start) {
this._start(function() {
callback(_this.read());
});
}
this._onPopState = function() {
if (_this.writeTimer) {
clearTimeout(_this.writeTimer);
_this.writeTimer = undefined;
}
_this.inPopState = true;
// We always read the state from the URL because the state of the history
// can be incorect in some cases (e.g. using React Router).
callback(_this.read());
};
safelyRunOnBrowser(function(param) {
var browserWindow = param.window;
browserWindow.addEventListener('popstate', _this._onPopState);
});
}
},
{
key: "createURL",
value: /**
* Creates a complete URL from a given syncable UI state.
*
* It always generates the full URL, not a relative one.
* This allows to handle cases like using a <base href>.
* See: https://github.com/algolia/instantsearch/issues/790
*/ function createURL(routeState) {
var url = this._createURL({
qsModule: qs,
routeState: routeState,
location: this.getLocation()
});
return url;
}
},
{
key: "dispose",
value: /**
* Removes the event listener and cleans up the URL.
*/ function dispose() {
var _this = this;
if (this._dispose) {
this._dispose();
}
this.isDisposed = true;
safelyRunOnBrowser(function(param) {
var browserWindow = param.window;
if (_this._onPopState) {
browserWindow.removeEventListener('popstate', _this._onPopState);
}
});
if (this.writeTimer) {
clearTimeout(this.writeTimer);
}
if (this._cleanUrlOnDispose) {
this.write({});
}
}
},
{
key: "start",
value: function start() {
this.isDisposed = false;
}
},
{
key: "shouldWrite",
value: function shouldWrite(url) {
var _this = this;
return safelyRunOnBrowser(function(param) {
var browserWindow = param.window;
// When disposed and the cleanUrlOnDispose is set to false, we do not want to write the URL.
if (_this.isDisposed && !_this._cleanUrlOnDispose) {
return false;
}
// We do want to `pushState` if:
// - the router is not disposed, IS.js needs to update the URL
// OR
// - the last write was from InstantSearch.js
// (unlike a SPA, where it would have last written)
var lastPushWasByISAfterDispose = !(_this.isDisposed && _this.latestAcknowledgedHistory !== browserWindow.history.length);
return(// but that should not write the URL.
!_this.inPopState && // When the previous pushState after dispose was by IS.js, we want to write the URL.
lastPushWasByISAfterDispose && // When the URL is the same as the current one, we do not want to write it.
url !== browserWindow.location.href);
});
}
}
]);
return BrowserHistory;
}();
function historyRouter() {
var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_createURL = _ref.createURL, createURL = _ref_createURL === void 0 ? function(param) {
var qsModule = param.qsModule, routeState = param.routeState, location = param.location;
var protocol = location.protocol, hostname = location.hostname, _location_port = location.port, port = _location_port === void 0 ? '' : _location_port, pathname = location.pathname, hash = location.hash;
var queryString = qsModule.stringify(routeState);
var portWithPrefix = port === '' ? '' : ":".concat(port);
// IE <= 11 has no proper `location.origin` so we cannot rely on it.
if (!queryString) {
return "".concat(protocol, "//").concat(hostname).concat(portWithPrefix).concat(pathname).concat(hash);
}
return "".concat(protocol, "//").concat(hostname).concat(portWithPrefix).concat(pathname, "?").concat(queryString).concat(hash);
} : _ref_createURL, _ref_parseURL = _ref.parseURL, parseURL = _ref_parseURL === void 0 ? function(param) {
var qsModule = param.qsModule, location = param.location;
// `qs` by default converts arrays with more than 20 items to an object.
// We want to avoid this because the data structure manipulated can therefore vary.
// Setting the limit to `100` seems a good number because the engine's default is 100
// (it can go up to 1000 but it is very unlikely to select more than 100 items in the UI).
//
// Using an `arrayLimit` of `n` allows `n + 1` items.
//
// See:
// - https://github.com/ljharb/qs#parsing-arrays
// - https://www.algolia.com/doc/api-reference/api-parameters/maxValuesPerFacet/
return qsModule.parse(location.search.slice(1), {
arrayLimit: 99
});
} : _ref_parseURL, _ref_writeDelay = _ref.writeDelay, writeDelay = _ref_writeDelay === void 0 ? 400 : _ref_writeDelay, windowTitle = _ref.windowTitle, _ref_getLocation = _ref.getLocation, getLocation = _ref_getLocation === void 0 ? function() {
return safelyRunOnBrowser(function(param) {
var browserWindow = param.window;
return browserWindow.location;
}, {
fallback: function fallback() {
throw new Error('You need to provide `getLocation` to the `history` router in environments where `window` does not exist.');
}
});
} : _ref_getLocation, start = _ref.start, dispose = _ref.dispose, push = _ref.push, cleanUrlOnDispose = _ref.cleanUrlOnDispose;
return new BrowserHistory({
createURL: createURL,
parseURL: parseURL,
writeDelay: writeDelay,
windowTitle: windowTitle,
getLocation: getLocation,
start: start,
dispose: dispose,
push: push,
cleanUrlOnDispose: cleanUrlOnDispose
});
}
function getIndexStateWithoutConfigure(uiState) {
uiState.configure;
var trackedUiState = _object_without_properties(uiState, [
"configure"
]);
return trackedUiState;
}
// technically a URL could contain any key, since users provide it,
// which is why the input to this function is UiState, not something
// which excludes "configure" as this function does.
function simpleStateMapping() {
return {
$$type: 'ais.simple',
stateToRoute: function stateToRoute(uiState) {
return Object.keys(uiState).reduce(function(state, indexId) {
return _object_spread_props(_object_spread({}, state), _define_property({}, indexId, getIndexStateWithoutConfigure(uiState[indexId])));
}, {});
},
routeToState: function routeToState() {
var routeState = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
return Object.keys(routeState).reduce(function(state, indexId) {
var indexState = routeState[indexId];
if ((typeof indexState === "undefined" ? "undefined" : _type_of(indexState)) !== 'object' || indexState === null) {
return state;
}
return _object_spread_props(_object_spread({}, state), _define_property({}, indexId, getIndexStateWithoutConfigure(indexState)));
}, {});
}
};
}
var createRouterMiddleware = function createRouterMiddleware() {
var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var _props_router = props.router, router = _props_router === void 0 ? historyRouter() : _props_router, _props_stateMapping = props.// this is needed because simpleStateMapping is StateMapping<TUiState, TUiState>.
// While it's only used when UiState and RouteState are the same, unfortunately
// TypeScript still considers them separate types.
stateMapping, stateMapping = _props_stateMapping === void 0 ? simpleStateMapping() : _props_stateMapping, _props_$$internal = props.$$internal, $$internal = _props_$$internal === void 0 ? false : _props_$$internal;
return function(param) {
var instantSearchInstance = param.instantSearchInstance;
function topLevelCreateURL(nextState) {
var previousUiState = // index widgets are used. Therefore we fall back to the initialUiState.
// We can't indiscriminately use the initialUiState because then we
// reintroduce state that was changed by the user.
// When there are no widgets, we are sure the user can't yet have made
// any changes.
instantSearchInstance.mainIndex.getWidgets().length === 0 ? instantSearchInstance._initialUiState : instantSearchInstance.mainIndex.getWidgetUiState({});
var uiState = Object.keys(nextState).reduce(function(acc, indexId) {
return _object_spread_props(_object_spread({}, acc), _define_property({}, indexId, nextState[indexId]));
}, previousUiState);
var route = stateMapping.stateToRoute(uiState);
return router.createURL(route);
}
// casting to UiState here to keep createURL unaware of custom UiState
// (as long as it's an object, it's ok)
instantSearchInstance._createURL = topLevelCreateURL;
var lastRouteState = undefined;
var initialUiState = instantSearchInstance._initialUiState;
return {
$$type: "ais.router({router:".concat(router.$$type || '__unknown__', ", stateMapping:").concat(stateMapping.$$type || '__unknown__', "})"),
$$internal: $$internal,
onStateChange: function onStateChange(param) {
var uiState = param.uiState;
var routeState = stateMapping.stateToRoute(uiState);
if (lastRouteState === undefined || !isEqual(lastRouteState, routeState)) {
router.write(routeState);
lastRouteState = routeState;
}
},
subscribe: function subscribe() {
instantSearchInstance._initialUiState = _object_spread({}, initialUiState, stateMapping.routeToState(router.read()));
router.onUpdate(function(route) {
if (instantSearchInstance.mainIndex.getWidgets().length > 0) {
instantSearchInstance.setUiState(stateMapping.routeToState(route));
}
});
},
started: function started() {
var _router_start;
(_router_start = router.start) === null || _router_start === void 0 ? void 0 : _router_start.call(router);
},
unsubscribe: function unsubscribe() {
router.dispose();
}
};
};
};
function formatNumber(value, numberLocale) {
return value.toLocaleString(numberLocale);
}
var NAMESPACE = 'ais';
var component = function component(componentName) {
return function() {
var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, descendantName = _ref.descendantName, modifierName = _ref.modifierName;
var descendent = descendantName ? "-".concat(descendantName) : '';
var modifier = modifierName ? "--".concat(modifierName) : '';
return "".concat(NAMESPACE, "-").concat(componentName).concat(descendent).concat(modifier);
};
};
var suit$3 = component('Highlight');
/**
* @deprecated use html tagged templates and the Highlight component instead
*/ function highlight(param) {
var attribute = param.attribute, _param_highlightedTagName = param.highlightedTagName, highlightedTagName = _param_highlightedTagName === void 0 ? 'mark' : _param_highlightedTagName, hit = param.hit, _param_cssClasses = param.cssClasses, cssClasses = _param_cssClasses === void 0 ? {} : _param_cssClasses;
var highlightAttributeResult = getPropertyByPath(hit._highlightResult, attribute);
var _ref = highlightAttributeResult || {}, tmp = _ref.value, attributeValue = tmp === void 0 ? '' : tmp;
// cx is not used, since it would be bundled as a dependency for Vue
var className = suit$3({
descendantName: 'highlighted'
}) + (cssClasses.highlighted ? " ".concat(cssClasses.highlighted) : '');
return attributeValue.replace(new RegExp(TAG_REPLACEMENT.highlightPreTag, 'g'), "<".concat(highlightedTagName, ' class="').concat(className, '">')).replace(new RegExp(TAG_REPLACEMENT.highlightPostTag, 'g'), "</".concat(highlightedTagName, ">"));
}
var suit$2 = component('ReverseHighlight');
/**
* @deprecated use html tagged templates and the ReverseHighlight component instead
*/ function reverseHighlight(param) {
var attribute = param.attribute, _param_highlightedTagName = param.highlightedTagName, highlightedTagName = _param_highlightedTagName === void 0 ? 'mark' : _param_highlightedTagName, hit = param.hit, _param_cssClasses = param.cssClasses, cssClasses = _param_cssClasses === void 0 ? {} : _param_cssClasses;
var highlightAttributeResult = getPropertyByPath(hit._highlightResult, attribute);
var _ref = highlightAttributeResult || {}, tmp = _ref.value, attributeValue = tmp === void 0 ? '' : tmp;
// cx is not used, since it would be bundled as a dependency for Vue
var className = suit$2({
descendantName: 'highlighted'
}) + (cssClasses.highlighted ? " ".concat(cssClasses.highlighted) : '');
var reverseHighlightedValue = concatHighlightedParts(reverseHighlightedParts(getHighlightedParts(attributeValue)));
return reverseHighlightedValue.replace(new RegExp(TAG_REPLACEMENT.highlightPreTag, 'g'), "<".concat(highlightedTagName, ' class="').concat(className, '">')).replace(new RegExp(TAG_REPLACEMENT.highlightPostTag, 'g'), "</".concat(highlightedTagName, ">"));
}
var suit$1 = component('Snippet');
/**
* @deprecated use html tagged templates and the Snippet component instead
*/ function snippet(param) {
var attribute = param.attribute, _param_highlightedTagName = param.highlightedTagName, highlightedTagName = _param_highlightedTagName === void 0 ? 'mark' : _param_highlightedTagName, hit = param.hit, _param_cssClasses = param.cssClasses, cssClasses = _param_cssClasses === void 0 ? {} : _param_cssClasses;
var snippetAttributeResult = getPropertyByPath(hit._snippetResult, attribute);
var _ref = snippetAttributeResult || {}, tmp = _ref.value, attributeValue = tmp === void 0 ? '' : tmp;
// cx is not used, since it would be bundled as a dependency for Vue
var className = suit$1({
descendantName: 'highlighted'
}) + (cssClasses.highlighted ? " ".concat(cssClasses.highlighted) : '');
return attributeValue.replace(new RegExp(TAG_REPLACEMENT.highlightPreTag, 'g'), "<".concat(highlightedTagName, ' class="').concat(className, '">')).replace(new RegExp(TAG_REPLACEMENT.highlightPostTag, 'g'), "</".concat(highlightedTagName, ">"));
}
var suit = component('ReverseSnippet');
/**
* @deprecated use html tagged templates and the ReverseSnippet component instead
*/ function reverseSnippet(param) {
var attribute = param.attribute, _param_highlightedTagName = param.highlightedTagName, highlightedTagName = _param_highlightedTagName === void 0 ? 'mark' : _param_highlightedTagName, hit = param.hit, _param_cssClasses = param.cssClasses, cssClasses = _param_cssClasses === void 0 ? {} : _param_cssClasses;
var snippetAttributeResult = getPropertyByPath(hit._snippetResult, attribute);
var _ref = snippetAttributeResult || {}, tmp = _ref.value, attributeValue = tmp === void 0 ? '' : tmp;
// cx is not used, since it would be bundled as a dependency for Vue
var className = suit({
descendantName: 'highlighted'
}) + (cssClasses.highlighted ? " ".concat(cssClasses.highlighted) : '');
var reverseHighlightedValue = concatHighlightedParts(reverseHighlightedParts(getHighlightedParts(attributeValue)));
return reverseHighlightedValue.replace(new RegExp(TAG_REPLACEMENT.highlightPreTag, 'g'), "<".concat(highlightedTagName, ' class="').concat(className, '">')).replace(new RegExp(TAG_REPLACEMENT.highlightPostTag, 'g'), "</".concat(highlightedTagName, ">"));
}
function hoganHelpers(param) {
var numberLocale = param.numberLocale;
return {
formatNumber: function formatNumber1(value, render) {
return formatNumber(Number(render(value)), numberLocale);
},
highlight: function highlight1(options, render) {
try {
var highlightOptions = JSON.parse(options);
return render(highlight(_object_spread_props(_object_spread({}, highlightOptions), {
hit: this
})));
} catch (error) {
throw new Error('\nThe highlight helper expects a JSON object of the format:\n{ "attribute": "name", "highlightedTagName": "mark" }');
}
},
reverseHighlight: function reverseHighlight1(options, render) {
try {
var reverseHighlightOptions = JSON.parse(options);
return render(reverseHighlight(_object_spread_props(_object_spread({}, reverseHighlightOptions), {
hit: this
})));
} catch (error) {
throw new Error('\n The reverseHighlight helper expects a JSON object of the format:\n { "attribute": "name", "highlightedTagName": "mark" }');
}
},
snippet: function snippet1(options, render) {
try {
var snippetOptions = JSON.parse(options);
return render(snippet(_object_spread_props(_object_spread({}, snippetOptions), {
hit: this
})));
} catch (error) {
throw new Error('\nThe snippet helper expects a JSON object of the format:\n{ "attribute": "name", "highlightedTagName": "mark" }');
}
},
reverseSnippet: function reverseSnippet1(options, render) {
try {
var reverseSnippetOptions = JSON.parse(options);
return render(reverseSnippet(_object_spread_props(_object_spread({}, reverseSnippetOptions), {
hit: this
})));
} catch (error) {
throw new Error('\n The reverseSnippet helper expects a JSON object of the format:\n { "attribute": "name", "highlightedTagName": "mark" }');
}
},
insights: function insights1(options, render) {
try {
var _JSON_parse = JSON.parse(options), method = _JSON_parse.method, payload = _JSON_parse.payload;
return render(insights(method, _object_spread({
objectIDs: [
this.objectID
]
}, payload)));
} catch (error) {
throw new Error('\nThe insights helper expects a JSON object of the format:\n{ "method": "method-name", "payload": { "eventName": "name of the event" } }');
}
}
};
}
var withUsage$t = createDocumentationMessageGenerator({
name: 'instantsearch'
});
function defaultCreateURL() {
return '#';
}
var INSTANTSEARCH_FUTURE_DEFAULTS = {
preserveSharedStateOnUnmount: false,
persistHierarchicalRootCount: false
};
/**
* The actual implementation of the InstantSearch. This is
* created using the `instantsearch` factory function.
* It emits the 'render' event every time a search is done
*/ var InstantSearch$1 = /*#__PURE__*/ function(EventEmitter) {
_inherits(InstantSearch, EventEmitter);
function InstantSearch(options) {
_class_call_check(this, InstantSearch);
var _this;
_this = _call_super(this, InstantSearch), _define_property(_this, "client", void 0), _define_property(_this, "indexName", void 0), _define_property(_this, "compositionID", void 0), _define_property(_this, "insightsClient", void 0), _define_property(_this, "onStateChange", null), _define_property(_this, "future", void 0), _define_property(_this, "helper", void 0), _define_property(_this, "mainHelper", void 0), _define_property(_this, "mainIndex", void 0), _define_property(_this, "started", void 0), _define_property(_this, "templatesConfig", void 0), _define_property(_this, "renderState", {}), _define_property(_this, "_stalledSearchDelay", void 0), _define_property(_this, "_searchStalledTimer", void 0), _define_property(_this, "_initialUiState", void 0), _define_property(_this, "_initialResults", void 0), _define_property(_this, "_manuallyResetScheduleSearch", false), _define_property(_this, "_resetScheduleSearch", void 0), _define_property(_this, "_createURL", void 0), _define_property(_this, "_searchFunction", void 0), _define_property(_this, "_mainHelperSearch", void 0), _define_property(_this, "_hasSearchWidget", false), _define_property(_this, "_hasRecommendWidget", false), _define_property(_this, "_insights", void 0), /**
* The options the instance was created with, kept verbatim so consumers
* (e.g. usage events) can introspect the configuration without the class
* having to enumerate every option by hand. Typed without the class generics
* on purpose: referencing `TUiState`/`TRouteState` here (they sit in
* contravariant positions inside `InstantSearchOptions`) would break the
* assignability of `InstantSearch<SpecificUiState>` to `InstantSearch`.
*/ _define_property(_this, "_initialOptions", void 0), _define_property(_this, "middleware", []), _define_property(_this, "sendEventToInsights", void 0), _define_property(_this, "_createdAt", now()), /**
* The status of the search. Can be "idle", "loading", "stalled", or "error".
*/ _define_property(_this, "status", 'idle'), /**
* The last returned error from the Search API.
* The error gets cleared when the next valid search response is rendered.
*/ _define_property(_this, "error", undefined), _define_property(_this, "scheduleSearch", defer(function() {
if (_this.started) {
_this.mainHelper.search();
}
})), _define_property(_this, "scheduleRender", defer(function() {
var shouldResetStatus = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
var _this_mainHelper;
if (!((_this_mainHelper = _this.mainHelper) === null || _this_mainHelper === void 0 ? void 0 : _this_mainHelper.hasPendingRequests())) {
clearTimeout(_this._searchStalledTimer);
_this._searchStalledTimer = null;
if (shouldResetStatus) {
_this.status = 'idle';
_this.error = undefined;
}
}
_this.mainIndex.render({
instantSearchInstance: _this
});
_this.emit('render');
}, // status reset accumulates instead of letting the first caller decide: a
// render scheduled for a reason unrelated to the search must not cancel the
// one a search result asks for, or it would strand the status on `loading`.
function(param, param1) {
var _param = _sliced_to_array(param, 1), tmp = _param[0], shouldResetStatus = tmp === void 0 ? true : tmp, _param1 = _sliced_to_array(param1, 1), tmp1 = _param1[0], nextShouldResetStatus = tmp1 === void 0 ? true : tmp1;
return [
shouldResetStatus || nextShouldResetStatus
];
})), _define_property(_this, "onInternalStateChange", defer(function() {
var nextUiState = _this.mainIndex.getWidgetUiState({});
_this.middleware.forEach(function(param) {
var instance = param.instance;
instance.onStateChange({
uiState: nextUiState
});
});
}));
// prevent `render` event listening from causing a warning
_this.setMaxListeners(100);
var _options_indexName = options.indexName, indexName = _options_indexName === void 0 ? '' : _options_indexName, compositionID = options.compositionID, numberLocale = options.numberLocale, _options_initialUiState = options.initialUiState, initialUiState = _options_initialUiState === void 0 ? {} : _options_initialUiState, _options_routing = options.routing, routing = _options_routing === void 0 ? null : _options_routing, _options_insights = options.insights, insights = _options_insights === void 0 ? undefined : _options_insights, searchFunction = options.searchFunction, _options_stalledSearchDelay = options.stalledSearchDelay, stalledSearchDelay = _options_stalledSearchDelay === void 0 ? 200 : _options_stalledSearchDelay, _options_searchClient = options.searchClient, searchClient = _options_searchClient === void 0 ? null : _options_searchClient, _options_insightsClient = options.insightsClient, insightsClient = _options_insightsClient === void 0 ? null : _options_insightsClient, _options_onStateChange = options.onStateChange, onStateChange = _options_onStateChange === void 0 ? null : _options_onStateChange, _options_future1 = options.future, future = _options_future1 === void 0 ? _object_spread({}, INSTANTSEARCH_FUTURE_DEFAULTS, options.future || {}) : _options_future1;
if (searchClient === null) {
throw new Error(withUsage$t('The `searchClient` option is required.'));
}
if (typeof searchClient.search !== 'function') {
throw new Error("The `searchClient` must implement a `search` method.\n\nSee: https://www.algolia.com/doc/guides/building-search-ui/going-further/backend-search/in-depth/backend-instantsearch/js/");
}
if (typeof searchClient.addAlgoliaAgent === 'function') {
searchClient.addAlgoliaAgent("instantsearch.js (".concat(version, ")"));
}
if (insightsClient && typeof insightsClient !== 'function') {
throw new Error(withUsage$t('The `insightsClient` option should be a function.'));
}
_this._initialOptions = options;
_this.client = searchClient;
_this.future = future;
_this.insightsClient = insightsClient;
_this.indexName = indexName;
_this.compositionID = compositionID;
_this.helper = null;
_this.mainHelper = null;
_this.mainIndex = index({
// we use an index widget to render compositions
// this only works because there's only one composition index allow for now
indexName: _this.compositionID || _this.indexName
});
_this.onStateChange = onStateChange;
_this.started = false;
_this.templatesConfig = {
helpers: hoganHelpers({
numberLocale: numberLocale
}),
compileOptions: {}
};
_this._stalledSearchDelay = stalledSearchDelay;
_this._searchStalledTimer = null;
_this._createURL = defaultCreateURL;
_this._initialUiState = initialUiState;
_this._initialResults = null;
_this._insights = insights;
if (searchFunction) {
_this._searchFunction = searchFunction;
}
_this.sendEventToInsights = noop;
if (routing) {
var routerOptions = typeof routing === 'boolean' ? {} : routing;
routerOptions.$$internal = true;
_this.use(createRouterMiddleware(routerOptions));
}
// This is the default Insights middleware,
// added when `insights` is set to true by the user.
// Any user-provided middleware will be added later and override this one.
if (insights) {
var insightsOptions = typeof insights === 'boolean' ? {} : insights;
insightsOptions.$$internal = true;
_this.use(createInsightsMiddleware(insightsOptions));
}
if (isMetadataEnabled()) {
_this.use(createMetadataMiddleware({
$$internal: true
}));
}
return _this;
}
_create_class(InstantSearch, [
{
key: "_isSearchStalled",
get: /**
* @deprecated use `status === 'stalled'` instead
*/ function get() {
return this.status === 'stalled';
}
},
{
key: "use",
value: /**
* Hooks a middleware into the InstantSearch lifecycle.
*/ function use() {
var _this = this;
for(var _len = arguments.length, middleware = new Array(_len), _key = 0; _key < _len; _key++){
middleware[_key] = arguments[_key];
}
var newMiddlewareList = middleware.map(function(fn) {
var newMiddleware = _object_spread({
$$type: '__unknown__',
$$internal: false,
subscribe: noop,
started: noop,
unsubscribe: noop,
onStateChange: noop
}, fn({
instantSearchInstance: _this
}));
_this.middleware.push({
creator: fn,
instance: newMiddleware
});
return newMiddleware;
});
// If the instance has already started, we directly subscribe the
// middleware so they're notified of changes.
if (this.started) {
newMiddlewareList.forEach(function(m) {
m.subscribe();
m.started();
});
}
return this;
}
},
{
key: "unuse",
value: /**
* Removes a middleware from the InstantSearch lifecycle.
*/ function unuse() {
for(var _len = arguments.length, middlewareToUnuse = new Array(_len), _key = 0; _key < _len; _key++){
middlewareToUnuse[_key] = arguments[_key];
}
this.middleware.filter(function(m) {
return middlewareToUnuse.includes(m.creator);
}).forEach(function(m) {
return m.instance.unsubscribe();
});
this.middleware = this.middleware.filter(function(m) {
return !middlewareToUnuse.includes(m.creator);
});
return this;
}
},
{
key: "EXPERIMENTAL_use",
value: function EXPERIMENTAL_use() {
for(var _len = arguments.length, middleware = new Array(_len), _key = 0; _key < _len; _key++){
middleware[_key] = arguments[_key];
}
return this.use.apply(this, _to_consumable_array(middleware));
}
},
{
key: "addWidget",
value: /**
* Adds a widget to the search instance.
* A widget can be added either before or after InstantSearch has started.
* @param widget The widget to add to InstantSearch.
*
* @deprecated This method will still be supported in 4.x releases, but not further. It is replaced by `addWidgets([widget])`.
*/ function addWidget(widget) {
return this.addWidgets([
widget
]);
}
},
{
key: "addWidgets",
value: /**
* Adds multiple widgets to the search instance.
* Widgets can be added either before or after InstantSearch has started.
* @param widgets The array of widgets to add to InstantSearch.
*/ function addWidgets(widgets) {
if (!Array.isArray(widgets)) {
throw new Error(withUsage$t('The `addWidgets` method expects an array of widgets. Please use `addWidget`.'));
}
if (this.compositionID && widgets.some(function(w) {
return !Array.isArray(w) && isIndexWidget(w) && !w._isolated;
})) {
throw new Error(withUsage$t('The `index` widget cannot be used with a composition-based InstantSearch implementation.'));
}
this.mainIndex.addWidgets(widgets);
return this;
}
},
{
key: "removeWidget",
value: /**
* Removes a widget from the search instance.
* @deprecated This method will still be supported in 4.x releases, but not further. It is replaced by `removeWidgets([widget])`
* @param widget The widget instance to remove from InstantSearch.
*
* The widget must implement a `dispose()` method to clear its state.
*/ function removeWidget(widget) {
return this.removeWidgets([
widget
]);
}
},
{
key: "removeWidgets",
value: /**
* Removes multiple widgets from the search instance.
* @param widgets Array of widgets instances to remove from InstantSearch.
*
* The widgets must implement a `dispose()` method to clear their states.
*/ function removeWidgets(widgets) {
if (!Array.isArray(widgets)) {
throw new Error(withUsage$t('The `removeWidgets` method expects an array of widgets. Please use `removeWidget`.'));
}
this.mainIndex.removeWidgets(widgets);
return this;
}
},
{
key: "start",
value: /**
* Ends the initialization of InstantSearch.js and triggers the
* first search.
*/ function start() {
var _this = this;
if (this.started) {
throw new Error(withUsage$t('The `start` method has already been called once.'));
}
// This Helper is used for the queries, we don't care about its state. The
// states are managed at the `index` level. We use this Helper to create
// DerivedHelper scoped into the `index` widgets.
// In Vue InstantSearch' hydrate, a main helper gets set before start, so
// we need to respect this helper as a way to keep all listeners correct.
var mainHelper = this.mainHelper || algoliasearchHelper(this.client, this.indexName, undefined, {
persistHierarchicalRootCount: this.future.persistHierarchicalRootCount
});
if (this.compositionID) {
mainHelper.searchForFacetValues = mainHelper.searchForCompositionFacetValues.bind(mainHelper);
}
mainHelper.search = function() {
var hasSearchOrRecommendWidget = _this._hasSearchWidget || _this._hasRecommendWidget;
if (hasSearchOrRecommendWidget) {
_this.status = 'loading';
}
_this.scheduleRender(!hasSearchOrRecommendWidget);
// This solution allows us to keep the exact same API for the users but
// under the hood, we have a different implementation. It should be
// completely transparent for the rest of the codebase. Only this module
// is impacted.
if (_this._hasSearchWidget) {
if (_this.compositionID) {
mainHelper.searchWithComposition();
} else {
mainHelper.searchOnlyWithDerivedHelpers();
}
}
if (_this._hasRecommendWidget) {
mainHelper.recommend();
}
return mainHelper;
};
if (this._searchFunction) {
// this client isn't used to actually search, but required for the helper
// to not throw errors
var fakeClient = {
search: function search() {
return new Promise(noop);
}
};
this._mainHelperSearch = mainHelper.search.bind(mainHelper);
mainHelper.search = function() {
var mainIndexHelper = _this.mainIndex.getHelper();
var searchFunctionHelper = algoliasearchHelper(fakeClient, mainIndexHelper.state.index, mainIndexHelper.state);
searchFunctionHelper.once('search', function(param) {
var state = param.state;
mainIndexHelper.overrideStateWithoutTriggeringChangeEvent(state);
_this._mainHelperSearch();
});
// Forward state changes from `searchFunctionHelper` to `mainIndexHelper`
searchFunctionHelper.on('change', function(param) {
var state = param.state;
mainIndexHelper.setState(state);
});
_this._searchFunction(searchFunctionHelper);
return mainHelper;
};
}
// Only the "main" Helper emits the `error` event vs the one for `search`
// and `results` that are also emitted on the derived one.
mainHelper.on('error', function(param) {
var error = param.error;
if (!_instanceof(error, Error)) {
// typescript lies here, error is in some cases { name: string, message: string }
var err = error;
error = Object.keys(err).reduce(function(acc, key) {
acc[key] = err[key];
return acc;
}, new Error(err.message));
}
// If an error is emitted, it is re-thrown by events. In previous versions
// we emitted {error}, which is thrown as:
// "Uncaught, unspecified \"error\" event. ([object Object])"
// To avoid breaking changes, we make the error available in both
// `error` and `error.error`
// @MAJOR emit only error
error.error = error;
_this.error = error;
_this.status = 'error';
_this.scheduleRender(!_this._hasSearchWidget && !_this._hasRecommendWidget);
// This needs to execute last because it throws the error.
_this.emit('error', error);
});
this.mainHelper = mainHelper;
this.middleware.forEach(function(param) {
var instance = param.instance;
instance.subscribe();
});
this.mainIndex.init({
instantSearchInstance: this,
parent: null,
uiState: this._initialUiState
});
if (this._initialResults) {
hydrateSearchClient(this.client, this._initialResults);
hydrateRecommendCache(this.mainHelper, this._initialResults);
var originalScheduleSearch = this.scheduleSearch;
// We don't schedule a first search when initial results are provided
// because we already have the results to render. This skips the initial
// network request on the browser on `start`.
this.scheduleSearch = defer(noop);
if (this._manuallyResetScheduleSearch) {
// If `_manuallyResetScheduleSearch` is passed, it means that we don't
// want to rely on a single `defer` to reset the `scheduleSearch`.
// Instead, the consumer will call `_resetScheduleSearch` to restore
// the original `scheduleSearch` function.
// This happens in the React flavour after rendering.
this._resetScheduleSearch = function() {
_this.scheduleSearch = originalScheduleSearch;
};
} else {
// We also skip the initial network request when widgets are dynamically
// added in the first tick (that's the case in all the framework-based flavors).
// When we add a widget to `index`, it calls `scheduleSearch`. We can rely
// on our `defer` util to restore the original `scheduleSearch` value once
// widgets are added to hook back to the regular lifecycle.
defer(function() {
_this.scheduleSearch = originalScheduleSearch;
})();
}
} else if (this.mainIndex.getWidgets().length > 0) {
this.scheduleSearch();
}
// Keep the previous reference for legacy purpose, some pattern use
// the direct Helper access `search.helper` (e.g multi-index).
this.helper = this.mainIndex.getHelper();
// track we started the search if we add more widgets,
// to init them directly after add
this.started = true;
this.middleware.forEach(function(param) {
var instance = param.instance;
instance.started();
});
// This is the automatic Insights middleware,
// added when `insights` is unset and the initial results possess `queryID`.
// Any user-provided middleware will be added later and override this one.
if (typeof this._insights === 'undefined') {
mainHelper.derivedHelpers[0].once('result', function() {
var hasAutomaticInsights = _this.mainIndex.getScopedResults().some(function(param) {
var results = param.results;
return results === null || results === void 0 ? void 0 : results._automaticInsights;
});
if (hasAutomaticInsights) {
_this.use(createInsightsMiddleware({
$$internal: true,
$$automatic: true
}));
}
});
}
}
},
{
key: "dispose",
value: /**
* Removes all widgets without triggering a search afterwards.
* @return {undefined} This method does not return anything
*/ function dispose() {
var _this_mainHelper;
this.scheduleSearch.cancel();
this.scheduleRender.cancel();
clearTimeout(this._searchStalledTimer);
this.removeWidgets(this.mainIndex.getWidgets());
this.mainIndex.dispose();
// You can not start an instance two times, therefore a disposed instance
// needs to set started as false otherwise this can not be restarted at a
// later point.
this.started = false;
// The helper needs to be reset to perform the next search from a fresh state.
// If not reset, it would use the state stored before calling `dispose()`.
this.removeAllListeners();
(_this_mainHelper = this.mainHelper) === null || _this_mainHelper === void 0 ? void 0 : _this_mainHelper.removeAllListeners();
this.mainHelper = null;
this.helper = null;
this.middleware.forEach(function(param) {
var instance = param.instance;
instance.unsubscribe();
});
// Cleared after unsubscribe so in-flight readers (e.g. the insights
// start-event listener) have detached before the reference goes away.
this._initialOptions = null;
}
},
{
key: "scheduleStalledRender",
value: function scheduleStalledRender() {
var _this = this;
if (!this._searchStalledTimer) {
this._searchStalledTimer = setTimeout(function() {
_this.status = 'stalled';
_this.scheduleRender();
}, this._stalledSearchDelay);
}
}
},
{
key: "setUiState",
value: /**
* Set the UI state and trigger a search.
* @param uiState The next UI state or a function computing it from the current state
* @param callOnStateChange private parameter used to know if the method is called from a state change
*/ function setUiState(uiState) {
var _this = this;
var callOnStateChange = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
if (!this.mainHelper) {
throw new Error(withUsage$t('The `start` method needs to be called before `setUiState`.'));
}
// We refresh the index UI state to update the local UI state that the
// main index passes to the function form of `setUiState`.
this.mainIndex.refreshUiState();
var nextUiState = typeof uiState === 'function' ? uiState(this.mainIndex.getWidgetUiState({})) : uiState;
if (this.onStateChange && callOnStateChange) {
this.onStateChange({
uiState: nextUiState,
setUiState: function setUiState(finalUiState) {
setIndexHelperState(typeof finalUiState === 'function' ? finalUiState(nextUiState) : finalUiState, _this.mainIndex);
_this.scheduleSearch();
_this.onInternalStateChange();
}
});
} else {
setIndexHelperState(nextUiState, this.mainIndex);
this.scheduleSearch();
this.onInternalStateChange();
}
}
},
{
key: "getUiState",
value: function getUiState() {
if (this.started) {
// We refresh the index UI state to make sure changes from `refine` are taken in account
this.mainIndex.refreshUiState();
}
return this.mainIndex.getWidgetUiState({});
}
},
{
key: "createURL",
value: function createURL() {
var nextState = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
if (!this.started) {
throw new Error(withUsage$t('The `start` method needs to be called before `createURL`.'));
}
return this._createURL(nextState);
}
},
{
key: "refresh",
value: function refresh() {
if (!this.mainHelper) {
throw new Error(withUsage$t('The `start` method needs to be called before `refresh`.'));
}
this.mainHelper.clearCache().search();
}
}
]);
return InstantSearch;
}(EventEmitter);
var shim = {exports: {}};
var useSyncExternalStoreShim_development = {};
/**
* @license React
* use-sync-external-store-shim.development.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
var hasRequiredUseSyncExternalStoreShim_development;
function requireUseSyncExternalStoreShim_development () {
if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
hasRequiredUseSyncExternalStoreShim_development = 1;
{
(function() {
/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
if (
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
'function'
) {
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
}
var React$1 = React;
var ReactSharedInternals = React$1.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
function error(format) {
{
{
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
printWarning('error', format, args);
}
}
}
function printWarning(level, format, args) {
// When changing this logic, you might want to also
// update consoleWithStackDev.www.js as well.
{
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
var stack = ReactDebugCurrentFrame.getStackAddendum();
if (stack !== '') {
format += '%s';
args = args.concat([stack]);
} // eslint-disable-next-line react-internal/safe-string-coercion
var argsWithFormat = args.map(function (item) {
return String(item);
}); // Careful: RN currently depends on this prefix
argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
// breaks IE9: https://github.com/facebook/react/issues/13610
// eslint-disable-next-line react-internal/no-production-logging
Function.prototype.apply.call(console[level], console, argsWithFormat);
}
}
/**
* inlined Object.is polyfill to avoid requiring consumers ship their own
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
*/
function is(x, y) {
return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
;
}
var objectIs = typeof Object.is === 'function' ? Object.is : is;
// dispatch for CommonJS interop named imports.
var useState = React$1.useState,
useEffect = React$1.useEffect,
useLayoutEffect = React$1.useLayoutEffect,
useDebugValue = React$1.useDebugValue;
var didWarnOld18Alpha = false;
var didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works
// because of a very particular set of implementation details and assumptions
// -- change any one of them and it will break. The most important assumption
// is that updates are always synchronous, because concurrent rendering is
// only available in versions of React that also have a built-in
// useSyncExternalStore API. And we only use this shim when the built-in API
// does not exist.
//
// Do not assume that the clever hacks used by this hook also work in general.
// The point of this shim is to replace the need for hacks by other libraries.
function useSyncExternalStore(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of
// React do not expose a way to check if we're hydrating. So users of the shim
// will need to track that themselves and return the correct value
// from `getSnapshot`.
getServerSnapshot) {
{
if (!didWarnOld18Alpha) {
if (React$1.startTransition !== undefined) {
didWarnOld18Alpha = true;
error('You are using an outdated, pre-release alpha of React 18 that ' + 'does not support useSyncExternalStore. The ' + 'use-sync-external-store shim will not work correctly. Upgrade ' + 'to a newer pre-release.');
}
}
} // Read the current snapshot from the store on every render. Again, this
// breaks the rules of React, and only works here because of specific
// implementation details, most importantly that updates are
// always synchronous.
var value = getSnapshot();
{
if (!didWarnUncachedGetSnapshot) {
var cachedValue = getSnapshot();
if (!objectIs(value, cachedValue)) {
error('The result of getSnapshot should be cached to avoid an infinite loop');
didWarnUncachedGetSnapshot = true;
}
}
} // Because updates are synchronous, we don't queue them. Instead we force a
// re-render whenever the subscribed state changes by updating an some
// arbitrary useState hook. Then, during render, we call getSnapshot to read
// the current value.
//
// Because we don't actually use the state returned by the useState hook, we
// can save a bit of memory by storing other stuff in that slot.
//
// To implement the early bailout, we need to track some things on a mutable
// object. Usually, we would put that in a useRef hook, but we can stash it in
// our useState hook instead.
//
// To force a re-render, we call forceUpdate({inst}). That works because the
// new object always fails an equality check.
var _useState = useState({
inst: {
value: value,
getSnapshot: getSnapshot
}
}),
inst = _useState[0].inst,
forceUpdate = _useState[1]; // Track the latest getSnapshot function with a ref. This needs to be updated
// in the layout phase so we can access it during the tearing check that
// happens on subscribe.
useLayoutEffect(function () {
inst.value = value;
inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the
// commit phase if there was an interleaved mutation. In concurrent mode
// this can happen all the time, but even in synchronous mode, an earlier
// effect may have mutated the store.
if (checkIfSnapshotChanged(inst)) {
// Force a re-render.
forceUpdate({
inst: inst
});
}
}, [subscribe, value, getSnapshot]);
useEffect(function () {
// Check for changes right before subscribing. Subsequent changes will be
// detected in the subscription handler.
if (checkIfSnapshotChanged(inst)) {
// Force a re-render.
forceUpdate({
inst: inst
});
}
var handleStoreChange = function () {
// TODO: Because there is no cross-renderer API for batching updates, it's
// up to the consumer of this library to wrap their subscription event
// with unstable_batchedUpdates. Should we try to detect when this isn't
// the case and print a warning in development?
// The store changed. Check if the snapshot changed since the last time we
// read from the store.
if (checkIfSnapshotChanged(inst)) {
// Force a re-render.
forceUpdate({
inst: inst
});
}
}; // Subscribe to the store and return a clean-up function.
return subscribe(handleStoreChange);
}, [subscribe]);
useDebugValue(value);
return value;
}
function checkIfSnapshotChanged(inst) {
var latestGetSnapshot = inst.getSnapshot;
var prevValue = inst.value;
try {
var nextValue = latestGetSnapshot();
return !objectIs(prevValue, nextValue);
} catch (error) {
return true;
}
}
function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
// Note: The shim does not use getServerSnapshot, because pre-18 versions of
// React do not expose a way to check if we're hydrating. So users of the shim
// will need to track that themselves and return the correct value
// from `getSnapshot`.
return getSnapshot();
}
var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
var isServerEnvironment = !canUseDOM;
var shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
var useSyncExternalStore$2 = React$1.useSyncExternalStore !== undefined ? React$1.useSyncExternalStore : shim;
useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
if (
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
'function'
) {
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
}
})();
}
return useSyncExternalStoreShim_development;
}
var hasRequiredShim;
function requireShim () {
if (hasRequiredShim) return shim.exports;
hasRequiredShim = 1;
{
shim.exports = requireUseSyncExternalStoreShim_development();
}
return shim.exports;
}
var shimExports = requireShim();
var defaultUserAgents = [
"react (".concat(React.version, ")"),
"react-instantsearch (".concat(version$2, ")"),
"react-instantsearch-core (".concat(version$2, ")")
];
var serverUserAgent = "react-instantsearch-server (".concat(version$2, ")");
var nextUserAgent = function nextUserAgent(nextVersion) {
return nextVersion ? "next.js (".concat(nextVersion, ")") : null;
};
function useInstantSearchApi(props) {
var forceUpdate = useForceUpdate();
var serverContext = useInstantSearchServerContext();
var serverState = useInstantSearchSSRContext();
var waitForResultsRef = useRSCContext().waitForResultsRef;
var initialResults = serverState === null || serverState === void 0 ? void 0 : serverState.initialResults;
var prevPropsRef = React.useRef(props);
var shouldRenderAtOnce = serverContext || initialResults || waitForResultsRef;
var searchRef = React.useRef(null);
// As we need to render on mount with SSR, using the local ref above in `StrictMode` will
// create and start two instances of InstantSearch. To avoid this, we instead discard it and use
// an upward ref from `InstantSearchSSRContext` as it has already been mounted a second time at this point.
if (serverState === null || serverState === void 0 ? void 0 : serverState.ssrSearchRef) {
searchRef = serverState.ssrSearchRef;
}
if (searchRef.current === null) {
// We don't use the `instantsearch()` function because it comes with other
// top-level APIs that we don't need.
// See https://github.com/algolia/instantsearch/blob/5b529f43d8acc680f85837eaaa41f7fd03a3f833/src/index.es.ts#L63-L86
var search = new InstantSearch$1(props);
search._schedule = function _schedule(cb) {
search._schedule.queue.push(cb);
clearTimeout(search._schedule.timer);
search._schedule.timer = setTimeout(function() {
search._schedule.queue.forEach(function(callback) {
callback();
});
search._schedule.queue = [];
}, 0);
};
search._schedule.queue = [];
if (shouldRenderAtOnce) {
// InstantSearch.js has a private Initial Results API that lets us inject
// results on the search instance.
// On the server, we default the initial results to an empty object so that
// InstantSearch.js doesn't schedule a search that isn't used, leading to
// an additional network request. (This is equivalent to monkey-patching
// `scheduleSearch` to a noop.)
search._initialResults = initialResults || {};
// We don't rely on the `defer` to reset the schedule search, but will call
// `search._resetScheduleSearch()` manually in the effect after children
// mount in `InstantSearch`.
search._manuallyResetScheduleSearch = true;
}
addAlgoliaAgents(props.searchClient, _to_consumable_array(defaultUserAgents).concat([
serverContext && serverUserAgent,
nextUserAgent(getNextVersion())
]));
// On the server, we start the search early to compute the search parameters.
// On SSR, we start the search early to directly catch up with the lifecycle
// and render.
if (shouldRenderAtOnce) {
search.start();
}
if (serverContext) {
// We notify `getServerState()` of the InstantSearch internals to retrieve
// the server state and pass it to the render on SSR.
serverContext.notifyServer({
search: search
});
}
warnNextRouter(props.routing);
searchRef.current = search;
}
{
var search1 = searchRef.current;
var prevProps = prevPropsRef.current;
if (prevProps.indexName !== props.indexName) {
search1.helper.setIndex(props.indexName || '').search();
prevPropsRef.current = props;
}
if (prevProps.searchClient !== props.searchClient) {
addAlgoliaAgents(props.searchClient, _to_consumable_array(defaultUserAgents).concat([
serverContext && serverUserAgent
]));
search1.mainHelper.setClient(props.searchClient).search();
prevPropsRef.current = props;
}
if (prevProps.onStateChange !== props.onStateChange) {
search1.onStateChange = props.onStateChange;
prevPropsRef.current = props;
}
if (prevProps.searchFunction !== props.searchFunction) {
// Updating the `searchFunction` to `undefined` is not supported by
// InstantSearch.js, so it will throw an error.
// This is a fair behavior until we add an update API in InstantSearch.js.
search1._searchFunction = props.searchFunction;
prevPropsRef.current = props;
}
if (prevProps.stalledSearchDelay !== props.stalledSearchDelay) {
var _props_stalledSearchDelay;
// The default `stalledSearchDelay` in InstantSearch.js is 200ms.
// We need to reset it when it's undefined to get back to the original value.
search1._stalledSearchDelay = (_props_stalledSearchDelay = props.stalledSearchDelay) !== null && _props_stalledSearchDelay !== void 0 ? _props_stalledSearchDelay : 200;
prevPropsRef.current = props;
}
if (!dequal(prevProps.future, props.future)) {
search1.future = _object_spread({}, INSTANTSEARCH_FUTURE_DEFAULTS, props.future);
prevPropsRef.current = props;
}
// Updating the `routing` prop is not supported because InstantSearch.js
// doesn't let us change it. This might not be a problem though, because `routing`
// shouldn't need to be dynamic.
// If we find scenarios where `routing` needs to change, we can always expose
// it privately on the InstantSearch instance. Another way would be to
// manually inject the routing middleware in this library, and not rely
// on the provided `routing` prop.
}
var cleanupTimerRef = React.useRef(null);
var store = shimExports.useSyncExternalStore(React.useCallback(function() {
var search = searchRef.current;
// Scenario 1: the component mounts.
if (cleanupTimerRef.current === null) {
// On SSR, the instance is already started so we don't start it again.
if (!search.started) {
search.start();
forceUpdate();
}
} else {
// We cancel the previous cleanup function because we don't want to
// dispose the search during an update.
clearTimeout(cleanupTimerRef.current);
search._preventWidgetCleanup = false;
}
return function() {
if (serverState === null || serverState === void 0 ? void 0 : serverState.ssrSearchRef) {
return;
}
function cleanup() {
search.dispose();
}
clearTimeout(search._schedule.timer);
// We clean up only when the component that uses this subscription unmounts,
// but not when it updates, because it would dispose the instance, which
// would remove all the widgets and break routing.
// Executing the cleanup function in a `setTimeout()` lets us cancel it
// in the next effect.
// (There might be better ways to do this.)
cleanupTimerRef.current = setTimeout(cleanup);
// We need to prevent the `useWidget` cleanup function so that widgets
// are not removed before the instance is disposed, triggering
// an unwanted search request.
search._preventWidgetCleanup = true;
};
}, [
forceUpdate,
serverState
]), function() {
return searchRef.current;
}, function() {
return searchRef.current;
});
return store;
}
function addAlgoliaAgents(searchClient, userAgents) {
if (typeof searchClient.addAlgoliaAgent !== 'function') {
return;
}
userAgents.filter(Boolean).forEach(function(userAgent) {
searchClient.addAlgoliaAgent(userAgent);
});
}
function warnNextRouter(routing) {}
/**
* Gets the version of Next.js if it is available in the `window` object,
* otherwise it returns the NEXT_RUNTIME environment variable (in SSR),
* which is either `nodejs` or `edge`.
*/ function getNextVersion() {
var _window_next, _process_env;
return typeof window !== 'undefined' && ((_window_next = window.next) === null || _window_next === void 0 ? void 0 : _window_next.version) || (typeof process !== 'undefined' ? (_process_env = process.env) === null || _process_env === void 0 ? void 0 : _process_env.NEXT_RUNTIME : undefined);
}
function InstantSearch(_0) {
var children = _0.children, props = _object_without_properties(_0, [
"children"
]);
var search = useInstantSearchApi(props);
if (!search.started) {
return null;
}
return /*#__PURE__*/ React.createElement(InstantSearchContext.Provider, {
value: search
}, /*#__PURE__*/ React.createElement(IndexContext.Provider, {
value: search.mainIndex
}, children, /*#__PURE__*/ React.createElement(ResetScheduleSearch, {
search: search
})));
}
function ResetScheduleSearch(param) {
var search = param.search;
React.useEffect(function() {
if (search._resetScheduleSearch) {
search._resetScheduleSearch();
}
}, [
search
]);
return null;
}
/**
* Provider to pass the server state retrieved from `getServerState()` to
* <InstantSearch>.
*/ function InstantSearchSSRProvider(_0) {
var children = _0.children, props = _object_without_properties(_0, [
"children"
]);
// This is used in `useInstantSearchApi()` to avoid creating and starting multiple instances of
// `InstantSearch` on mount.
var ssrSearchRef = React.useRef(null);
// This is used to re-map the result index to the requesting widget
var recommendIdx = React.useRef(0);
var hydrationCompleteRef = React.useRef(false);
React.useEffect(function() {
hydrationCompleteRef.current = true;
}, []);
// When <DynamicWidgets> is mounted, a second provider is used above the user-land
// <InstantSearchSSRProvider> in `getServerState()`.
// To avoid the user's provider overriding the context value with an empty object,
// we skip this provider.
if (Object.keys(props).length === 0) {
return /*#__PURE__*/ React.createElement(React.Fragment, null, children);
}
var contextValue = _object_spread_props(_object_spread({}, props), {
ssrSearchRef: ssrSearchRef,
recommendIdx: recommendIdx,
hydrationCompleteRef: hydrationCompleteRef
});
return /*#__PURE__*/ React.createElement(InstantSearchSSRContext.Provider, {
value: contextValue
}, children);
}
var withUsage$s = createDocumentationMessageGenerator({
name: 'autocomplete',
connector: true
});
var connectAutocomplete = function connectAutocomplete(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$s());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_escapeHTML = _ref.escapeHTML, escapeHTML = _ref_escapeHTML === void 0 ? true : _ref_escapeHTML, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(indices) {
return indices;
} : _ref_transformItems, _ref_requiresSearch = _ref.requiresSearch, requiresSearch = _ref_requiresSearch === void 0 ? true : _ref_requiresSearch, tmp = _ref.future, _ref1 = tmp === void 0 ? {} : tmp, _ref_undefinedEmptyQuery = _ref1.undefinedEmptyQuery, undefinedEmptyQuery = _ref_undefinedEmptyQuery === void 0 ? false : _ref_undefinedEmptyQuery;
var connectorState = {};
return {
$$type: 'ais.autocomplete',
dependsOn: requiresSearch ? 'search' : 'none',
shouldRender: requiresSearch ? undefined : function() {
return true;
},
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
var renderState = this.getWidgetRenderState(renderOptions);
renderState.indices.forEach(function(param) {
var sendEvent = param.sendEvent, hits = param.hits;
sendEvent('view:internal', hits);
});
renderFn(_object_spread_props(_object_spread({}, renderState), {
instantSearchInstance: instantSearchInstance
}), false);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
autocomplete: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var _this = this;
var helper = param.helper, state = param.state, scopedResults = param.scopedResults, instantSearchInstance = param.instantSearchInstance;
if (!connectorState.refine) {
connectorState.refine = function(query) {
helper.setQuery(query).search();
};
}
var sendEventMap = {};
var indices = scopedResults.map(function(scopedResult) {
var _scopedResult_results;
// We need to escape the hits because highlighting
// exposes HTML tags to the end-user.
if (scopedResult.results) {
scopedResult.results.hits = escapeHTML ? escapeHits(scopedResult.results.hits) : scopedResult.results.hits;
}
sendEventMap[scopedResult.indexId] = createSendEventForHits({
instantSearchInstance: instantSearchInstance,
helper: scopedResult.helper,
widgetType: _this.$$type
});
var hits = scopedResult.results ? addQueryID$1(addAbsolutePosition$1(scopedResult.results.hits, scopedResult.results.page, scopedResult.results.hitsPerPage), scopedResult.results.queryID) : [];
return {
indexId: scopedResult.indexId,
indexName: ((_scopedResult_results = scopedResult.results) === null || _scopedResult_results === void 0 ? void 0 : _scopedResult_results.index) || '',
hits: hits,
results: scopedResult.results || {}
};
});
return {
currentRefinement: undefinedEmptyQuery ? state.query : state.query || '',
indices: transformItems(indices).map(function(transformedIndex) {
return _object_spread_props(_object_spread({}, transformedIndex), {
sendEvent: sendEventMap[transformedIndex.indexId]
});
}),
refine: connectorState.refine,
widgetParams: widgetParams
};
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var query = undefinedEmptyQuery ? searchParameters.query : searchParameters.query || '';
if (!query || query === '' || uiState && uiState.query === query) {
return uiState;
}
return _object_spread_props(_object_spread({}, uiState), {
query: query
});
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
var parameters = {
query: undefinedEmptyQuery ? uiState.query : uiState.query || ''
};
if (!escapeHTML) {
return searchParameters.setQueryParameters(parameters);
}
return searchParameters.setQueryParameters(_object_spread({}, parameters, TAG_PLACEHOLDER));
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
var stateWithoutQuery = state.setQueryParameter('query', undefined);
if (!escapeHTML) {
return stateWithoutQuery;
}
return stateWithoutQuery.setQueryParameters(Object.keys(TAG_PLACEHOLDER).reduce(function(acc, key) {
return _object_spread_props(_object_spread({}, acc), _define_property({}, key, undefined));
}, {}));
}
};
};
};
function useAutocomplete(props, additionalWidgetProperties) {
return useConnector(connectAutocomplete, props, additionalWidgetProperties);
}
var withUsage$r = createDocumentationMessageGenerator({
name: 'breadcrumb',
connector: true
});
var connectBreadcrumb = function connectBreadcrumb(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$r());
var connectorState = {};
return function(widgetParams) {
var _ref = widgetParams || {}, attributes = _ref.attributes, _ref_separator = _ref.separator, separator = _ref_separator === void 0 ? ' > ' : _ref_separator, _ref_rootPath = _ref.rootPath, rootPath = _ref_rootPath === void 0 ? null : _ref_rootPath, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
if (!attributes || !Array.isArray(attributes) || attributes.length === 0) {
throw new Error(withUsage$r('The `attributes` option expects an array of strings.'));
}
var _attributes = _sliced_to_array(attributes, 1), hierarchicalFacetName = _attributes[0];
function getRefinedState(state, facetValue) {
if (!facetValue) {
var breadcrumb = state.getHierarchicalFacetBreadcrumb(hierarchicalFacetName);
if (breadcrumb.length === 0) {
return state;
} else {
return state.resetPage().toggleFacetRefinement(hierarchicalFacetName, breadcrumb[0]);
}
}
return state.resetPage().toggleFacetRefinement(hierarchicalFacetName, facetValue);
}
return {
$$type: 'ais.breadcrumb',
init: function init(initOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
dispose: function dispose() {
unmountFn();
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
breadcrumb: _object_spread_props(_object_spread({}, renderState.breadcrumb), _define_property({}, hierarchicalFacetName, this.getWidgetRenderState(renderOptions)))
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var _this = this;
var helper = param.helper, createURL = param.createURL, results = param.results, state = param.state;
function getItems() {
// The hierarchicalFacets condition is required for flavors
// that render immediately with empty results, without relying
// on init() (like React InstantSearch).
if (!results || state.hierarchicalFacets.length === 0) {
return [];
}
var facetValues = results.getFacetValues(hierarchicalFacetName, {});
var facetItems = facetValues && !Array.isArray(facetValues) && facetValues.data ? facetValues.data : [];
var items = transformItems(shiftItemsValues(prepareItems(facetItems)), {
results: results
});
return items;
}
var items = getItems();
if (!connectorState.createURL) {
connectorState.createURL = function(facetValue) {
return createURL(function(uiState) {
return _this.getWidgetUiState(uiState, {
searchParameters: getRefinedState(helper.state, facetValue),
helper: helper
});
});
};
}
if (!connectorState.refine) {
connectorState.refine = function(facetValue) {
helper.setState(getRefinedState(helper.state, facetValue)).search();
};
}
return {
canRefine: items.length > 0,
createURL: connectorState.createURL,
items: items,
refine: connectorState.refine,
widgetParams: widgetParams
};
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var path = searchParameters.getHierarchicalFacetBreadcrumb(hierarchicalFacetName);
return removeEmptyRefinementsFromUiState$4(_object_spread_props(_object_spread({}, uiState), {
hierarchicalMenu: _object_spread_props(_object_spread({}, uiState.hierarchicalMenu), _define_property({}, hierarchicalFacetName, path))
}), hierarchicalFacetName);
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
var values = uiState.hierarchicalMenu && uiState.hierarchicalMenu[hierarchicalFacetName];
if (searchParameters.isConjunctiveFacet(hierarchicalFacetName) || searchParameters.isDisjunctiveFacet(hierarchicalFacetName)) {
return searchParameters;
}
if (searchParameters.isHierarchicalFacet(hierarchicalFacetName)) {
searchParameters.getHierarchicalFacetByName(hierarchicalFacetName);
}
var withFacetConfiguration = searchParameters.removeHierarchicalFacet(hierarchicalFacetName).addHierarchicalFacet({
name: hierarchicalFacetName,
attributes: attributes,
separator: separator,
rootPath: rootPath
});
if (!values) {
return withFacetConfiguration.setQueryParameters({
hierarchicalFacetsRefinements: _object_spread_props(_object_spread({}, withFacetConfiguration.hierarchicalFacetsRefinements), _define_property({}, hierarchicalFacetName, []))
});
}
return withFacetConfiguration.addHierarchicalFacetRefinement(hierarchicalFacetName, values.join(separator));
}
};
};
};
function prepareItems(data) {
return data.reduce(function(result, currentItem) {
if (currentItem.isRefined) {
result.push({
label: currentItem.name,
value: currentItem.escapedValue
});
if (Array.isArray(currentItem.data)) {
result = result.concat(prepareItems(currentItem.data));
}
}
return result;
}, []);
}
function shiftItemsValues(array) {
return array.map(function(x, idx) {
return {
label: x.label,
value: idx + 1 === array.length ? null : array[idx + 1].value
};
});
}
function removeEmptyRefinementsFromUiState$4(indexUiState, attribute) {
if (!indexUiState.hierarchicalMenu) {
return indexUiState;
}
if (!indexUiState.hierarchicalMenu[attribute] || !indexUiState.hierarchicalMenu[attribute].length) {
delete indexUiState.hierarchicalMenu[attribute];
}
if (Object.keys(indexUiState.hierarchicalMenu).length === 0) {
delete indexUiState.hierarchicalMenu;
}
return indexUiState;
}
function useBreadcrumb(props, additionalWidgetProperties) {
return useConnector(connectBreadcrumb, props, additionalWidgetProperties);
}
function cx() {
for(var _len = arguments.length, classNames = new Array(_len), _key = 0; _key < _len; _key++){
classNames[_key] = arguments[_key];
}
return classNames.reduce(function(acc, className) {
if (Array.isArray(className)) {
return acc.concat(className);
}
return acc.concat([
className
]);
}, []).filter(Boolean).join(' ');
}
function createAutocompleteComponent(param) {
var createElement = param.createElement;
return function Autocomplete(userProps) {
var children = userProps.children, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, rootRef = userProps.rootRef, props = _object_without_properties(userProps, [
"children",
"classNames",
"rootRef"
]);
return /*#__PURE__*/ createElement("div", _object_spread({
className: cx('ais-Autocomplete', classNames.root),
ref: rootRef
}, props), children);
};
}
function createAutocompleteDetachedContainerComponent(param) {
var createElement = param.createElement;
return function AutocompleteDetachedContainer(userProps) {
var children = userProps.children, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
return /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteDetachedContainer', classNames.detachedContainer),
onMouseDown: function onMouseDown(event) {
event.stopPropagation();
}
}, children);
};
}
function createAutocompleteDetachedFormContainerComponent(param) {
var createElement = param.createElement;
return function AutocompleteDetachedFormContainer(userProps) {
var children = userProps.children, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
return /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteDetachedFormContainer', classNames.detachedFormContainer)
}, children);
};
}
function createAutocompleteDetachedOverlayComponent(param) {
var createElement = param.createElement;
return function AutocompleteDetachedOverlay(userProps) {
var children = userProps.children, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, onClose = userProps.onClose;
return /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteDetachedOverlay', classNames.detachedOverlay),
onMouseDown: onClose
}, children);
};
}
// WebKit can keep this SVG spinner animating while the loading slot is hidden (`hidden` / not stalled),
// which wastes work. We pause SMIL when idle and unpause when `isSearchStalled`.
// Same approach as autocomplete-js.
// https://github.com/algolia/autocomplete/issues/1322
function syncLoadingSvgAnimation(element, isSearchStalled) {
if (!element || typeof element.pauseAnimations !== 'function' || typeof element.unpauseAnimations !== 'function') {
return;
}
if (isSearchStalled) {
element.unpauseAnimations();
} else {
element.pauseAnimations();
}
}
function SubmitIcon(param) {
var createElement = param.createElement, className = param.className;
return /*#__PURE__*/ createElement("svg", {
className: cx('ais-AutocompleteSubmitIcon', className),
viewBox: "0 0 24 24",
fill: "currentColor"
}, /*#__PURE__*/ createElement("path", {
d: "M16.041 15.856c-0.034 0.026-0.067 0.055-0.099 0.087s-0.060 0.064-0.087 0.099c-1.258 1.213-2.969 1.958-4.855 1.958-1.933 0-3.682-0.782-4.95-2.050s-2.050-3.017-2.050-4.95 0.782-3.682 2.050-4.95 3.017-2.050 4.95-2.050 3.682 0.782 4.95 2.050 2.050 3.017 2.050 4.95c0 1.886-0.745 3.597-1.959 4.856zM21.707 20.293l-3.675-3.675c1.231-1.54 1.968-3.493 1.968-5.618 0-2.485-1.008-4.736-2.636-6.364s-3.879-2.636-6.364-2.636-4.736 1.008-6.364 2.636-2.636 3.879-2.636 6.364 1.008 4.736 2.636 6.364 3.879 2.636 6.364 2.636c2.125 0 4.078-0.737 5.618-1.968l3.675 3.675c0.391 0.391 1.024 0.391 1.414 0s0.391-1.024 0-1.414z"
}));
}
function LoadingIcon(param) {
var createElement = param.createElement, isSearchStalled = param.isSearchStalled, className = param.className;
return /*#__PURE__*/ createElement("svg", {
className: cx('ais-AutocompleteLoadingIcon', className),
viewBox: "0 0 100 100",
ref: function ref(element) {
return syncLoadingSvgAnimation(element, isSearchStalled);
}
}, /*#__PURE__*/ createElement("circle", {
cx: "50",
cy: "50",
fill: "none",
r: "35",
stroke: "currentColor",
strokeDasharray: "164.93361431346415 56.97787143782138",
strokeWidth: "6"
}, /*#__PURE__*/ createElement("animateTransform", {
attributeName: "transform",
type: "rotate",
repeatCount: "indefinite",
dur: "1s",
values: "0 50 50;90 50 50;180 50 50;360 50 50",
keyTimes: "0;0.40;0.65;1"
})));
}
function ClearIcon(param) {
var createElement = param.createElement, className = param.className;
return /*#__PURE__*/ createElement("svg", {
className: cx('ais-AutocompleteClearIcon', className),
viewBox: "0 0 24 24",
fill: "currentColor"
}, /*#__PURE__*/ createElement("path", {
d: "M5.293 6.707l5.293 5.293-5.293 5.293c-0.391 0.391-0.391 1.024 0 1.414s1.024 0.391 1.414 0l5.293-5.293 5.293 5.293c0.391 0.391 1.024 0.391 1.414 0s0.391-1.024 0-1.414l-5.293-5.293 5.293-5.293c0.391-0.391 0.391-1.024 0-1.414s-1.024-0.391-1.414 0l-5.293 5.293-5.293-5.293c-0.391-0.391-1.024-0.391-1.414 0s-0.391 1.024 0 1.414z"
}));
}
function ClockIcon(param) {
var createElement = param.createElement, className = param.className;
return /*#__PURE__*/ createElement("svg", {
className: cx(className) || undefined,
viewBox: "0 0 24 24",
fill: "currentColor"
}, /*#__PURE__*/ createElement("path", {
d: "M12.516 6.984v5.25l4.5 2.672-0.75 1.266-5.25-3.188v-6h1.5zM12 20.016q3.281 0 5.648-2.367t2.367-5.648-2.367-5.648-5.648-2.367-5.648 2.367-2.367 5.648 2.367 5.648 5.648 2.367zM12 2.016q4.125 0 7.055 2.93t2.93 7.055-2.93 7.055-7.055 2.93-7.055-2.93-2.93-7.055 2.93-7.055 7.055-2.93z"
}));
}
function TrashIcon(param) {
var createElement = param.createElement, className = param.className;
return /*#__PURE__*/ createElement("svg", {
className: cx(className) || undefined,
viewBox: "0 0 24 24",
fill: "currentColor"
}, /*#__PURE__*/ createElement("path", {
d: "M18 7v13c0 0.276-0.111 0.525-0.293 0.707s-0.431 0.293-0.707 0.293h-10c-0.276 0-0.525-0.111-0.707-0.293s-0.293-0.431-0.293-0.707v-13zM17 5v-1c0-0.828-0.337-1.58-0.879-2.121s-1.293-0.879-2.121-0.879h-4c-0.828 0-1.58 0.337-2.121 0.879s-0.879 1.293-0.879 2.121v1h-4c-0.552 0-1 0.448-1 1s0.448 1 1 1h1v13c0 0.828 0.337 1.58 0.879 2.121s1.293 0.879 2.121 0.879h10c0.828 0 1.58-0.337 2.121-0.879s0.879-1.293 0.879-2.121v-13h1c0.552 0 1-0.448 1-1s-0.448-1-1-1zM9 5v-1c0-0.276 0.111-0.525 0.293-0.707s0.431-0.293 0.707-0.293h4c0.276 0 0.525 0.111 0.707 0.293s0.293 0.431 0.293 0.707v1zM9 11v6c0 0.552 0.448 1 1 1s1-0.448 1-1v-6c0-0.552-0.448-1-1-1s-1 0.448-1 1zM13 11v6c0 0.552 0.448 1 1 1s1-0.448 1-1v-6c0-0.552-0.448-1-1-1s-1 0.448-1 1z"
}));
}
function ApplyIcon(param) {
var createElement = param.createElement, className = param.className;
return /*#__PURE__*/ createElement("svg", {
className: cx(className) || undefined,
viewBox: "0 0 24 24",
fill: "currentColor"
}, /*#__PURE__*/ createElement("path", {
d: "M8 17v-7.586l8.293 8.293c0.391 0.391 1.024 0.391 1.414 0s0.391-1.024 0-1.414l-8.293-8.293h7.586c0.552 0 1-0.448 1-1s-0.448-1-1-1h-10c-0.552 0-1 0.448-1 1v10c0 0.552 0.448 1 1 1s1-0.448 1-1z"
}));
}
function AiModeIcon(param) {
var createElement = param.createElement, className = param.className;
return /*#__PURE__*/ createElement("svg", {
className: cx('ais-AiModeButton-icon', className),
xmlns: "http://www.w3.org/2000/svg",
fill: "none",
viewBox: "0 0 20 20",
width: "16",
height: "16",
"aria-hidden": "true"
}, /*#__PURE__*/ createElement("path", {
fill: "currentColor",
fillRule: "evenodd",
d: "M10 1.875c.27 0 .51.173.594.43l1.593 4.844a1.043 1.043 0 0 0 .664.664l4.844 1.593a.625.625 0 0 1 0 1.188l-4.844 1.593a1.043 1.043 0 0 0-.664.664l-1.593 4.844a.625.625 0 0 1-1.188 0l-1.593-4.844a1.042 1.042 0 0 0-.664-.664l-4.844-1.593a.625.625 0 0 1 0-1.188l4.844-1.593a1.042 1.042 0 0 0 .664-.664l1.593-4.844a.625.625 0 0 1 .594-.43ZM9 7.539A2.292 2.292 0 0 1 7.54 9L4.5 10l3.04 1A2.292 2.292 0 0 1 9 12.46l1 3.04 1-3.04A2.293 2.293 0 0 1 12.46 11l3.04-1-3.04-1A2.292 2.292 0 0 1 11 7.54L10 4.5 9 7.54ZM4.167 1.875c.345 0 .625.28.625.625v3.333a.625.625 0 0 1-1.25 0V2.5c0-.345.28-.625.625-.625ZM15.833 13.542c.345 0 .625.28.625.625V17.5a.625.625 0 1 1-1.25 0v-3.333c0-.345.28-.625.625-.625Z",
clipRule: "evenodd"
}), /*#__PURE__*/ createElement("path", {
fill: "currentColor",
fillRule: "evenodd",
d: "M1.875 4.167c0-.346.28-.625.625-.625h3.333a.625.625 0 1 1 0 1.25H2.5a.625.625 0 0 1-.625-.625ZM13.542 15.833c0-.345.28-.625.625-.625H17.5a.625.625 0 0 1 0 1.25h-3.333a.625.625 0 0 1-.625-.625Z",
clipRule: "evenodd"
}));
}
function SearchIcon(param) {
var createElement = param.createElement, className = param.className;
return /*#__PURE__*/ createElement("svg", {
className: cx('ais-AutocompleteDetachedSearchIcon', className),
viewBox: "0 0 24 24",
fill: "currentColor"
}, /*#__PURE__*/ createElement("path", {
d: "M16.041 15.856c-0.034 0.026-0.067 0.055-0.099 0.087s-0.060 0.064-0.087 0.099c-1.258 1.213-2.969 1.958-4.855 1.958-1.933 0-3.682-0.782-4.95-2.050s-2.050-3.017-2.050-4.95 0.782-3.682 2.050-4.95 3.017-2.050 4.95-2.050 3.682 0.782 4.95 2.050 2.050 3.017 2.050 4.95c0 1.886-0.745 3.597-1.959 4.856zM21.707 20.293l-3.675-3.675c1.231-1.54 1.968-3.493 1.968-5.618 0-2.485-1.008-4.736-2.636-6.364s-3.879-2.636-6.364-2.636-4.736 1.008-6.364 2.636-2.636 3.879-2.636 6.364 1.008 4.736 2.636 6.364 3.879 2.636 6.364 2.636c2.125 0 4.078-0.737 5.618-1.968l3.675 3.675c0.391 0.391 1.024 0.391 1.414 0s0.391-1.024 0-1.414z"
}));
}
function BackIcon(param) {
var createElement = param.createElement, className = param.className;
return /*#__PURE__*/ createElement("svg", {
className: cx('ais-AutocompleteBackIcon', className),
viewBox: "0 0 24 24",
fill: "currentColor"
}, /*#__PURE__*/ createElement("path", {
d: "M9.828 11H21a1 1 0 110 2H9.828l3.586 3.586a1 1 0 01-1.414 1.414l-5.3-5.3a1 1 0 010-1.414l5.3-5.3a1 1 0 111.414 1.414L9.828 11z"
}));
}
function createAutocompleteDetachedSearchButtonComponent(param) {
var createElement = param.createElement;
return function AutocompleteDetachedSearchButton(userProps) {
var query = userProps.query, _userProps_placeholder = userProps.placeholder, placeholder = _userProps_placeholder === void 0 ? 'Search' : _userProps_placeholder, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, onClick = userProps.onClick, onClear = userProps.onClear, translations = userProps.translations;
return /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteDetachedSearchButton', classNames.detachedSearchButton),
onClick: onClick,
onKeyDown: function onKeyDown(event) {
if (event.key === 'Enter' || event.key === ' ') {
event.preventDefault();
onClick();
}
},
role: "button",
tabIndex: 0,
title: translations.detachedSearchButtonTitle
}, /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteDetachedSearchButtonIcon', classNames.detachedSearchButtonIcon)
}, /*#__PURE__*/ createElement(SearchIcon, {
createElement: createElement,
className: classNames.detachedSearchButtonSearchIcon
})), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteDetachedSearchButtonPlaceholder', classNames.detachedSearchButtonPlaceholder),
hidden: Boolean(query)
}, placeholder), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteDetachedSearchButtonQuery', classNames.detachedSearchButtonQuery)
}, query), query && onClear && /*#__PURE__*/ createElement("button", {
type: "reset",
className: cx('ais-AutocompleteDetachedSearchButtonClear', classNames.detachedSearchButtonClear),
title: translations.detachedClearButtonTitle,
onClick: function onClick(event) {
event.stopPropagation();
onClear();
}
}, /*#__PURE__*/ createElement(ClearIcon, {
createElement: createElement,
className: classNames.detachedSearchButtonClearIcon
})));
};
}
function createAutocompleteIndexComponent(param) {
var createElement = param.createElement;
return function AutocompleteIndex(userProps) {
var items = userProps.items, HeaderComponent = userProps.HeaderComponent, ItemComponent = userProps.ItemComponent, NoResultsComponent = userProps.NoResultsComponent, getItemProps = userProps.getItemProps, sendEvent = userProps.sendEvent, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
if (items.length === 0 && !NoResultsComponent) {
return null;
}
return /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteIndex', classNames.root)
}, HeaderComponent && /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteIndexHeader', classNames.header)
}, /*#__PURE__*/ createElement(HeaderComponent, {
items: items
})), items.length === 0 && NoResultsComponent ? /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteIndexNoResults', classNames.noResults)
}, /*#__PURE__*/ createElement(NoResultsComponent, null)) : /*#__PURE__*/ createElement("ol", {
className: cx('ais-AutocompleteIndexList', classNames.list)
}, items.map(function(item, index) {
var _getItemProps = getItemProps(item, index), className = _getItemProps.className, onSelect = _getItemProps.onSelect, onApply = _getItemProps.onApply, itemProps = _object_without_properties(_getItemProps, [
"className",
"onSelect",
"onApply"
]);
return /*#__PURE__*/ createElement("li", _object_spread_props(_object_spread({
key: "".concat(itemProps.id, ":").concat(item.objectID)
}, itemProps), {
className: cx('ais-AutocompleteIndexItem', classNames.item, className),
onClick: function onClick() {
sendEvent === null || sendEvent === void 0 ? void 0 : sendEvent('click:internal', item, 'Hit Clicked');
},
onAuxClick: function onAuxClick() {
sendEvent === null || sendEvent === void 0 ? void 0 : sendEvent('click:internal', item, 'Hit Clicked');
}
}), /*#__PURE__*/ createElement(ItemComponent, {
item: item,
onSelect: onSelect,
onApply: onApply
}));
})));
};
}
function createAutocompletePanelComponent(param) {
var createElement = param.createElement;
return function AutocompletePanel(userProps) {
var children = userProps.children, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, hidden = userProps.hidden, props = _object_without_properties(userProps, [
"children",
"classNames",
"hidden"
]);
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
"aria-hidden": hidden,
className: cx('ais-AutocompletePanel', !hidden && 'ais-AutocompletePanel--open', classNames.root, !hidden && classNames.open, props.className),
onMouseDown: function onMouseDown(event) {
// Prevents the autocomplete panel from blurring the input when
// clicking inside the panel.
event.preventDefault();
}
}), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompletePanelLayout', classNames.layout)
}, children));
};
}
function SparklesIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
fill: "none",
viewBox: "0 0 20 20"
}, /*#__PURE__*/ createElement("path", {
fill: "currentColor",
fillRule: "evenodd",
d: "M10 1.875c.27 0 .51.173.594.43l1.593 4.844a1.043 1.043 0 0 0 .664.664l4.844 1.593a.625.625 0 0 1 0 1.188l-4.844 1.593a1.043 1.043 0 0 0-.664.664l-1.593 4.844a.625.625 0 0 1-1.188 0l-1.593-4.844a1.042 1.042 0 0 0-.664-.664l-4.844-1.593a.625.625 0 0 1 0-1.188l4.844-1.593a1.042 1.042 0 0 0 .664-.664l1.593-4.844a.625.625 0 0 1 .594-.43ZM9 7.539A2.292 2.292 0 0 1 7.54 9L4.5 10l3.04 1A2.292 2.292 0 0 1 9 12.46l1 3.04 1-3.04A2.293 2.293 0 0 1 12.46 11l3.04-1-3.04-1A2.292 2.292 0 0 1 11 7.54L10 4.5 9 7.54ZM4.167 1.875c.345 0 .625.28.625.625v3.333a.625.625 0 0 1-1.25 0V2.5c0-.345.28-.625.625-.625ZM15.833 13.542c.345 0 .625.28.625.625V17.5a.625.625 0 1 1-1.25 0v-3.333c0-.345.28-.625.625-.625Z",
clipRule: "evenodd"
}), /*#__PURE__*/ createElement("path", {
fill: "currentColor",
fillRule: "evenodd",
d: "M1.875 4.167c0-.346.28-.625.625-.625h3.333a.625.625 0 1 1 0 1.25H2.5a.625.625 0 0 1-.625-.625ZM13.542 15.833c0-.345.28-.625.625-.625H17.5a.625.625 0 0 1 0 1.25h-3.333a.625.625 0 0 1-.625-.625Z",
clipRule: "evenodd"
}));
}
function ArrowUpIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "m5 12 7-7 7 7"
}), /*#__PURE__*/ createElement("path", {
d: "M12 19V5"
}));
}
function ArrowRightIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "M5 12h14"
}), /*#__PURE__*/ createElement("path", {
d: "m12 5 7 7-7 7"
}));
}
function ChevronUpIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "m18 15-6-6-6 6"
}));
}
function ChevronDownIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "m6 9 6 6 6-6"
}));
}
function CloseIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "M18 6 6 18"
}), /*#__PURE__*/ createElement("path", {
d: "m6 6 12 12"
}));
}
function MaximizeIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "M15 3h6v6"
}), /*#__PURE__*/ createElement("path", {
d: "m21 3-7 7"
}), /*#__PURE__*/ createElement("path", {
d: "m3 21 7-7"
}), /*#__PURE__*/ createElement("path", {
d: "M9 21H3v-6"
}));
}
function MinimizeIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "m14 10 7-7"
}), /*#__PURE__*/ createElement("path", {
d: "M20 10h-6V4"
}), /*#__PURE__*/ createElement("path", {
d: "m3 21 7-7"
}), /*#__PURE__*/ createElement("path", {
d: "M4 14h6v6"
}));
}
function StopIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("circle", {
cx: "12",
cy: "12",
r: "10"
}), /*#__PURE__*/ createElement("rect", {
x: "9",
y: "9",
width: "6",
height: "6",
rx: "1"
}));
}
function ReloadIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8"
}), /*#__PURE__*/ createElement("path", {
d: "M21 3v5h-5"
}), /*#__PURE__*/ createElement("path", {
d: "M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16"
}), /*#__PURE__*/ createElement("path", {
d: "M3 21v-5h5"
}));
}
function CopyIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("rect", {
width: "14",
height: "14",
x: "8",
y: "8",
rx: "2",
ry: "2"
}), /*#__PURE__*/ createElement("path", {
d: "M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"
}));
}
function MenuIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("circle", {
cx: "12",
cy: "12",
r: "1"
}), /*#__PURE__*/ createElement("circle", {
cx: "12",
cy: "5",
r: "1"
}), /*#__PURE__*/ createElement("circle", {
cx: "12",
cy: "19",
r: "1"
}));
}
function LoadingSpinnerIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
viewBox: "12 12 24 24",
role: "status",
"aria-busy": "true",
"aria-live": "polite"
}, /*#__PURE__*/ createElement("title", null, "Loading spinner"), /*#__PURE__*/ createElement("circle", {
cx: "24",
cy: "24",
r: "11",
fill: "none",
stroke: "currentColor"
}));
}
function CheckIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "M21.801 10A10 10 0 1 1 17 3.335"
}), /*#__PURE__*/ createElement("path", {
d: "m9 11 3 3L22 4"
}));
}
function ThumbsUpIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "M15 5.88 14 10h5.83a2 2 0 0 1 1.92 2.56l-2.33 8A2 2 0 0 1 17.5 22H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2h2.76a2 2 0 0 0 1.79-1.11L12 2a3.13 3.13 0 0 1 3 3.88Z"
}), /*#__PURE__*/ createElement("path", {
d: "M7 10v12"
}));
}
function ThumbsDownIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "M9 18.12 10 14H4.17a2 2 0 0 1-1.92-2.56l2.33-8A2 2 0 0 1 6.5 2H20a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2.76a2 2 0 0 0-1.79 1.11L12 22a3.13 3.13 0 0 1-3-3.88Z"
}), /*#__PURE__*/ createElement("path", {
d: "M17 14V2"
}));
}
function BrainIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round",
"aria-hidden": "true"
}, /*#__PURE__*/ createElement("path", {
d: "M12 18V5"
}), /*#__PURE__*/ createElement("path", {
d: "M15 13a4.17 4.17 0 0 1-3-4 4.17 4.17 0 0 1-3 4"
}), /*#__PURE__*/ createElement("path", {
d: "M17.598 6.5A3 3 0 1 0 12 5a3 3 0 1 0-5.598 1.5"
}), /*#__PURE__*/ createElement("path", {
d: "M17.997 5.125a4 4 0 0 1 2.526 5.77"
}), /*#__PURE__*/ createElement("path", {
d: "M18 18a4 4 0 0 0 2-7.464"
}), /*#__PURE__*/ createElement("path", {
d: "M19.967 17.483A4 4 0 1 1 12 18a4 4 0 1 1-7.967-.517"
}), /*#__PURE__*/ createElement("path", {
d: "M6 18a4 4 0 0 1-2-7.464"
}), /*#__PURE__*/ createElement("path", {
d: "M6.003 5.125a4 4 0 0 0-2.526 5.77"
}));
}
function ChevronLeftIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "m15 18-6-6 6-6"
}));
}
function ChevronRightIcon(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round"
}, /*#__PURE__*/ createElement("path", {
d: "m9 18 6-6-6-6"
}));
}
function createAutocompletePromptSuggestionComponent(param) {
var createElement = param.createElement;
return function AutocompletePromptSuggestion(userProps) {
var item = userProps.item, onSelect = userProps.onSelect, children = userProps.children, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
var label = item.label || item.prompt;
return /*#__PURE__*/ createElement("div", {
onClick: onSelect,
className: cx('ais-AutocompleteItemWrapper', 'ais-AutocompletePromptSuggestionWrapper', classNames.root)
}, /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemContent', 'ais-AutocompletePromptSuggestionItemContent', classNames.content)
}, /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemIcon', 'ais-AutocompletePromptSuggestionItemIcon', classNames.icon)
}, /*#__PURE__*/ createElement(SparklesIcon, {
createElement: createElement
})), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemContentBody', 'ais-AutocompletePromptSuggestionItemContentBody', classNames.body)
}, children !== null && children !== void 0 ? children : label)));
};
}
function createAutocompleteRecentSearchComponent(param) {
var createElement = param.createElement;
return function AutocompleteRecentSearch(userProps) {
var item = userProps.item, children = userProps.children, onSelect = userProps.onSelect, onRemoveRecentSearch = userProps.onRemoveRecentSearch, onApply = userProps.onApply, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
return /*#__PURE__*/ createElement("div", {
onClick: onSelect,
className: cx('ais-AutocompleteItemWrapper ais-AutocompleteRecentSearchWrapper', classNames.root)
}, /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemContent', 'ais-AutocompleteRecentSearchItemContent', classNames.content)
}, /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemIcon', 'ais-AutocompleteRecentSearchItemIcon', classNames.content)
}, /*#__PURE__*/ createElement(ClockIcon, {
createElement: createElement
})), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemContentBody', 'ais-AutocompleteRecentSearchItemContentBody', classNames.content)
}, children)), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemActions', 'ais-AutocompleteRecentSearchItemActions', classNames.actions)
}, /*#__PURE__*/ createElement("button", {
className: cx('ais-AutocompleteItemActionButton', 'ais-AutocompleteRecentSearchItemDeleteButton', classNames.deleteButton),
title: "Remove ".concat(item.query, " from recent searches"),
onClick: function onClick(evt) {
evt.stopPropagation();
onRemoveRecentSearch();
}
}, /*#__PURE__*/ createElement(TrashIcon, {
createElement: createElement
})), /*#__PURE__*/ createElement("button", {
className: cx('ais-AutocompleteItemActionButton', 'ais-AutocompleteRecentSearchItemApplyButton', classNames.applyButton),
title: "Apply ".concat(item.query, " as search"),
onClick: function onClick(evt) {
evt.stopPropagation();
onApply();
}
}, /*#__PURE__*/ createElement(ApplyIcon, {
createElement: createElement
}))));
};
}
function createAutocompleteSearchComponent(param) {
var createElement = param.createElement;
return function AutocompleteSearch(userProps) {
var inputProps = userProps.inputProps, onClear = userProps.onClear, query = userProps.query, isSearchStalled = userProps.isSearchStalled, onCancel = userProps.onCancel, isDetached = userProps.isDetached, submitTitle = userProps.submitTitle, onAiModeClick = userProps.onAiModeClick, _userProps_aiModeButtonDisabled = userProps.aiModeButtonDisabled, aiModeButtonDisabled = _userProps_aiModeButtonDisabled === void 0 ? false : _userProps_aiModeButtonDisabled, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
var isBackButton = Boolean(isDetached && onCancel);
var resolvedCancelTitle = submitTitle !== null && submitTitle !== void 0 ? submitTitle : 'Close';
var inputRef = inputProps.ref;
return /*#__PURE__*/ createElement("form", {
className: cx('ais-AutocompleteForm', classNames.form),
action: "",
noValidate: true,
role: "search",
onSubmit: function onSubmit(e) {
e.preventDefault();
},
onReset: function onReset() {
var _inputRef_current;
return (_inputRef_current = inputRef.current) === null || _inputRef_current === void 0 ? void 0 : _inputRef_current.focus();
}
}, /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteInputWrapperPrefix', classNames.inputWrapperPrefix)
}, isBackButton && /*#__PURE__*/ createElement("button", {
className: cx('ais-AutocompleteBackButton', classNames.backButton),
type: "button",
title: resolvedCancelTitle,
onClick: onCancel,
hidden: isSearchStalled
}, /*#__PURE__*/ createElement(BackIcon, {
createElement: createElement,
className: classNames.backButtonIcon
})), /*#__PURE__*/ createElement("label", {
className: cx('ais-AutocompleteLabel', classNames.label),
"aria-label": "Submit",
htmlFor: inputProps.id,
id: "".concat(inputProps.id, "-label"),
hidden: isBackButton || undefined
}, /*#__PURE__*/ createElement("button", {
className: cx('ais-AutocompleteSubmitButton', classNames.submitButton),
type: "submit",
title: "Submit",
hidden: isSearchStalled
}, /*#__PURE__*/ createElement(SubmitIcon, {
createElement: createElement,
className: classNames.submitButtonIcon
}))), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteLoadingIndicator', classNames.loadingIndicator),
hidden: !isSearchStalled
}, /*#__PURE__*/ createElement(LoadingIcon, {
createElement: createElement,
isSearchStalled: isSearchStalled,
className: classNames.loadingIndicatorIcon
}))), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteInputWrapper', classNames.inputWrapper)
}, /*#__PURE__*/ createElement("input", _object_spread({
className: cx('ais-AutocompleteInput', classNames.input),
"aria-autocomplete": "both",
"aria-labelledby": "".concat(inputProps.id, "-label"),
autoComplete: "off",
autoCorrect: "off",
autoCapitalize: "off",
enterKeyHint: "search",
spellCheck: "false",
maxLength: 512,
type: "search",
value: query
}, inputProps))), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteInputWrapperSuffix', classNames.inputWrapperSuffix)
}, /*#__PURE__*/ createElement("button", {
className: cx('ais-AutocompleteClearButton', classNames.resetButton),
type: "reset",
title: "Clear",
hidden: query.length === 0 || isSearchStalled,
onClick: onClear
}, /*#__PURE__*/ createElement(ClearIcon, {
createElement: createElement,
className: classNames.resetButtonIcon
})), onAiModeClick && /*#__PURE__*/ createElement("button", {
className: cx('ais-AiModeButton', classNames.aiModeButton),
type: "button",
title: "AI Mode",
disabled: aiModeButtonDisabled,
onClick: function onClick(e) {
e.preventDefault();
onAiModeClick();
}
}, /*#__PURE__*/ createElement(AiModeIcon, {
createElement: createElement,
className: classNames.aiModeButtonIcon
}), /*#__PURE__*/ createElement("span", {
className: cx('ais-AiModeButton-label', classNames.aiModeButtonLabel)
}, "AI Mode"))));
};
}
function createAutocompleteSuggestionComponent(param) {
var createElement = param.createElement;
return function AutocompleteSuggestion(userProps) {
var item = userProps.item, children = userProps.children, onSelect = userProps.onSelect, onApply = userProps.onApply, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
return /*#__PURE__*/ createElement("div", {
onClick: onSelect,
className: cx('ais-AutocompleteItemWrapper', 'ais-AutocompleteSuggestionWrapper', classNames.root)
}, /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemContent', 'ais-AutocompleteSuggestionItemContent', classNames.content)
}, /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemIcon', 'ais-AutocompleteSuggestionItemIcon', classNames.content)
}, /*#__PURE__*/ createElement(SubmitIcon, {
createElement: createElement
})), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemContentBody', 'ais-AutocompleteSuggestionItemContentBody', classNames.content)
}, children)), /*#__PURE__*/ createElement("div", {
className: cx('ais-AutocompleteItemActions', 'ais-AutocompleteSuggestionItemActions', classNames.actions)
}, /*#__PURE__*/ createElement("button", {
className: cx('ais-AutocompleteItemActionButton', 'ais-AutocompleteSuggestionItemApplyButton', classNames.applyButton),
type: "button",
title: "Apply ".concat(item.query, " as search"),
onClick: function onClick(evt) {
evt.stopPropagation();
onApply();
}
}, /*#__PURE__*/ createElement(ApplyIcon, {
createElement: createElement
}))));
};
}
function find(array, predicate) {
for(var index = 0; index < array.length; index++){
var item = array[index];
if (predicate(item, index, array)) {
return item;
}
}
return undefined;
}
function createAutocompletePropGetters(param) {
var useEffect = param.useEffect, useId = param.useId, useMemo = param.useMemo, useRef = param.useRef, useState = param.useState;
return function usePropGetters(param) {
var indices = param.indices, indicesConfig = param.indicesConfig, onRefine = param.onRefine, globalOnSelect = param.onSelect, onApply = param.onApply, onSubmit = param.onSubmit, placeholder = param.placeholder, _param_isDetached = param.isDetached, isDetached = _param_isDetached === void 0 ? false : _param_isDetached, _param_shouldHidePanel = param.shouldHidePanel, shouldHidePanel = _param_shouldHidePanel === void 0 ? false : _param_shouldHidePanel, _param_autoFocus = param.autoFocus, autoFocus = _param_autoFocus === void 0 ? false : _param_autoFocus, id = param.id;
var internalId = useId();
var getElementId = createGetElementId(id !== null && id !== void 0 ? id : internalId);
var inputRef = useRef(null);
var rootRef = useRef(null);
var _useState = _sliced_to_array(useState(autoFocus), 2), isOpen = _useState[0], setIsOpen = _useState[1];
var _useState1 = _sliced_to_array(useState(undefined), 2), activeDescendant = _useState1[0], setActiveDescendant = _useState1[1];
var _useMemo = useMemo(function() {
return buildItems({
indices: indices,
indicesConfig: indicesConfig,
getElementId: getElementId
});
}, [
indices,
indicesConfig,
getElementId
]), items = _useMemo.items, itemsIds = _useMemo.itemsIds;
useEffect(function() {
// In detached mode, we don't close the panel on body click
// because the overlay handles closing
if (isDetached) {
return function() {};
}
var onBodyClick = function onBodyClick(event) {
var _unwrapRef;
if ((_unwrapRef = unwrapRef(rootRef)) === null || _unwrapRef === void 0 ? void 0 : _unwrapRef.contains(event.target)) {
return;
}
setIsOpen(false);
};
document.body.addEventListener('click', onBodyClick);
return function() {
document.body.removeEventListener('click', onBodyClick);
};
}, [
rootRef,
isDetached
]);
var getNextActiveDescendant = function getNextActiveDescendant(key) {
switch(key){
case 'ArrowUp':
{
var prevIndex = itemsIds.indexOf(activeDescendant || '') - 1;
return itemsIds[prevIndex] || itemsIds[itemsIds.length - 1];
}
case 'ArrowDown':
{
var nextIndex = itemsIds.indexOf(activeDescendant || '') + 1;
return itemsIds[nextIndex] || itemsIds[0];
}
default:
return undefined;
}
};
var submit = function submit() {
var override = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var _override_activeDescendant;
if (isOpen) {
setIsOpen(false);
} else {
var _inputRef_current;
(_inputRef_current = inputRef.current) === null || _inputRef_current === void 0 ? void 0 : _inputRef_current.blur();
}
var actualDescendant = (_override_activeDescendant = override.activeDescendant) !== null && _override_activeDescendant !== void 0 ? _override_activeDescendant : activeDescendant;
if (!actualDescendant && override.query !== undefined) {
onRefine(override.query);
}
if (actualDescendant && items.has(actualDescendant)) {
var _ref;
var _items_get = items.get(actualDescendant), item = _items_get.item, _items_get_config = _items_get.config, indexOnSelect = _items_get_config.onSelect, getQuery = _items_get_config.getQuery, getURL = _items_get_config.getURL;
var actualOnSelect = indexOnSelect !== null && indexOnSelect !== void 0 ? indexOnSelect : globalOnSelect;
actualOnSelect({
item: item,
query: (_ref = getQuery === null || getQuery === void 0 ? void 0 : getQuery(item)) !== null && _ref !== void 0 ? _ref : '',
url: getURL === null || getURL === void 0 ? void 0 : getURL(item),
setQuery: function setQuery(query) {
return onRefine(query);
}
});
setActiveDescendant(undefined);
}
onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit();
};
return {
getInputProps: function getInputProps() {
return {
id: getElementId('input'),
ref: inputRef,
role: 'combobox',
autoFocus: autoFocus,
'aria-autocomplete': 'list',
'aria-expanded': isOpen,
'aria-haspopup': 'grid',
'aria-controls': getElementId('panel'),
'aria-activedescendant': activeDescendant,
placeholder: placeholder,
onFocus: function onFocus() {
return setIsOpen(true);
},
onKeyDown: function onKeyDown(event) {
switch(event.key){
case 'Escape':
{
if (isOpen) {
setIsOpen(false);
event.preventDefault();
} else {
setActiveDescendant(undefined);
}
break;
}
case 'ArrowUp':
case 'ArrowDown':
{
var _document_getElementById;
setIsOpen(true);
var nextActiveDescendant = getNextActiveDescendant(event.key);
setActiveDescendant(nextActiveDescendant);
(_document_getElementById = document.getElementById(nextActiveDescendant)) === null || _document_getElementById === void 0 ? void 0 : _document_getElementById.scrollIntoView(false);
event.preventDefault();
break;
}
case 'Enter':
{
submit({
query: event.target.value
});
break;
}
case 'Tab':
// In detached mode, Tab doesn't close the panel
if (!isDetached) {
setIsOpen(false);
}
break;
default:
setIsOpen(true);
return;
}
},
onKeyUp: function onKeyUp(event) {
switch(event.key){
case 'ArrowLeft':
case 'ArrowUp':
case 'ArrowRight':
case 'ArrowDown':
case 'Escape':
case 'Return':
event.preventDefault();
return;
default:
setActiveDescendant(undefined);
break;
}
}
};
},
getItemProps: function getItemProps(item, index) {
var id = getElementId('item', item.__indexName, index);
return {
id: id,
role: 'row',
'aria-selected': id === activeDescendant,
onSelect: function onSelect() {
return submit({
activeDescendant: id
});
},
onApply: function onApply1() {
var _ref;
var _items_get = items.get(id), currentItem = _items_get.item, getQuery = _items_get.config.getQuery;
onApply((_ref = getQuery === null || getQuery === void 0 ? void 0 : getQuery(currentItem)) !== null && _ref !== void 0 ? _ref : '');
}
};
},
getPanelProps: function getPanelProps() {
return {
hidden: !isOpen || shouldHidePanel,
id: getElementId('panel'),
role: 'grid',
'aria-labelledby': getElementId('input')
};
},
getRootProps: function getRootProps() {
return {
ref: rootRef
};
},
isOpen: isOpen,
setIsOpen: setIsOpen,
focusInput: function focusInput() {
var _inputRef_current;
(_inputRef_current = inputRef.current) === null || _inputRef_current === void 0 ? void 0 : _inputRef_current.focus();
}
};
};
}
function buildItems(param) {
var _loop = function _loop(i) {
var _indices_i;
var currentIndexConfig = find(indicesConfig, function(config) {
return config.indexName === indices[i].indexName;
});
var hits = ((_indices_i = indices[i]) === null || _indices_i === void 0 ? void 0 : _indices_i.hits) || [];
for(var position = 0; position < hits.length; position++){
var itemId = getElementId('item', (currentIndexConfig === null || currentIndexConfig === void 0 ? void 0 : currentIndexConfig.indexName) || indices[i].indexName, position);
items.set(itemId, {
item: hits[position],
config: currentIndexConfig
});
itemsIds.push(itemId);
}
};
var indices = param.indices, indicesConfig = param.indicesConfig, getElementId = param.getElementId;
var itemsIds = [];
var items = new Map();
for(var i = 0; i < indices.length; i++)_loop(i);
return {
items: items,
itemsIds: itemsIds
};
}
function createGetElementId(autocompleteId) {
return function getElementId() {
for(var _len = arguments.length, suffixes = new Array(_len), _key = 0; _key < _len; _key++){
suffixes[_key] = arguments[_key];
}
var prefix = 'autocomplete';
return "".concat(prefix).concat(autocompleteId).concat(suffixes.join(':'));
};
}
/**
* Returns the framework-agnostic value of a ref.
*/ function unwrapRef(ref) {
return ref.current && _type_of(ref.current) === 'object' && 'base' in ref.current ? ref.current.base // Preact
: ref.current; // React
}
function createAutocompleteStorage(param) {
var useEffect = param.useEffect, useMemo = param.useMemo, useState = param.useState;
return function useStorage(param) {
var showRecent = param.showRecent, query = param.query, indices = param.indices, indicesConfig = param.indicesConfig, suggestionsIndexName = param.suggestionsIndexName;
var storageKey = showRecent && (typeof showRecent === "undefined" ? "undefined" : _type_of(showRecent)) === 'object' ? showRecent.storageKey : undefined;
var storage = useMemo(function() {
return createStorage({
limit: 5,
storageKey: storageKey
});
}, [
storageKey
]);
var _useState = _sliced_to_array(useState(storage.getSnapshot()), 2), snapshot = _useState[0], setSnapshot = _useState[1];
useEffect(function() {
storage.registerUpdateListener(function() {
setSnapshot(storage.getSnapshot());
});
return function() {
storage.unregisterUpdateListener();
};
}, [
storage
]);
if (!showRecent) {
return {
storage: {
onAdd: function onAdd() {},
onRemove: function onRemove() {}
},
storageHits: [],
indicesForPropGetters: indices,
indicesConfigForPropGetters: indicesConfig
};
}
var storageHits = snapshot.getAll(query).map(function(value) {
return {
objectID: value,
query: value,
__indexName: 'recent-searches',
_highlightResult: getHighlightedAttribute({
item: {
query: value
},
query: query || ''
})
};
});
var indicesForPropGetters = _to_consumable_array(indices.map(function(index) {
return index.indexName === suggestionsIndexName ? _object_spread_props(_object_spread({}, index), {
hits: index.hits.filter(function(hit) {
return !find(storageHits, function(storageHit) {
return storageHit.query === hit.query;
});
})
}) : index;
}));
var indicesConfigForPropGetters = _to_consumable_array(indicesConfig);
indicesForPropGetters.unshift({
indexName: 'recent-searches',
indexId: 'recent-searches',
hits: storageHits
});
indicesConfigForPropGetters.unshift({
indexName: 'recent-searches',
// @ts-expect-error - we know it has query as it's generated from storageHits
getQuery: function getQuery(item) {
return item.query;
}
});
return {
storage: storage,
storageHits: storageHits,
indicesForPropGetters: indicesForPropGetters,
indicesConfigForPropGetters: indicesConfigForPropGetters
};
};
}
var LOCAL_STORAGE_KEY_TEST = 'test-localstorage-support';
var LOCAL_STORAGE_KEY = 'autocomplete-recent-searches';
function isLocalStorageSupported() {
try {
localStorage.setItem(LOCAL_STORAGE_KEY_TEST, '');
localStorage.removeItem(LOCAL_STORAGE_KEY_TEST);
return true;
} catch (error) {
return false;
}
}
function getHighlightedAttribute(param) {
var item = param.item, query = param.query;
if (!query.trim().length) {
return {
query: {
matchLevel: 'none'
}
};
}
return {
query: {
value: item.query.replace(new RegExp(query.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&'), 'gi'), function(match) {
return "<mark>".concat(match, "</mark>");
})
}
};
}
function getLocalStorage() {
var key = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : LOCAL_STORAGE_KEY;
if (!isLocalStorageSupported()) {
return {
setItems: function setItems() {},
getItems: function getItems() {
return [];
}
};
}
return {
setItems: function setItems(items) {
try {
window.localStorage.setItem(key, JSON.stringify(items));
} catch (unused) {
// do nothing, this likely means the storage is full
}
},
getItems: function getItems() {
var items = window.localStorage.getItem(key);
return items ? JSON.parse(items) : [];
}
};
}
function createStorage(param) {
var _param_limit = param.limit, limit = _param_limit === void 0 ? 5 : _param_limit, storageKey = param.storageKey;
var storage = getLocalStorage(storageKey);
var updateListener = null;
return {
onAdd: function onAdd(query) {
this.onRemove(query);
storage.setItems([
query
].concat(_to_consumable_array(storage.getItems())));
},
onRemove: function onRemove(query) {
storage.setItems(storage.getItems().filter(function(q) {
return q !== query;
}));
updateListener === null || updateListener === void 0 ? void 0 : updateListener();
},
registerUpdateListener: function registerUpdateListener(callback) {
updateListener = callback;
},
unregisterUpdateListener: function unregisterUpdateListener() {
updateListener = null;
},
getSnapshot: function getSnapshot() {
return {
getAll: function getAll() {
var query = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : '';
return storage.getItems().filter(function(q) {
return q.includes(query);
}).slice(0, limit);
}
};
}
};
}
function createButtonComponent(param) {
var createElement = param.createElement;
return function Button(userProps) {
var _userProps_variant = userProps.variant, variant = _userProps_variant === void 0 ? 'primary' : _userProps_variant, _userProps_size = userProps.size, size = _userProps_size === void 0 ? 'md' : _userProps_size, _userProps_iconOnly = userProps.iconOnly, iconOnly = _userProps_iconOnly === void 0 ? false : _userProps_iconOnly, className = userProps.className, children = userProps.children, props = _object_without_properties(userProps, [
"variant",
"size",
"iconOnly",
"className",
"children"
]);
return /*#__PURE__*/ createElement("button", _object_spread({
type: "button",
className: cx('ais-Button', "ais-Button--".concat(variant), "ais-Button--".concat(size), iconOnly && 'ais-Button--icon-only', className)
}, props), children);
};
}
function createDefaultItemComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
return function DefaultItem(userProps) {
return /*#__PURE__*/ createElement(Fragment, null, JSON.stringify(userProps.item, null, 2));
};
}
function updateNavigationButtonsProps(param) {
var listRef = param.listRef, nextButtonRef = param.nextButtonRef, previousButtonRef = param.previousButtonRef, setCanScrollLeft = param.setCanScrollLeft, setCanScrollRight = param.setCanScrollRight;
if (!listRef.current) {
return;
}
var isLeftHidden = listRef.current.scrollLeft <= 0;
var isRightHidden = listRef.current.scrollLeft + listRef.current.clientWidth >= listRef.current.scrollWidth;
setCanScrollLeft(!isLeftHidden);
setCanScrollRight(!isRightHidden);
if (previousButtonRef.current) {
previousButtonRef.current.hidden = isLeftHidden;
}
if (nextButtonRef.current) {
nextButtonRef.current.hidden = isRightHidden;
}
}
var lastCarouselId = 0;
function generateCarouselId() {
return "ais-Carousel-".concat(lastCarouselId++);
}
function PreviousIconDefaultComponent(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
width: "8",
height: "16",
viewBox: "0 0 8 16",
fill: "none"
}, /*#__PURE__*/ createElement("path", {
fillRule: "evenodd",
clipRule: "evenodd",
fill: "currentColor",
d: "M7.13809 0.744078C7.39844 1.06951 7.39844 1.59715 7.13809 1.92259L2.27616 8L7.13809 14.0774C7.39844 14.4028 7.39844 14.9305 7.13809 15.2559C6.87774 15.5814 6.45563 15.5814 6.19528 15.2559L0.861949 8.58926C0.6016 8.26382 0.6016 7.73618 0.861949 7.41074L6.19528 0.744078C6.45563 0.418641 6.87774 0.418641 7.13809 0.744078Z"
}));
}
function NextIconDefaultComponent(param) {
var createElement = param.createElement;
return /*#__PURE__*/ createElement("svg", {
width: "8",
height: "16",
viewBox: "0 0 8 16",
fill: "none"
}, /*#__PURE__*/ createElement("path", {
fillRule: "evenodd",
clipRule: "evenodd",
fill: "currentColor",
d: "M0.861908 15.2559C0.601559 14.9305 0.601559 14.4028 0.861908 14.0774L5.72384 8L0.861908 1.92259C0.601559 1.59715 0.601559 1.06952 0.861908 0.744079C1.12226 0.418642 1.54437 0.418642 1.80472 0.744079L7.13805 7.41074C7.3984 7.73618 7.3984 8.26382 7.13805 8.58926L1.80472 15.2559C1.54437 15.5814 1.12226 15.5814 0.861908 15.2559Z"
}));
}
function createCarouselComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment, useEffect = param.useEffect, useRef = param.useRef;
return function Carousel(userProps) {
var listRef = userProps.listRef, nextButtonRef = userProps.nextButtonRef, previousButtonRef = userProps.previousButtonRef, carouselIdRef = userProps.carouselIdRef, canScrollLeft = userProps.canScrollLeft, canScrollRight = userProps.canScrollRight, setCanScrollLeft = userProps.setCanScrollLeft, setCanScrollRight = userProps.setCanScrollRight, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, tmp = userProps.itemComponent, ItemComponent = tmp === void 0 ? createDefaultItemComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp, tmp1 = userProps.previousIconComponent, PreviousIcon = tmp1 === void 0 ? PreviousIconDefaultComponent : tmp1, tmp2 = userProps.nextIconComponent, NextIcon = tmp2 === void 0 ? NextIconDefaultComponent : tmp2, HeaderComponent = userProps.headerComponent, _userProps_showNavigation = userProps.showNavigation, showNavigation = _userProps_showNavigation === void 0 ? true : _userProps_showNavigation, items = userProps.items, userTranslations = userProps.translations, sendEvent = userProps.sendEvent, props = _object_without_properties(userProps, [
"listRef",
"nextButtonRef",
"previousButtonRef",
"carouselIdRef",
"canScrollLeft",
"canScrollRight",
"setCanScrollLeft",
"setCanScrollRight",
"classNames",
"itemComponent",
"previousIconComponent",
"nextIconComponent",
"headerComponent",
"showNavigation",
"items",
"translations",
"sendEvent"
]);
var translations = _object_spread({
listLabel: 'Items',
nextButtonLabel: 'Next',
nextButtonTitle: 'Next',
previousButtonLabel: 'Previous',
previousButtonTitle: 'Previous'
}, userTranslations);
var previousItemsLengthRef = useRef(items.length);
var cssClasses = {
root: cx('ais-Carousel', classNames.root),
list: cx('ais-Carousel-list', classNames.list),
item: cx('ais-Carousel-item', classNames.item),
navigation: cx('ais-Carousel-navigation', classNames.navigation),
navigationNext: cx('ais-Carousel-navigation--next', classNames.navigationNext),
navigationPrevious: cx('ais-Carousel-navigation--previous', classNames.navigationPrevious)
};
function scrollLeft() {
if (listRef.current) {
listRef.current.scrollLeft -= listRef.current.offsetWidth * 0.75;
}
}
function scrollRight() {
if (listRef.current) {
listRef.current.scrollLeft += listRef.current.offsetWidth * 0.75;
}
}
useEffect(function() {
if (previousItemsLengthRef.current !== items.length) {
updateNavigationButtonsProps({
listRef: listRef,
nextButtonRef: nextButtonRef,
previousButtonRef: previousButtonRef,
setCanScrollLeft: setCanScrollLeft,
setCanScrollRight: setCanScrollRight
});
previousItemsLengthRef.current = items.length;
}
}, [
items.length,
listRef,
nextButtonRef,
previousButtonRef,
setCanScrollLeft,
setCanScrollRight
]);
if (items.length === 0) {
return null;
}
var itemOccurrences = new Map();
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx(cssClasses.root)
}), HeaderComponent && /*#__PURE__*/ createElement(HeaderComponent, {
nbItems: items.length,
canScrollLeft: canScrollLeft,
canScrollRight: canScrollRight,
scrollLeft: scrollLeft,
scrollRight: scrollRight
}), showNavigation && /*#__PURE__*/ createElement("button", {
ref: previousButtonRef,
title: translations.previousButtonTitle,
"aria-label": translations.previousButtonLabel,
hidden: true,
"aria-controls": carouselIdRef.current,
className: cx(cssClasses.navigation, cssClasses.navigationPrevious),
onClick: function onClick(event) {
event.preventDefault();
scrollLeft();
}
}, /*#__PURE__*/ createElement(PreviousIcon, {
createElement: createElement
})), /*#__PURE__*/ createElement("ol", {
className: cx(cssClasses.list),
ref: listRef,
tabIndex: 0,
id: carouselIdRef.current,
"aria-roledescription": "carousel",
"aria-label": translations.listLabel,
"aria-live": "polite",
onScroll: function onScroll() {
return updateNavigationButtonsProps({
listRef: listRef,
nextButtonRef: nextButtonRef,
previousButtonRef: previousButtonRef,
setCanScrollLeft: setCanScrollLeft,
setCanScrollRight: setCanScrollRight
});
},
onKeyDown: function onKeyDown(event) {
if (event.key === 'ArrowLeft') {
event.preventDefault();
scrollLeft();
} else if (event.key === 'ArrowRight') {
event.preventDefault();
scrollRight();
}
}
}, items.map(function(item, index) {
var _itemOccurrences_get;
var occurrence = (_itemOccurrences_get = itemOccurrences.get(item.objectID)) !== null && _itemOccurrences_get !== void 0 ? _itemOccurrences_get : 0;
itemOccurrences.set(item.objectID, occurrence + 1);
return /*#__PURE__*/ createElement("li", {
key: JSON.stringify([
item.objectID,
occurrence
]),
className: cx(cssClasses.item),
"aria-roledescription": "slide",
"aria-label": "".concat(index + 1, " of ").concat(items.length),
onClick: function onClick() {
sendEvent('click:internal', item, 'Item Clicked');
},
onAuxClick: function onAuxClick() {
sendEvent('click:internal', item, 'Item Clicked');
}
}, /*#__PURE__*/ createElement(ItemComponent, {
item: item,
sendEvent: sendEvent
}));
})), showNavigation && /*#__PURE__*/ createElement("button", {
ref: nextButtonRef,
title: translations.nextButtonTitle,
"aria-label": translations.nextButtonLabel,
"aria-controls": carouselIdRef.current,
className: cx(cssClasses.navigation, cssClasses.navigationNext),
onClick: function onClick(event) {
event.preventDefault();
scrollRight();
}
}, /*#__PURE__*/ createElement(NextIcon, {
createElement: createElement
})));
};
}
function createChatHeaderComponent(param) {
var createElement = param.createElement;
var Button = createButtonComponent({
createElement: createElement
});
return function ChatHeader(userProps) {
var _userProps_maximized = userProps.maximized, maximized = _userProps_maximized === void 0 ? false : _userProps_maximized, onToggleMaximize = userProps.onToggleMaximize, onClose = userProps.onClose, onClear = userProps.onClear, _userProps_canClear = userProps.canClear, canClear = _userProps_canClear === void 0 ? false : _userProps_canClear, CloseIcon$1 = userProps.closeIconComponent;
userProps.minimizeIconComponent;
var MaximizeIcon$1 = userProps.maximizeIconComponent, TitleIcon = userProps.titleIconComponent, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, userTranslations = userProps.translations, props = _object_without_properties(userProps, [
"maximized",
"onToggleMaximize",
"onClose",
"onClear",
"canClear",
"closeIconComponent",
"minimizeIconComponent",
"maximizeIconComponent",
"titleIconComponent",
"classNames",
"translations"
]);
var translations = _object_spread({
title: 'Chat',
minimizeLabel: 'Minimize chat',
maximizeLabel: 'Maximize chat',
closeLabel: 'Close chat',
clearLabel: 'Clear'
}, userTranslations);
var defaultMaximizeIcon = maximized ? /*#__PURE__*/ createElement(MinimizeIcon, {
createElement: createElement
}) : /*#__PURE__*/ createElement(MaximizeIcon, {
createElement: createElement
});
return /*#__PURE__*/ createElement("div", _object_spread({
className: cx('ais-ChatHeader', classNames.root, props.className)
}, props), /*#__PURE__*/ createElement("span", {
className: cx('ais-ChatHeader-title', classNames.title)
}, /*#__PURE__*/ createElement("span", {
className: cx('ais-ChatHeader-titleIcon', classNames.titleIcon)
}, TitleIcon ? /*#__PURE__*/ createElement(TitleIcon, null) : /*#__PURE__*/ createElement(SparklesIcon, {
createElement: createElement
})), translations.title), /*#__PURE__*/ createElement("div", {
className: cx('ais-ChatHeader-actions')
}, onClear && /*#__PURE__*/ createElement(Button, {
variant: "ghost",
size: "sm",
className: cx('ais-ChatHeader-clear', classNames.clear),
onClick: onClear,
disabled: !canClear
}, translations.clearLabel), /*#__PURE__*/ createElement(Button, {
variant: "ghost",
size: "sm",
iconOnly: true,
className: cx('ais-ChatHeader-maximize', classNames.maximize),
onClick: onToggleMaximize,
"aria-label": maximized ? translations.minimizeLabel : translations.maximizeLabel
}, MaximizeIcon$1 ? /*#__PURE__*/ createElement(MaximizeIcon$1, {
maximized: maximized
}) : defaultMaximizeIcon), /*#__PURE__*/ createElement(Button, {
variant: "ghost",
size: "sm",
iconOnly: true,
className: cx('ais-ChatHeader-close', classNames.close),
onClick: onClose,
"aria-label": translations.closeLabel,
title: translations.closeLabel
}, CloseIcon$1 ? /*#__PURE__*/ createElement(CloseIcon$1, null) : /*#__PURE__*/ createElement(CloseIcon, {
createElement: createElement
}))));
};
}
function startsWith(str, prefix) {
return str.slice(0, prefix.length) === prefix;
}
var getTextContent = function getTextContent(message) {
return message.parts.map(function(part) {
return part.type === 'text' ? part.text : '';
}).join('');
};
var hasTextContent = function hasTextContent(message) {
return getTextContent(message).trim() !== '';
};
var isPartText = function isPartText(part) {
return part.type === 'text';
};
var isPartTool = function isPartTool(part) {
return startsWith(part.type, 'tool-');
};
function isReasoningPartActive(parts, index) {
var part = parts[index];
return (part === null || part === void 0 ? void 0 : part.type) === 'reasoning' && part.state === 'streaming' && !parts.slice(index + 1).some(function(laterPart) {
return laterPart.type !== 'reasoning' || laterPart.state === 'streaming';
});
}
/**
* Whether a text part renders nothing. `text-start` creates the part before its
* first delta, and `<context>` wrappers are a shim `ChatMessage` also drops.
*/ var isPartTextEmpty = function isPartTextEmpty(part) {
return part.text.trim().length === 0 || part.text.startsWith('<context>') && part.text.endsWith('</context>');
};
/**
* Whether a part says something about the turn's progress. Data parts and
* unwritten text parts render nothing, so reading them would answer "what is
* this turn doing" with a part that changed nothing on screen.
*/ var isPartProgressSignal = function isPartProgressSignal(part) {
if (startsWith(part.type, 'data-')) {
return false;
}
if (isPartText(part)) {
return !isPartTextEmpty(part);
}
return true;
};
var findLastProgressPart = function findLastProgressPart(parts) {
if (!parts) {
return undefined;
}
for(var index = parts.length - 1; index >= 0; index--){
var part = parts[index];
if (isPartProgressSignal(part)) {
return part;
}
}
return undefined;
};
var TOOL_PART_PREFIX = 'tool-';
/**
* Resolves the tool a message part belongs to, from either a part type
* (`tool-algolia_search_index`) or a bare tool name.
*
* An exact registration wins. Otherwise only tools whose `matchesToolName`
* claims the name are considered, most specific first, for servers that name a
* call after the registered tool: the Algolia MCP Server appends the index name
* (`algolia_search_index_products`).
*
* Generic over the tool shape: the renderer, the loader, the widget and the
* connector hold different subsets of the tool contract.
*/ var findTool = function findTool(partType, tools) {
var toolName = startsWith(partType, TOOL_PART_PREFIX) ? partType.slice(TOOL_PART_PREFIX.length) : partType;
if (tools[toolName]) {
return tools[toolName];
}
var claimants = Object.keys(tools).filter(function(key) {
var _tools_key_matchesToolName, _tools_key;
return Boolean((_tools_key = tools[key]) === null || _tools_key === void 0 ? void 0 : (_tools_key_matchesToolName = _tools_key.matchesToolName) === null || _tools_key_matchesToolName === void 0 ? void 0 : _tools_key_matchesToolName.call(_tools_key, toolName));
});
if (claimants.length === 0) {
return undefined;
}
// Most specific claim wins, ties by name, so the winner doesn't depend on
// registration order.
claimants.sort(function(a, b) {
return b.length - a.length || (a < b ? -1 : 1);
});
return tools[claimants[0]];
};
var FACET_KEY_PREFIX = 'facet_';
/**
* A numeric facet value as the Algolia MCP Server emits it: an operator
* followed by a number (`'<=1500'`). Mirrors that server's own
* `NUMERIC_FILTER_REGEX` so the two sides cannot drift.
*/ var NUMERIC_FACET_VALUE = /^(<=|>=|=|!=|<|>)\s*(-?\d+(\.\d+)?)$/;
var isNumericFacetValues = function isNumericFacetValues(values) {
return values.length > 0 && values.every(function(value) {
return NUMERIC_FACET_VALUE.test(value);
});
};
/**
* The key the Algolia MCP Server attaches its resolved search parameters under,
* on the tool result's `_meta`. Agent Studio forwards this one key to the
* browser by allowlist, as a `data-tool-output-metadata` part correlated by
* `toolCallId`.
*
* These params are the filters the server actually searched with, after
* defaults, clamping and the allow-list — including ones the model never saw.
* That makes them exact where the raw `facet_` keys are ambiguous.
*/ var RESOLVED_SEARCH_PARAMS_META_KEY = 'com.algolia/resolved-search-params';
var TOOL_OUTPUT_METADATA_PART_TYPE = 'data-tool-output-metadata';
var isStringArray = function isStringArray(value) {
return Array.isArray(value) && value.every(function(item) {
return typeof item === 'string';
});
};
var RESOLVED_SEARCH_PARAMS_KEYS = [
'query',
'facetFilters',
'numericFilters'
];
/**
* Recognizes a single resolved-params bag by shape.
*
* The server attaches the same `_meta` key in three shapes: one bag for a
* single-index search, one bag per variation (an array) for a bulk search, and
* a per-index map for a multi-index search. Only the single bag can be read
* here. An array or a map parses to nothing, and an empty bag would still beat
* the raw `facet_` keys and search with the query alone — so the other two
* shapes are left to the fallback path instead.
*/ var isResolvedSearchParamsBag = function isResolvedSearchParamsBag(value) {
return (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && value !== null && !Array.isArray(value) && RESOLVED_SEARCH_PARAMS_KEYS.some(function(key) {
return key in value;
});
};
/**
* Reads the resolved search params a search tool call was answered with.
*
* The metadata arrives as a transient data part next to the tool call. It is
* read from `messages` rather than through `onData` because the chat retains
* every `data-*` part on the message, which covers the live and the replayed
* conversation with one path. Returns `undefined` when the part is absent —
* the case whenever the server does not emit `_meta` — or when its value is
* not a single params bag, so that the caller falls back to the raw
* `facet_` keys instead of searching with no filters at all.
*/ var getResolvedSearchParams = function getResolvedSearchParams(messages, toolCallId) {
if (!messages || !toolCallId) {
return undefined;
}
// Newest first: a re-answered tool call should win over its earlier result.
for(var i = messages.length - 1; i >= 0; i--){
var _messages_i;
var parts = (_messages_i = messages[i]) === null || _messages_i === void 0 ? void 0 : _messages_i.parts;
if (!Array.isArray(parts)) {
continue;
}
for(var j = parts.length - 1; j >= 0; j--){
var _data_metadata;
var part = parts[j];
if (!part || part.type !== TOOL_OUTPUT_METADATA_PART_TYPE) {
continue;
}
var data = part.data;
if ((data === null || data === void 0 ? void 0 : data.toolCallId) !== toolCallId) {
continue;
}
var resolved = (_data_metadata = data.metadata) === null || _data_metadata === void 0 ? void 0 : _data_metadata[RESOLVED_SEARCH_PARAMS_META_KEY];
if (!isResolvedSearchParamsBag(resolved)) {
continue;
}
// Algolia reads a plain string entry as its own group, and the search
// tool's schema accepts that mixed form
// (`['category:Books', ['author:Alice', 'author:Bob']]`), so a flat
// entry is a normal producer output.
var facetFilters = Array.isArray(resolved.facetFilters) ? resolved.facetFilters.map(function(entry) {
return typeof entry === 'string' ? [
entry
] : entry;
}).filter(isStringArray) : undefined;
var numericFilters = isStringArray(resolved.numericFilters) ? resolved.numericFilters : undefined;
return {
query: typeof resolved.query === 'string' ? resolved.query : undefined,
facetFilters: facetFilters && facetFilters.length > 0 ? facetFilters : undefined,
numericFilters: numericFilters && numericFilters.length > 0 ? numericFilters : undefined
};
}
}
return undefined;
};
var hasQueries = function hasQueries(input) {
return Array.isArray(input.queries);
};
var getSearchToolQuery = function getSearchToolQuery(input) {
if (!input) {
return undefined;
}
return hasQueries(input) ? input.queries[0] : input;
};
var getFacetFilters = function getFacetFilters(query) {
if (!query) {
return undefined;
}
if (Array.isArray(query.facet_filters)) {
return query.facet_filters;
}
var facetFilters = Object.entries(query).reduce(function(acc, param) {
var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
if (!startsWith(key, FACET_KEY_PREFIX)) {
return acc;
}
var attribute = key.slice(FACET_KEY_PREFIX.length);
if (!attribute) {
return acc;
}
// A boolean facet arrives as a primitive, not an array.
if (typeof value === 'boolean') {
acc.push([
"".concat(attribute, ":").concat(value)
]);
return acc;
}
if (!Array.isArray(value)) {
return acc;
}
var values = value.filter(function(item) {
return typeof item === 'string';
});
if (values.length === 0) {
return acc;
}
// A numeric facet needs a numeric refinement, which this shape cannot
// express. `price:<=1500` would refine on a value no record holds, so the
// search would quietly return the wrong results. Dropping it loses the
// filter instead, which the user can see. Where the tool's resolved
// search params are available, `getResolvedSearchParams` applies the
// numeric refinement properly and this path is not reached.
if (isNumericFacetValues(values)) {
return acc;
}
acc.push(values.map(function(item) {
return "".concat(attribute, ":").concat(item);
}));
return acc;
}, []);
return facetFilters.length > 0 ? facetFilters : undefined;
};
/**
* Extracts the refinements a search tool searched with, in the shape
* `applyFilters` expects.
*
* The default search tool provides a ready-to-use `facet_filters` array. The
* Algolia MCP Server search tool instead expresses refinements as individual
* `facet_<attribute>` keys (e.g. `facet_categories: ['Books', 'Toys']`), which
* are converted here into `[['attribute:value']]`.
*
* Pass `resolved` (from `getResolvedSearchParams`) to use the filters the
* server actually searched with instead of re-deriving them from the raw keys.
* That is the only way to apply a numeric refinement.
*/ var getApplyFiltersParamsFromToolInput = function getApplyFiltersParamsFromToolInput(input, resolved) {
var query = getSearchToolQuery(input);
// The resolved params are what the server actually searched with, so they win
// wherever they exist. Only they can express a numeric refinement: a numeric
// facet and a string facet whose value is literally `'<=1500'` are identical
// in the raw `facet_` keys.
if (resolved) {
var _resolved_query;
return {
query: (_resolved_query = resolved.query) !== null && _resolved_query !== void 0 ? _resolved_query : query === null || query === void 0 ? void 0 : query.query,
facetFilters: resolved.facetFilters,
numericFilters: resolved.numericFilters
};
}
return {
query: query === null || query === void 0 ? void 0 : query.query,
facetFilters: getFacetFilters(query)
};
};
function n(){return n=Object.assign?Object.assign.bind():function(e){for(var n=1;n<arguments.length;n++){var r=arguments[n];for(var t in r)Object.prototype.hasOwnProperty.call(r,t)&&(e[t]=r[t]);}return e},n.apply(this,arguments)}const t={blockQuote:"0",breakLine:"1",breakThematic:"2",codeBlock:"3",codeFenced:"4",codeInline:"5",footnote:"6",footnoteReference:"7",gfmTask:"8",heading:"9",headingSetext:"10",htmlBlock:"11",htmlComment:"12",htmlSelfClosing:"13",image:"14",link:"15",linkAngleBraceStyleDetector:"16",linkBareUrlDetector:"17",linkMailtoDetector:"18",newlineCoalescer:"19",orderedList:"20",paragraph:"21",ref:"22",refImage:"23",refLink:"24",table:"25",tableSeparator:"26",text:"27",textBolded:"28",textEmphasized:"29",textEscaped:"30",textMarked:"31",textStrikethroughed:"32",unorderedList:"33"},o=["allowFullScreen","allowTransparency","autoComplete","autoFocus","autoPlay","cellPadding","cellSpacing","charSet","classId","colSpan","contentEditable","contextMenu","crossOrigin","encType","formAction","formEncType","formMethod","formNoValidate","formTarget","frameBorder","hrefLang","inputMode","keyParams","keyType","marginHeight","marginWidth","maxLength","mediaGroup","minLength","noValidate","radioGroup","readOnly","rowSpan","spellCheck","srcDoc","srcLang","srcSet","tabIndex","useMap"].reduce((e,n)=>(e[n.toLowerCase()]=n,e),{class:"className",for:"htmlFor"}),a={amp:"&",apos:"'",gt:">",lt:"<",nbsp:" ",quot:"“"},c=["style","script","pre"],i=["src","href","data","formAction","srcDoc","action"],u=/([-A-Z0-9_:]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|(?:\{((?:\\.|{[^}]*?}|[^}])*)\})))?/gi,l=/\n{2,}$/,s=/^(\s*>[\s\S]*?)(?=\n\n|$)/,f=/^ *> ?/gm,_=/^(?:\[!([^\]]*)\]\n)?([\s\S]*)/,d=/^ {2,}\n/,p=/^(?:([-*_])( *\1){2,}) *(?:\n *)+\n/,y=/^(?: {1,3})?(`{3,}|~{3,}) *(\S+)? *([^\n]*?)?\n([\s\S]*?)(?:\1\n?|$)/,h=/^(?: {4}[^\n]+\n*)+(?:\n *)+\n?/,g=/^(`+)((?:\\`|(?!\1)`|[^`])+)\1/,m=/^(?:\n *)*\n/,k=/\r\n?/g,x=/^\[\^([^\]]+)](:(.*)((\n+ {4,}.*)|(\n(?!\[\^).+))*)/,q=/^\[\^([^\]]+)]/,v=/\f/g,b=/^---[ \t]*\n(.|\n)*\n---[ \t]*\n/,$=/^\s*?\[(x|\s)\]/,S=/^ *(#{1,6}) *([^\n]+?)(?: +#*)?(?:\n *)*(?:\n|$)/,z=/^ *(#{1,6}) +([^\n]+?)(?: +#*)?(?:\n *)*(?:\n|$)/,E=/^([^\n]+)\n *(=|-)\2{2,} *\n/,A=/^ *(?!<[a-z][^ >/]* ?\/>)<([a-z][^ >/]*) ?((?:[^>]*[^/])?)>\n?(\s*(?:<\1[^>]*?>[\s\S]*?<\/\1>|(?!<\1\b)[\s\S])*?)<\/\1>(?!<\/\1>)\n*/i,R=/&([a-z0-9]+|#[0-9]{1,6}|#x[0-9a-fA-F]{1,6});/gi,B=/^<!--[\s\S]*?(?:-->)/,L=/^(data|aria|x)-[a-z_][a-z\d_.-]*$/,O=/^ *<([a-z][a-z0-9:]*)(?:\s+((?:<.*?>|[^>])*))?\/?>(?!<\/\1>)(\s*\n)?/i,j=/^\{.*\}$/,C=/^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/,I=/^<([^ >]+[:@\/][^ >]+)>/,T=/-([a-z])?/gi,M=/^(\|.*)\n(?: *(\|? *[-:]+ *\|[-| :]*)\n((?:.*\|.*\n)*))?\n?/,w=/^[^\n]+(?: \n|\n{2,})/,D=/^\[([^\]]*)\]:\s+<?([^\s>]+)>?\s*("([^"]*)")?/,F=/^!\[([^\]]*)\] ?\[([^\]]*)\]/,P=/^\[([^\]]*)\] ?\[([^\]]*)\]/,Z=/(\n|^[-*]\s|^#|^ {2,}|^-{2,}|^>\s)/,N=/\t/g,G=/(^ *\||\| *$)/g,U=/^ *:-+: *$/,V=/^ *:-+ *$/,H=/^ *-+: *$/,Q=e=>`(?=[\\s\\S]+?\\1${e?"\\1":""})`,W="((?:\\[.*?\\][([].*?[)\\]]|<.*?>(?:.*?<.*?>)?|`.*?`|\\\\\\1|[\\s\\S])+?)",J=RegExp(`^([*_])\\1${Q(1)}${W}\\1\\1(?!\\1)`),K=RegExp(`^([*_])${Q(0)}${W}\\1(?!\\1)`),X=RegExp(`^(==)${Q(0)}${W}\\1`),Y=RegExp(`^(~~)${Q(0)}${W}\\1`),ee=/^(:[a-zA-Z0-9-_]+:)/,ne=/^\\([^0-9A-Za-z\s])/,re=/\\([^0-9A-Za-z\s])/g,te=/^[\s\S](?:(?! \n|[0-9]\.|http)[^=*_~\-\n:<`\\\[!])*/,oe=/^\n+/,ae=/^([ \t]*)/,ce=/(?:^|\n)( *)$/,ie="(?:\\d+\\.)",ue="(?:[*+-])";function le(e){return "( *)("+(1===e?ie:ue)+") +"}const se=le(1),fe=le(2);function _e(e){return RegExp("^"+(1===e?se:fe))}const de=_e(1),pe=_e(2);function ye(e){return RegExp("^"+(1===e?se:fe)+"[^\\n]*(?:\\n(?!\\1"+(1===e?ie:ue)+" )[^\\n]*)*(\\n|$)","gm")}const he=ye(1),ge=ye(2);function me(e){const n=1===e?ie:ue;return RegExp("^( *)("+n+") [\\s\\S]+?(?:\\n{2,}(?! )(?!\\1"+n+" (?!"+n+" ))\\n*|\\s*\\n*$)")}const ke=me(1),xe=me(2);function qe(e,n){const r=1===n,t=r?ke:xe,o=r?he:ge,a=r?de:pe;return {t:e=>a.test(e),o:je(function(e,n){const r=ce.exec(n.prevCapture);return r&&(n.list||!n.inline&&!n.simple)?t.exec(e=r[1]+e):null}),i:1,u(e,n,t){const c=r?+e[2]:void 0,i=e[0].replace(l,"\n").match(o);let u=!1;return {items:i.map(function(e,r){const o=a.exec(e)[0].length,c=RegExp("^ {1,"+o+"}","gm"),l=e.replace(c,"").replace(a,""),s=r===i.length-1,f=-1!==l.indexOf("\n\n")||s&&u;u=f;const _=t.inline,d=t.list;let p;t.list=!0,f?(t.inline=!1,p=Se(l)+"\n\n"):(t.inline=!0,p=Se(l));const y=n(p,t);return t.inline=_,t.list=d,y}),ordered:r,start:c}},l:(n,r,t)=>e(n.ordered?"ol":"ul",{key:t.key,start:"20"===n.type?n.start:void 0},n.items.map(function(n,o){return e("li",{key:o},r(n,t))}))}}const ve=RegExp("^\\[((?:\\[[^\\[\\]]*(?:\\[[^\\[\\]]*\\][^\\[\\]]*)*\\]|[^\\[\\]])*)\\]\\(\\s*<?((?:\\([^)]*\\)|[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['\"]([\\s\\S]*?)['\"])?\\s*\\)"),be=/^!\[(.*?)\]\( *((?:\([^)]*\)|[^() ])*) *"?([^)"]*)?"?\)/;function $e(e){return "string"==typeof e}function Se(e){let n=e.length;for(;n>0&&e[n-1]<=" ";)n--;return e.slice(0,n)}function ze(e,n){return e.startsWith(n)}function Ee(e,n,r){if(Array.isArray(r)){for(let n=0;n<r.length;n++)if(ze(e,r[n]))return !0;return !1}return r(e,n)}function Ae(e){return e.replace(/[ÀÁÂÃÄÅàáâãäåæÆ]/g,"a").replace(/[çÇ]/g,"c").replace(/[ðÐ]/g,"d").replace(/[ÈÉÊËéèêë]/g,"e").replace(/[ÏïÎîÍíÌì]/g,"i").replace(/[Ññ]/g,"n").replace(/[øØœŒÕõÔôÓóÒò]/g,"o").replace(/[ÜüÛûÚúÙù]/g,"u").replace(/[ŸÿÝý]/g,"y").replace(/[^a-z0-9- ]/gi,"").replace(/ /gi,"-").toLowerCase()}function Re(e){return H.test(e)?"right":U.test(e)?"center":V.test(e)?"left":null}function Be(e,n,r,t){const o=r.inTable;r.inTable=!0;let a=[[]],c="";function i(){if(!c)return;const e=a[a.length-1];e.push.apply(e,n(c,r)),c="";}return e.trim().split(/(`[^`]*`|\\\||\|)/).filter(Boolean).forEach((e,n,r)=>{"|"===e.trim()&&(i(),t)?0!==n&&n!==r.length-1&&a.push([]):c+=e;}),i(),r.inTable=o,a}function Le(e,n,r){r.inline=!0;const t=e[2]?e[2].replace(G,"").split("|").map(Re):[],o=e[3]?function(e,n,r){return e.trim().split("\n").map(function(e){return Be(e,n,r,!0)})}(e[3],n,r):[],a=Be(e[1],n,r,!!o.length);return r.inline=!1,o.length?{align:t,cells:o,header:a,type:"25"}:{children:a,type:"21"}}function Oe(e,n){return null==e.align[n]?{}:{textAlign:e.align[n]}}function je(e){return e.inline=1,e}function Ce(e){return je(function(n,r){return r.inline?e.exec(n):null})}function Ie(e){return je(function(n,r){return r.inline||r.simple?e.exec(n):null})}function Te(e){return function(n,r){return r.inline||r.simple?null:e.exec(n)}}function Me(e){return je(function(n){return e.exec(n)})}const we=/(javascript|vbscript|data(?!:image)):/i;function De(e){try{const n=decodeURIComponent(e).replace(/[^A-Za-z0-9/:]/g,"");if(we.test(n))return null}catch(e){return null}return e}function Fe(e){return e?e.replace(re,"$1"):e}function Pe(e,n,r){const t=r.inline||!1,o=r.simple||!1;r.inline=!0,r.simple=!0;const a=e(n,r);return r.inline=t,r.simple=o,a}function Ze(e,n,r){const t=r.inline||!1,o=r.simple||!1;r.inline=!1,r.simple=!0;const a=e(n,r);return r.inline=t,r.simple=o,a}function Ne(e,n,r){const t=r.inline||!1;r.inline=!1;const o=e(n,r);return r.inline=t,o}const Ge=(e,n,r)=>({children:Pe(n,e[2],r)});function Ue(){return {}}function Ve(){return null}function He(...e){return e.filter(Boolean).join(" ")}function Qe(e,n,r){let t=e;const o=n.split(".");for(;o.length&&(t=t[o[0]],void 0!==t);)o.shift();return t||r}function We(r="",t={}){t.overrides=t.overrides||{},t.namedCodesToUnicode=t.namedCodesToUnicode?n({},a,t.namedCodesToUnicode):a;const l=t.slugify||Ae,G=t.sanitizer||De,U=t.createElement||React__namespace.createElement,V=[s,y,h,t.enforceAtxHeadings?z:S,E,M,ke,xe],H=[...V,w,A,B,O];function Q(e,n){for(let r=0;r<e.length;r++)if(e[r].test(n))return !0;return !1}function W(e,r,...o){const a=Qe(t.overrides,e+".props",{});return U(function(e,n){const r=Qe(n,e);return r?"function"==typeof r||"object"==typeof r&&"render"in r?r:Qe(n,e+".component",e):e}(e,t.overrides),n({},r,a,{className:He(null==r?void 0:r.className,a.className)||void 0}),...o)}function re(e){e=e.replace(b,"");let n=!1;t.forceInline?n=!0:t.forceBlock||(n=!1===Z.test(e));const r=fe(se(n?e:Se(e).replace(oe,"")+"\n\n",{inline:n}));for(;$e(r[r.length-1])&&!r[r.length-1].trim();)r.pop();if(null===t.wrapper)return r;const o=t.wrapper||(n?"span":"div");let a;if(r.length>1||t.forceWrapper)a=r;else {if(1===r.length)return a=r[0],"string"==typeof a?W("span",{key:"outer"},a):a;a=null;}return U(o,{key:"outer"},a)}function ce(e,n){if(!n||!n.trim())return null;const r=n.match(u);return r?r.reduce(function(n,r){const t=r.indexOf("=");if(-1!==t){const a=function(e){return -1!==e.indexOf("-")&&null===e.match(L)&&(e=e.replace(T,function(e,n){return n.toUpperCase()})),e}(r.slice(0,t)).trim(),c=function(e){const n=e[0];return ('"'===n||"'"===n)&&e.length>=2&&e[e.length-1]===n?e.slice(1,-1):e}(r.slice(t+1).trim()),u=o[a]||a;if("ref"===u)return n;const l=n[u]=function(e,n,r,t){return "style"===n?function(e){const n=[];let r="",t=!1,o=!1,a="";if(!e)return n;for(let c=0;c<e.length;c++){const i=e[c];if('"'!==i&&"'"!==i||t||(o?i===a&&(o=!1,a=""):(o=!0,a=i)),"("===i&&r.endsWith("url")?t=!0:")"===i&&t&&(t=!1),";"!==i||o||t)r+=i;else {const e=r.trim();if(e){const r=e.indexOf(":");if(r>0){const t=e.slice(0,r).trim(),o=e.slice(r+1).trim();n.push([t,o]);}}r="";}}const c=r.trim();if(c){const e=c.indexOf(":");if(e>0){const r=c.slice(0,e).trim(),t=c.slice(e+1).trim();n.push([r,t]);}}return n}(r).reduce(function(n,[r,o]){return n[r.replace(/(-[a-z])/g,e=>e[1].toUpperCase())]=t(o,e,r),n},{}):-1!==i.indexOf(n)?t(Fe(r),e,n):(r.match(j)&&(r=Fe(r.slice(1,r.length-1))),"true"===r||"false"!==r&&r)}(e,a,c,G);"string"==typeof l&&(A.test(l)||O.test(l))&&(n[u]=re(l.trim()));}else "style"!==r&&(n[o[r]||r]=!0);return n},{}):null}const ie=[],ue={},le={0:{t:[">"],o:Te(s),i:1,u(e,n,r){const[,t,o]=e[0].replace(f,"").match(_);return {alert:t,children:n(o,r)}},l(e,n,r){const t={key:r.key};return e.alert&&(t.className="markdown-alert-"+l(e.alert.toLowerCase(),Ae),e.children.unshift({attrs:{},children:[{type:"27",text:e.alert}],noInnerParse:!0,type:"11",tag:"header"})),W("blockquote",t,n(e.children,r))}},1:{t:[" "],o:Me(d),i:1,u:Ue,l:(e,n,r)=>W("br",{key:r.key})},2:{t:["--","__","**","- ","* ","_ "],o:Te(p),i:1,u:Ue,l:(e,n,r)=>W("hr",{key:r.key})},3:{t:[" "],o:Te(h),i:0,u:e=>({lang:void 0,text:Fe(Se(e[0].replace(/^ {4}/gm,"")))}),l:(e,r,t)=>W("pre",{key:t.key},W("code",n({},e.attrs,{className:e.lang?"lang-"+e.lang:""}),e.text))},4:{t:["```","~~~"],o:Te(y),i:0,u:e=>({attrs:ce("code",e[3]||""),lang:e[2]||void 0,text:e[4],type:"3"})},5:{t:["`"],o:Ie(g),i:3,u:e=>({text:Fe(e[2])}),l:(e,n,r)=>W("code",{key:r.key},e.text)},6:{t:["[^"],o:Te(x),i:0,u:e=>(ie.push({footnote:e[2],identifier:e[1]}),{}),l:Ve},7:{t:["[^"],o:Ce(q),i:1,u:e=>({target:"#"+l(e[1],Ae),text:e[1]}),l:(e,n,r)=>W("a",{key:r.key,href:G(e.target,"a","href")},W("sup",{key:r.key},e.text))},8:{t:["[ ]","[x]"],o:Ce($),i:1,u:e=>({completed:"x"===e[1].toLowerCase()}),l:(e,n,r)=>W("input",{checked:e.completed,key:r.key,readOnly:!0,type:"checkbox"})},9:{t:["#"],o:Te(t.enforceAtxHeadings?z:S),i:1,u:(e,n,r)=>({children:Pe(n,e[2],r),id:l(e[2],Ae),level:e[1].length}),l:(e,n,r)=>W("h"+e.level,{id:e.id,key:r.key},n(e.children,r))},10:{t:e=>{const n=e.indexOf("\n");return n>0&&n<e.length-1&&("="===e[n+1]||"-"===e[n+1])},o:Te(E),i:0,u:(e,n,r)=>({children:Pe(n,e[1],r),level:"="===e[2]?1:2,type:"9"})},11:{t:["<"],o:Me(A),i:1,u(e,n,r){const[,t]=e[3].match(ae),o=RegExp("^"+t,"gm"),a=e[3].replace(o,""),i=Q(H,a)?Ne:Pe,u=e[1].toLowerCase(),l=-1!==c.indexOf(u),s=(l?u:e[1]).trim(),f={attrs:ce(s,e[2]),noInnerParse:l,tag:s};if(r.inAnchor=r.inAnchor||"a"===u,l)f.text=e[3];else {const e=r.inHTML;r.inHTML=!0,f.children=i(n,a,r),r.inHTML=e;}return r.inAnchor=!1,f},l:(e,r,t)=>W(e.tag,n({key:t.key},e.attrs),e.text||(e.children?r(e.children,t):""))},13:{t:["<"],o:Me(O),i:1,u(e){const n=e[1].trim();return {attrs:ce(n,e[2]||""),tag:n}},l:(e,r,t)=>W(e.tag,n({},e.attrs,{key:t.key}))},12:{t:["\x3c!--"],o:Me(B),i:1,u:()=>({}),l:Ve},14:{t:["!["],o:Ie(be),i:1,u:e=>({alt:Fe(e[1]),target:Fe(e[2]),title:Fe(e[3])}),l:(e,n,r)=>W("img",{key:r.key,alt:e.alt||void 0,title:e.title||void 0,src:G(e.target,"img","src")})},15:{t:["["],o:Ce(ve),i:3,u:(e,n,r)=>({children:Ze(n,e[1],r),target:Fe(e[2]),title:Fe(e[3])}),l:(e,n,r)=>W("a",{key:r.key,href:G(e.target,"a","href"),title:e.title},n(e.children,r))},16:{t:["<"],o:Ce(I),i:0,u(e){let n=e[1],r=!1;return -1!==n.indexOf("@")&&-1===n.indexOf("//")&&(r=!0,n=n.replace("mailto:","")),{children:[{text:n,type:"27"}],target:r?"mailto:"+n:n,type:"15"}}},17:{t:(e,n)=>!n.inAnchor&&!t.disableAutoLink&&(ze(e,"http://")||ze(e,"https://")),o:Ce(C),i:0,u:e=>({children:[{text:e[1],type:"27"}],target:e[1],title:void 0,type:"15"})},20:qe(W,1),33:qe(W,2),19:{t:["\n"],o:Te(m),i:3,u:Ue,l:()=>"\n"},21:{o:je(function(e,n){if(n.inline||n.simple||n.inHTML&&-1===e.indexOf("\n\n")&&-1===n.prevCapture.indexOf("\n\n"))return null;let r="",t=0;for(;;){const n=e.indexOf("\n",t),o=e.slice(t,-1===n?void 0:n+1);if(Q(V,o))break;if(r+=o,-1===n||!o.trim())break;t=n+1;}const o=Se(r);return ""===o?null:[r,,o]}),i:3,u:Ge,l:(e,n,r)=>W("p",{key:r.key},n(e.children,r))},22:{t:["["],o:Ce(D),i:0,u:e=>(ue[e[1]]={target:e[2],title:e[4]},{}),l:Ve},23:{t:["!["],o:Ie(F),i:0,u:e=>({alt:e[1]?Fe(e[1]):void 0,ref:e[2]}),l:(e,n,r)=>ue[e.ref]?W("img",{key:r.key,alt:e.alt,src:G(ue[e.ref].target,"img","src"),title:ue[e.ref].title}):null},24:{t:e=>"["===e[0]&&-1===e.indexOf("]("),o:Ce(P),i:0,u:(e,n,r)=>({children:n(e[1],r),fallbackChildren:e[0],ref:e[2]}),l:(e,n,r)=>ue[e.ref]?W("a",{key:r.key,href:G(ue[e.ref].target,"a","href"),title:ue[e.ref].title},n(e.children,r)):W("span",{key:r.key},e.fallbackChildren)},25:{t:["|"],o:Te(M),i:1,u:Le,l(e,n,r){const t=e;return W("table",{key:r.key},W("thead",null,W("tr",null,t.header.map(function(e,o){return W("th",{key:o,style:Oe(t,o)},n(e,r))}))),W("tbody",null,t.cells.map(function(e,o){return W("tr",{key:o},e.map(function(e,o){return W("td",{key:o,style:Oe(t,o)},n(e,r))}))})))}},27:{o:je(function(e,n){let r;return ze(e,":")&&(r=ee.exec(e)),r||te.exec(e)}),i:4,u(e){const n=e[0];return {text:-1===n.indexOf("&")?n:n.replace(R,(e,n)=>t.namedCodesToUnicode[n]||e)}},l:e=>e.text},28:{t:["**","__"],o:Ie(J),i:2,u:(e,n,r)=>({children:n(e[2],r)}),l:(e,n,r)=>W("strong",{key:r.key},n(e.children,r))},29:{t:e=>{const n=e[0];return ("*"===n||"_"===n)&&e[1]!==n},o:Ie(K),i:3,u:(e,n,r)=>({children:n(e[2],r)}),l:(e,n,r)=>W("em",{key:r.key},n(e.children,r))},30:{t:["\\"],o:Ie(ne),i:1,u:e=>({text:e[1],type:"27"})},31:{t:["=="],o:Ie(X),i:3,u:Ge,l:(e,n,r)=>W("mark",{key:r.key},n(e.children,r))},32:{t:["~~"],o:Ie(Y),i:3,u:Ge,l:(e,n,r)=>W("del",{key:r.key},n(e.children,r))}};!0===t.disableParsingRawHTML&&(delete le[11],delete le[13]);const se=function(e){var n=Object.keys(e);function r(t,o){var a=[];if(o.prevCapture=o.prevCapture||"",t.trim())for(;t;)for(var c=0;c<n.length;){var i=n[c],u=e[i];if(!u.t||Ee(t,o,u.t)){var l=u.o(t,o);if(l&&l[0]){t=t.substring(l[0].length);var s=u.u(l,r,o);o.prevCapture+=l[0],s.type||(s.type=i),a.push(s);break}c++;}else c++;}return o.prevCapture="",a}return n.sort(function(n,r){return e[n].i-e[r].i||(n<r?-1:1)}),function(e,n){return r(function(e){return e.replace(k,"\n").replace(v,"").replace(N," ")}(e),n)}}(le),fe=function(e,n){return function r(t,o={}){if(Array.isArray(t)){const e=o.key,n=[];let a=!1;for(let e=0;e<t.length;e++){o.key=e;const c=r(t[e],o),i=$e(c);i&&a?n[n.length-1]+=c:null!==c&&n.push(c),a=i;}return o.key=e,n}return function(r,t,o){const a=e[r.type].l;return n?n(()=>a(r,t,o),r,t,o):a(r,t,o)}(t,r,o)}}(le,t.renderRule),_e=re(r);return ie.length?W("div",null,_e,W("footer",{key:"footer"},ie.map(function(e){return W("div",{id:l(e.identifier,Ae),key:e.identifier},e.identifier,fe(se(e.footnote,{inline:!0})))}))):_e}
var createRecords = function createRecords() {
return Object.create(null);
};
var hasOwn$1 = function hasOwn(records, objectID) {
return Object.prototype.hasOwnProperty.call(records, objectID);
};
function createChatRecordsStore() {
var records = createRecords();
return {
get: function get(objectID) {
return hasOwn$1(records, objectID) ? records[objectID] : undefined;
},
has: function has(objectID) {
return hasOwn$1(records, objectID);
},
getAll: function getAll() {
return records;
},
merge: function merge(contributed) {
contributed.forEach(function(record) {
if (record && typeof record.objectID === 'string' && record.objectID !== '') {
records[record.objectID] = record;
}
});
},
clear: function clear() {
records = createRecords();
}
};
}
/**
* Collects into `store` the records of every completed tool call in `messages`
* whose output holds `hits`. Matching on the output rather than on a tool name
* means any tool that fetches records contributes them by returning them.
*
* Idempotent, so it can re-run over the whole conversation on every update:
* streaming deltas and a conversation restored from storage are one code path.
*/ function collectChatRecords(messages) {
var store = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : createChatRecordsStore();
messages === null || messages === void 0 ? void 0 : messages.forEach(function(message) {
message.parts.forEach(function(part) {
var _part_output;
if (!isPartTool(part) || part.state !== 'output-available') {
return;
}
var hits = ((_part_output = part.output) !== null && _part_output !== void 0 ? _part_output : {}).hits;
if (Array.isArray(hits)) {
store.merge(hits);
}
});
});
return store;
}
function createChatMessageReasoningComponent(param) {
var createElement = param.createElement;
return function ChatMessageReasoning(userProps) {
var parts = userProps.parts, hidden = userProps.hidden, _userProps_parseMarkdown = userProps.parseMarkdown, parseMarkdown = _userProps_parseMarkdown === void 0 ? true : _userProps_parseMarkdown, translations = userProps.translations, classNames = userProps.classNames;
var activePart = parts.find(function(param) {
var isStreaming = param.isStreaming;
return isStreaming;
});
var isStreaming = Boolean(activePart);
var hasActiveHint = Boolean(activePart === null || activePart === void 0 ? void 0 : activePart.part.text.trim());
var renderPart = function renderPart(param) {
var part = param.part;
return parseMarkdown ? We(part.text, {
createElement: createElement,
disableParsingRawHTML: true
}) : /*#__PURE__*/ createElement("p", {
className: "ais-ChatMessage-text"
}, part.text);
};
var renderHint = function renderHint(part) {
return parseMarkdown ? We(part.text, {
createElement: createElement,
forceInline: true,
renderRule: function renderRule(next, node) {
if (node.type === t.htmlBlock || node.type === t.htmlComment || node.type === t.htmlSelfClosing) {
return null;
}
return next();
}
}) : part.text;
};
return /*#__PURE__*/ createElement("details", {
className: cx(classNames.reasoning),
"aria-label": translations.reasoningLabel,
"aria-busy": isStreaming,
hidden: hidden
}, /*#__PURE__*/ createElement("summary", {
className: cx(classNames.reasoningHeader)
}, /*#__PURE__*/ createElement("span", {
className: cx(classNames.reasoningIcon),
"aria-hidden": "true"
}, /*#__PURE__*/ createElement(BrainIcon, {
createElement: createElement
})), /*#__PURE__*/ createElement("span", {
className: cx(classNames.reasoningLabel)
}, translations.reasoningLabel), activePart && hasActiveHint && /*#__PURE__*/ createElement("span", {
className: "ais-ChatMessageReasoning-status",
"aria-hidden": "true"
}, /*#__PURE__*/ createElement("span", {
className: "ais-ChatMessageReasoning-separator"
}, "\xb7"), /*#__PURE__*/ createElement("span", {
className: "ais-ChatMessageReasoning-hint"
}, renderHint(activePart.part))), /*#__PURE__*/ createElement("span", {
className: cx(classNames.reasoningChevron),
"aria-hidden": "true"
}, /*#__PURE__*/ createElement(ChevronDownIcon, {
createElement: createElement
}))), /*#__PURE__*/ createElement("div", {
className: cx(classNames.reasoningBody)
}, /*#__PURE__*/ createElement("ol", {
className: cx(classNames.reasoningText)
}, parts.map(function(reasoningPart) {
return /*#__PURE__*/ createElement("li", {
key: reasoningPart.partIndex,
className: "ais-ChatMessageReasoning-item",
"aria-current": reasoningPart.isStreaming ? 'step' : undefined
}, renderPart(reasoningPart));
}))));
};
}
/**
* The root-level props tool layout components received before everything moved
* under `context`. Passed alongside `context` so components written against the
* previous API keep working. Remove together with
* `DeprecatedClientSideToolRootProps` in the next major.
*/ function getDeprecatedToolRootProps(context) {
return {
message: context.message,
messages: context.messages,
records: context.records,
insightsEventContext: context.insightsEventContext,
status: context.status,
indexUiState: context.indexUiState,
setIndexUiState: context.setIndexUiState,
onClose: context.onClose,
addToolResult: context.addToolResult,
applyFilters: context.applyFilters,
sendEvent: context.sendEvent
};
}
function createChatMessageComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
var Button = createButtonComponent({
createElement: createElement
});
var ChatMessageReasoning = createChatMessageReasoningComponent({
createElement: createElement
});
return function ChatMessage(userProps) {
var _messages_, _reasoningParts_;
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, message = userProps.message, _userProps_side = userProps.side, side = _userProps_side === void 0 ? 'left' : _userProps_side, _userProps_variant = userProps.variant, variant = _userProps_variant === void 0 ? 'subtle' : _userProps_variant, _userProps_actions = userProps.actions, actions = _userProps_actions === void 0 ? [] : _userProps_actions, _userProps_autoHideActions = userProps.autoHideActions, autoHideActions = _userProps_autoHideActions === void 0 ? false : _userProps_autoHideActions, LeadingComponent = userProps.leadingComponent, ActionsComponent = userProps.actionsComponent, FooterComponent = userProps.footerComponent, TextComponent = userProps.textComponent, ReasoningComponent = userProps.reasoningComponent, indexUiState = userProps.indexUiState, setIndexUiState = userProps.setIndexUiState, userTranslations = userProps.translations, suggestionsElement = userProps.suggestionsElement, loaderElement = userProps.loaderElement, _userProps_showReasoning = userProps.showReasoning, showReasoning = _userProps_showReasoning === void 0 ? true : _userProps_showReasoning, _userProps_parseMarkdown = userProps.parseMarkdown, parseMarkdown = _userProps_parseMarkdown === void 0 ? true : _userProps_parseMarkdown, ownMessages = userProps.messages, /* eslint-disable typescript/no-deprecated -- reading the
deprecated aliases is the point: they are resolved into `context`
below so callers on the previous API keep working. */ ownStatus = userProps.status, ownTools = userProps.tools, ownOnClose = userProps.onClose, /* eslint-enable typescript/no-deprecated */ sharedContext = userProps.context, props = _object_without_properties(userProps, [
"classNames",
"message",
"side",
"variant",
"actions",
"autoHideActions",
"leadingComponent",
"actionsComponent",
"footerComponent",
"textComponent",
"reasoningComponent",
"indexUiState",
"setIndexUiState",
"translations",
"suggestionsElement",
"loaderElement",
"showReasoning",
"parseMarkdown",
"messages",
"status",
"tools",
"onClose",
"context"
]);
// Root-level overrides win over the shared context, so a caller can scope
// these to a single message. `messages` is supported going forward; the
// other three are deprecated aliases kept for callers written against the
// pre-`context` API. Resolving them into one object up front means every
// consumer below (tools, actions, text) reads consistent values.
var context = _object_spread_props(_object_spread({}, sharedContext), {
messages: ownMessages !== null && ownMessages !== void 0 ? ownMessages : sharedContext.messages,
status: ownStatus !== null && ownStatus !== void 0 ? ownStatus : sharedContext.status,
tools: ownTools !== null && ownTools !== void 0 ? ownTools : sharedContext.tools,
onClose: ownOnClose !== null && ownOnClose !== void 0 ? ownOnClose : sharedContext.onClose
});
var messages = context.messages, status = context.status, tools = context.tools;
var translations = _object_spread({
messageLabel: 'Message',
actionsLabel: 'Message actions',
toolErrorRetryText: 'Retry',
reasoningLabel: 'Reasoning'
}, userTranslations);
// A message rendered without a connector-attached store falls back to
// collecting from the conversation it was handed.
var fallbackRecords;
var getFallbackRecords = function getFallbackRecords() {
fallbackRecords = fallbackRecords || collectChatRecords(messages);
return fallbackRecords;
};
var hasLeading = Boolean(LeadingComponent);
var isCurrentMessage = messages === undefined || ((_messages_ = messages[messages.length - 1]) === null || _messages_ === void 0 ? void 0 : _messages_.id) === message.id;
var reasoningParts = showReasoning ? message.parts.reduce(function(receivedParts, part, partIndex) {
if (part.type !== 'reasoning') {
return receivedParts;
}
var isStreaming = status === 'streaming' && isCurrentMessage && isReasoningPartActive(message.parts, partIndex);
if (!isStreaming && part.text.trim().length === 0) {
return receivedParts;
}
receivedParts.push({
part: part,
partIndex: partIndex,
isStreaming: isStreaming
});
return receivedParts;
}, []) : [];
var firstReasoningPartIndex = (_reasoningParts_ = reasoningParts[0]) === null || _reasoningParts_ === void 0 ? void 0 : _reasoningParts_.partIndex;
// Keep the built-in native disclosure mounted through a temporary
// eligibility gap so its reader-owned state survives resumed reasoning.
var reasoningPartIndex = firstReasoningPartIndex !== null && firstReasoningPartIndex !== void 0 ? firstReasoningPartIndex : showReasoning && !ReasoningComponent && status === 'streaming' && isCurrentMessage ? message.parts.findIndex(function(part) {
return part.type === 'reasoning';
}) : -1;
var isReasoningStreaming = reasoningParts.some(function(part) {
return part.isStreaming;
});
// `status` is the chat's, not the row's: gating every row on it took the
// actions off completed answers the moment a follow-up turn started,
// reflowing rows the turn hasn't touched. Only the row the turn is
// producing waits for the status to settle.
var showActions = Boolean(actions.length > 0 || ActionsComponent) && (status === 'ready' || !isCurrentMessage);
var cssClasses = {
root: cx('ais-ChatMessage', "ais-ChatMessage--".concat(side), "ais-ChatMessage--".concat(variant), autoHideActions && 'ais-ChatMessage--auto-hide-actions', classNames.root),
container: cx('ais-ChatMessage-container', classNames.container),
leading: cx('ais-ChatMessage-leading', classNames.leading),
content: cx('ais-ChatMessage-content', classNames.content),
message: cx('ais-ChatMessage-message', classNames.message),
actions: cx('ais-ChatMessage-actions', classNames.actions),
footer: cx('ais-ChatMessage-footer', classNames.footer),
reasoning: cx('ais-ChatMessageReasoning', classNames.reasoning),
reasoningHeader: cx('ais-ChatMessageReasoning-header', classNames.reasoningHeader),
reasoningIcon: cx('ais-ChatMessageReasoning-icon', classNames.reasoningIcon),
reasoningLabel: cx('ais-ChatMessageReasoning-label', classNames.reasoningLabel),
reasoningChevron: cx('ais-ChatMessageReasoning-chevron', classNames.reasoningChevron),
reasoningBody: cx('ais-ChatMessageReasoning-body', classNames.reasoningBody),
reasoningText: cx('ais-ChatMessageReasoning-text', classNames.reasoningText)
};
function renderMessagePart(part, index) {
if (part.type === 'step-start') {
return null;
}
if (part.type === 'reasoning') {
// A custom component renders each step where it arrived, so the rendered
// order matches the stream. The built-in disclosure below aggregates the
// whole message into a single row, which is why only it is placed by
// index.
if (ReasoningComponent) {
var receivedPart = reasoningParts.find(function(candidate) {
return candidate.partIndex === index;
});
if (!receivedPart) {
return null;
}
return /*#__PURE__*/ createElement(Fragment, {
key: "".concat(message.id, "-reasoning-").concat(index)
}, /*#__PURE__*/ createElement(ReasoningComponent, {
part: receivedPart.part,
partIndex: index,
isStreaming: receivedPart.isStreaming,
message: message,
context: context
}));
}
if (index !== reasoningPartIndex) {
return null;
}
return /*#__PURE__*/ createElement(ChatMessageReasoning, {
key: "".concat(message.id, "-reasoning"),
parts: reasoningParts,
hidden: reasoningParts.length === 0,
parseMarkdown: parseMarkdown,
translations: translations,
classNames: _object_spread_props(_object_spread({}, cssClasses), {
reasoningIcon: cx(cssClasses.reasoningIcon, isReasoningStreaming && 'ais-ChatMessageReasoning-icon--streaming'),
reasoningLabel: cx(cssClasses.reasoningLabel, isReasoningStreaming && 'ais-ChatMessageReasoning-label--streaming')
})
});
}
if (part.type === 'text') {
if (isPartTextEmpty(part)) {
return null;
}
if (TextComponent) {
return /*#__PURE__*/ createElement(Fragment, {
key: "".concat(message.id, "-").concat(index)
}, /*#__PURE__*/ createElement(TextComponent, {
part: part,
message: message,
messages: messages,
status: status,
partIndex: index
}));
}
if (!parseMarkdown) {
// Render the literal text. The `ais-ChatMessage-text` class applies
// `white-space: pre-wrap` to preserve the newlines that markdown
// would otherwise collapse, and streaming deltas append cleanly
// because there's no parser state to get into a half-parsed entity.
// Wrapped in a `<p>` to keep some structure for screen readers
// (markdown produces semantic elements; a bare text node would not).
return /*#__PURE__*/ createElement("p", {
key: "".concat(message.id, "-").concat(index),
className: "ais-ChatMessage-text"
}, part.text);
}
var markdown = We(part.text, {
createElement: createElement,
disableParsingRawHTML: true
});
return /*#__PURE__*/ createElement("span", {
key: "".concat(message.id, "-").concat(index)
}, markdown);
}
if (startsWith(part.type, 'tool-')) {
var _tool_shouldRender;
var tool = findTool(part.type, tools);
if ((tool === null || tool === void 0 ? void 0 : (_tool_shouldRender = tool.shouldRender) === null || _tool_shouldRender === void 0 ? void 0 : _tool_shouldRender.call(tool, _object_spread_props(_object_spread({}, context), {
message: part,
parentMessage: message
}))) === false) {
return null;
}
if (tool) {
var _tool_insightsEventContext;
var ToolLayoutComponent = tool.layoutComponent;
var toolMessage = part;
var boundAddToolResult = function boundAddToolResult(params) {
return tool['~addToolResultForMessage'] ? tool['~addToolResultForMessage'](message, {
output: params.output,
tool: part.type,
toolCallId: toolMessage.toolCallId
}) : tool.addToolResult({
output: params.output,
tool: part.type,
toolCallId: toolMessage.toolCallId
});
};
if (toolMessage.state === 'input-streaming' && !tool.streamInput) {
return null;
}
if (!ToolLayoutComponent) {
if (toolMessage.state !== 'output-error') {
return null;
}
var messageIndex = messages.findIndex(function(candidate) {
return candidate.id === message.id;
});
var canRetry = tool.retryOnError === true && Boolean(tool.onToolCall) && status === 'ready' && messageIndex >= 0 && !messages.slice(messageIndex + 1).some(function(candidate) {
return candidate.role === 'user';
});
return /*#__PURE__*/ createElement("div", {
key: "".concat(message.id, "-").concat(index),
className: "ais-ChatMessage-tool ais-ChatMessage-toolError"
}, /*#__PURE__*/ createElement("span", {
className: "ais-ChatMessage-toolError-message"
}, toolMessage.errorText || 'Tool call failed.'), canRetry && /*#__PURE__*/ createElement(Button, {
variant: "primary",
size: "sm",
className: "ais-ChatMessage-toolError-action",
onClick: function onClick() {
return context.onReload(message.id);
}
}, /*#__PURE__*/ createElement(ReloadIcon, {
createElement: createElement
}), translations.toolErrorRetryText));
}
var toolSendEvent = tool.sendEvent || function() {};
var agentId = (_tool_insightsEventContext = tool.insightsEventContext) === null || _tool_insightsEventContext === void 0 ? void 0 : _tool_insightsEventContext.agentId;
var sendEvent = function sendEvent(eventType, hits, eventName, additionalData) {
if (hits === undefined && eventName === undefined && additionalData === undefined) {
return toolSendEvent(eventType);
}
return toolSendEvent(eventType, hits, eventName, _object_spread_props(_object_spread(_object_spread_props(_object_spread({}, additionalData || {}), {
queryID: 'message_' + message.id
}), agentId ? {
agentId: agentId
} : {}), {
toolCallId: toolMessage.toolCallId
}));
};
var toolContext = _object_spread_props(_object_spread({}, context), {
records: tool.records || getFallbackRecords(),
message: toolMessage,
insightsEventContext: tool.insightsEventContext,
indexUiState: indexUiState,
setIndexUiState: setIndexUiState,
addToolResult: boundAddToolResult,
applyFilters: tool.applyFilters,
sendEvent: sendEvent
});
return /*#__PURE__*/ createElement("div", {
key: "".concat(message.id, "-").concat(index),
className: "ais-ChatMessage-tool"
}, /*#__PURE__*/ createElement(ToolLayoutComponent, _object_spread_props(_object_spread({}, getDeprecatedToolRootProps(toolContext)), {
context: toolContext
})));
}
}
return null;
}
var renderedParts = message.parts.map(renderMessagePart);
var hasRenderedParts = renderedParts.some(function(part) {
return part != null;
});
if (!hasRenderedParts && !loaderElement && !(ActionsComponent && showActions) && !FooterComponent) {
return suggestionsElement !== null && suggestionsElement !== void 0 ? suggestionsElement : null;
}
return /*#__PURE__*/ createElement("article", _object_spread_props(_object_spread({}, props), {
className: cx(cssClasses.root, props.className),
"aria-label": translations.messageLabel
}), /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.container)
}, hasLeading && /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.leading)
}, LeadingComponent && /*#__PURE__*/ createElement(LeadingComponent, null)), /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.content)
}, /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.message)
}, renderedParts, loaderElement), suggestionsElement, showActions && /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.actions),
"aria-label": translations.actionsLabel
}, ActionsComponent ? /*#__PURE__*/ createElement(ActionsComponent, {
actions: actions,
message: message,
context: context
}) : actions.map(function(action, index) {
return /*#__PURE__*/ createElement(Button, {
key: index,
variant: "ghost",
size: "sm",
iconOnly: true,
className: "ais-ChatMessage-action",
disabled: action.disabled,
"aria-label": action.title,
onClick: function onClick() {
var _action_onClick;
return (_action_onClick = action.onClick) === null || _action_onClick === void 0 ? void 0 : _action_onClick.call(action, message);
}
}, action.icon ? /*#__PURE__*/ createElement(action.icon, null) : /*#__PURE__*/ createElement(MenuIcon, {
createElement: createElement
}));
})), FooterComponent && /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.footer)
}, /*#__PURE__*/ createElement(FooterComponent, null)))));
};
}
function createChatMessageErrorComponent(param) {
var createElement = param.createElement;
var Button = createButtonComponent({
createElement: createElement
});
return function ChatMessageError(userProps) {
var _ref, _ref1;
var errorMessage = userProps.errorMessage, onReload = userProps.onReload, onNewConversation = userProps.onNewConversation, actions = userProps.actions, userTranslations = userProps.translations;
userProps.context;
var props = _object_without_properties(userProps, [
"errorMessage",
"onReload",
"onNewConversation",
"actions",
"translations",
"context"
]);
var defaultErrorMessage = 'Sorry, we are not able to generate a response at the moment. Please contact support.';
var defaultNewConversationText = 'Start a new conversation';
var defaultRetryText = 'Retry';
var errorMessageTranslation = userTranslations === null || userTranslations === void 0 ? void 0 : userTranslations.errorMessage;
var resolvedErrorMessage = typeof errorMessageTranslation === 'function' ? errorMessageTranslation({
errorMessage: errorMessage
}) : errorMessageTranslation !== null && errorMessageTranslation !== void 0 ? errorMessageTranslation : defaultErrorMessage;
var newConversationText = (_ref = userTranslations === null || userTranslations === void 0 ? void 0 : userTranslations.newConversationText) !== null && _ref !== void 0 ? _ref : defaultNewConversationText;
var retryText = (_ref1 = userTranslations === null || userTranslations === void 0 ? void 0 : userTranslations.retryText) !== null && _ref1 !== void 0 ? _ref1 : defaultRetryText;
// Action precedence:
// 1. `actions` (full custom)
// 2. `onNewConversation` (recommended for permanent / guardrail errors)
// 3. `onReload` (legacy retry, suitable for transient failures)
// 4. nothing
var hasCustomActions = Boolean(actions);
var showNewConversation = !hasCustomActions && Boolean(onNewConversation);
var showRetry = !hasCustomActions && !showNewConversation && Boolean(onReload);
var hasActions = hasCustomActions || showNewConversation || showRetry;
return /*#__PURE__*/ createElement("article", _object_spread({
className: "ais-ChatMessageError ais-ChatMessage ais-ChatMessage--left ais-ChatMessage--subtle"
}, props), /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessage-container"
}, /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessage-content"
}, /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessage-message"
}, resolvedErrorMessage), hasActions && /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessage-actions"
}, hasCustomActions ? actions.map(function(action, index) {
return /*#__PURE__*/ createElement(Button, _object_spread({
key: index,
variant: "ghost",
className: "ais-ChatMessage-action"
}, action), action.children);
}) : showNewConversation ? /*#__PURE__*/ createElement(Button, {
variant: "primary",
size: "md",
className: "ais-ChatMessage-errorAction",
onClick: function onClick() {
return onNewConversation === null || onNewConversation === void 0 ? void 0 : onNewConversation();
}
}, newConversationText) : /*#__PURE__*/ createElement(Button, {
variant: "primary",
size: "md",
className: "ais-ChatMessage-errorAction",
onClick: function onClick() {
return onReload === null || onReload === void 0 ? void 0 : onReload();
}
}, /*#__PURE__*/ createElement(ReloadIcon, {
createElement: createElement
}), retryText)))));
};
}
function createChatMessageLoaderComponent(param) {
var createElement = param.createElement;
return function ChatMessageLoader(userProps) {
var userTranslations = userProps.translations, _userProps_inline = userProps.inline, inline = _userProps_inline === void 0 ? false : _userProps_inline, className = userProps.className; // The turn context is for custom loaders, not for the DOM.
userProps.context;
var props = _object_without_properties(userProps, [
"translations",
"inline",
"className",
"context"
]);
var translations = _object_spread({
loaderText: ''
}, userTranslations);
var spinner = /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessageLoader-spinner"
}, /*#__PURE__*/ createElement(LoadingSpinnerIcon, {
createElement: createElement
}));
var body = /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessage-message"
}, translations.loaderText && /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessageLoader-text"
}, translations.loaderText), /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessageLoader-skeletonWrapper"
}, /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessageLoader-skeletonItem"
}), /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessageLoader-skeletonItem"
})));
if (inline) {
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-ChatMessageLoader', 'ais-ChatMessageLoader--inline', className)
}), spinner, body);
}
return /*#__PURE__*/ createElement("article", _object_spread_props(_object_spread({}, props), {
className: cx('ais-ChatMessageLoader ais-ChatMessage ais-ChatMessage--left ais-ChatMessage--subtle', className)
}), /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessage-container"
}, /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessage-leading"
}, spinner), /*#__PURE__*/ createElement("div", {
className: "ais-ChatMessage-content"
}, body)));
};
}
var copyToClipboard = function copyToClipboard(message) {
navigator.clipboard.writeText(getTextContent(message));
};
var DEFAULT_LOADER_SHOW_DELAY = 250;
// Short enough that it never lingers over the content that replaced it.
var DEFAULT_LOADER_MIN_DURATION = 200;
function getInstantSearchStatus(tools) {
var _Object_values_find_insightsEventContext, _Object_values_find;
return (_Object_values_find = Object.values(tools).find(function(tool) {
return tool.insightsEventContext;
})) === null || _Object_values_find === void 0 ? void 0 : (_Object_values_find_insightsEventContext = _Object_values_find.insightsEventContext) === null || _Object_values_find_insightsEventContext === void 0 ? void 0 : _Object_values_find_insightsEventContext.instantSearchStatus;
}
// Own-key presence is what a JSX spread copies; `in` would also answer for
// inherited keys the spread leaves behind.
var hasOwnKey = function hasOwnKey(target, key) {
return target !== undefined && Object.prototype.hasOwnProperty.call(target, key);
};
function createDefaultMessageComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
var ChatMessage = createChatMessageComponent({
createElement: createElement,
Fragment: Fragment
});
return function DefaultMessage(param) {
var message = param.message, userMessageProps = param.userMessageProps, assistantMessageProps = param.assistantMessageProps, indexUiState = param.indexUiState, setIndexUiState = param.setIndexUiState, onReload = param.onReload, onFeedback = param.onFeedback, feedbackState = param.feedbackState, actionsComponent = param.actionsComponent, classNames = param.classNames, messageTranslations = param.messageTranslations, translations = param.translations, suggestionsElement = param.suggestionsElement, loaderElement = param.loaderElement, context = param.context;
var defaultAssistantActions = _to_consumable_array(hasTextContent(message) ? [
{
title: translations.copyToClipboardLabel,
icon: function icon() {
return /*#__PURE__*/ createElement(CopyIcon, {
createElement: createElement
});
},
onClick: copyToClipboard
}
] : []).concat([
{
title: translations.regenerateLabel,
icon: function icon() {
return /*#__PURE__*/ createElement(ReloadIcon, {
createElement: createElement
});
},
onClick: function onClick(m) {
return onReload(m.id);
}
}
]);
var messageFeedback = feedbackState === null || feedbackState === void 0 ? void 0 : feedbackState[message.id];
var hasVoted = messageFeedback !== undefined;
if (onFeedback) {
var isSending = messageFeedback === 'sending';
if (isSending) {
defaultAssistantActions.push({
title: translations.sendingFeedbackLabel,
icon: function icon() {
return /*#__PURE__*/ createElement("span", {
className: "ais-ChatMessage-feedbackSpinner"
}, /*#__PURE__*/ createElement(LoadingSpinnerIcon, {
createElement: createElement
}));
},
disabled: true
});
} else if (hasVoted) {
defaultAssistantActions.push({
title: translations.feedbackThankYouText,
icon: function icon() {
return /*#__PURE__*/ createElement("span", {
className: "ais-ChatMessage-feedbackCheck"
}, /*#__PURE__*/ createElement(CheckIcon, {
createElement: createElement
}), /*#__PURE__*/ createElement("span", {
className: "ais-ChatMessage-feedbackText"
}, translations.feedbackThankYouText));
},
disabled: true
});
} else {
defaultAssistantActions.push({
title: translations.thumbsUpLabel,
icon: function icon() {
return /*#__PURE__*/ createElement(ThumbsUpIcon, {
createElement: createElement
});
},
onClick: function onClick(m) {
return onFeedback(m.id, 1);
}
}, {
title: translations.thumbsDownLabel,
icon: function icon() {
return /*#__PURE__*/ createElement(ThumbsDownIcon, {
createElement: createElement
});
},
onClick: function onClick(m) {
return onFeedback(m.id, 0);
}
});
}
}
var messageProps = message.role === 'user' ? userMessageProps : assistantMessageProps;
var defaultActions = message.role === 'user' ? undefined : defaultAssistantActions;
return /*#__PURE__*/ createElement(ChatMessage, _object_spread_props(_object_spread({
side: message.role === 'user' ? 'right' : 'left',
variant: message.role === 'user' ? 'neutral' : 'subtle',
indexUiState: indexUiState,
setIndexUiState: setIndexUiState,
actions: defaultActions,
actionsComponent: actionsComponent,
"data-role": message.role,
classNames: classNames,
translations: messageTranslations,
suggestionsElement: suggestionsElement,
loaderElement: loaderElement,
context: context
}, messageProps), {
message: message,
messages: context.messages
}));
};
}
function createChatMessagesComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment, useMemo = param.useMemo, useState = param.useState, useEffect = param.useEffect;
var Button = createButtonComponent({
createElement: createElement
});
/**
* Smooths the loading state into a visibility. Several transitions in a turn
* flip it twice within a few frames, which reads as the loader popping in and
* out, so a loader coming back mid-turn waits out `showDelay` and a visible
* one holds for `minDuration`.
*/ function useLoaderVisibility(param) {
var isLoading = param.isLoading, isTurnActive = param.isTurnActive, showDelay = param.showDelay, minDuration = param.minDuration;
var _useState = _sliced_to_array(useState({
phase: 'idle'
}), 2), loaderState = _useState[0], setLoaderState = _useState[1];
var isVisible = isTurnActive && (isLoading && (loaderState.phase === 'idle' || loaderState.phase === 'ready' || loaderState.phase === 'hidden' && showDelay <= 0) || loaderState.phase === 'visible' && (isLoading || minDuration > loaderState.elapsedDuration));
useEffect(function() {
if (!isTurnActive) {
if (loaderState.phase !== 'idle') {
setLoaderState({
phase: 'idle'
});
}
return undefined;
}
if (loaderState.phase === 'idle') {
if (isLoading) {
setLoaderState({
phase: 'visible',
shownAt: Date.now(),
elapsedDuration: 0
});
}
return undefined;
}
if (loaderState.phase === 'visible') {
if (!isLoading && minDuration <= loaderState.elapsedDuration) {
setLoaderState({
phase: 'hidden'
});
return undefined;
}
if (minDuration <= loaderState.elapsedDuration) {
return undefined;
}
var remaining = Math.max(0, loaderState.shownAt + minDuration - Date.now());
if (remaining === 0) {
setLoaderState(_object_spread_props(_object_spread({}, loaderState), {
elapsedDuration: minDuration
}));
return undefined;
}
var timer = setTimeout(function() {
setLoaderState(function(current) {
return current.phase === 'visible' && current.shownAt === loaderState.shownAt ? _object_spread_props(_object_spread({}, current), {
elapsedDuration: Math.max(current.elapsedDuration, minDuration)
}) : current;
});
}, remaining);
return function() {
return clearTimeout(timer);
};
}
if (loaderState.phase === 'hidden') {
if (isLoading) {
var now = Date.now();
setLoaderState(showDelay <= 0 ? {
phase: 'visible',
shownAt: now,
elapsedDuration: 0
} : {
phase: 'waiting',
pendingSince: now
});
}
return undefined;
}
if (loaderState.phase === 'ready') {
setLoaderState(isLoading ? {
phase: 'visible',
shownAt: loaderState.shownAt,
elapsedDuration: loaderState.elapsedDuration
} : {
phase: 'hidden'
});
return undefined;
}
if (!isLoading) {
setLoaderState({
phase: 'hidden'
});
return undefined;
}
var remaining1 = Math.max(0, loaderState.pendingSince + showDelay - Date.now());
if (remaining1 === 0) {
setLoaderState({
phase: 'visible',
shownAt: Date.now(),
elapsedDuration: 0
});
return undefined;
}
var timer1 = setTimeout(function() {
setLoaderState(function(current) {
return current.phase === 'waiting' && current.pendingSince === loaderState.pendingSince ? {
phase: 'ready',
shownAt: Date.now(),
elapsedDuration: 0
} : current;
});
}, remaining1);
return function() {
return clearTimeout(timer1);
};
}, [
isLoading,
isTurnActive,
loaderState,
minDuration,
showDelay
]);
return isVisible;
}
var DefaultMessageComponent = createDefaultMessageComponent({
createElement: createElement,
Fragment: Fragment
});
// Skip re-rendering (and re-compiling the markdown of) completed messages on
// every streaming delta. The deps tuple matches the row's render inputs;
// callbacks/`indexUiState` are intentionally excluded because `getUiState()`
// returns a fresh object every render and would defeat the memo — completed
// rows keep the callbacks/`indexUiState` they last rendered with until their
// next genuine update.
function MemoizedDefaultMessage(props) {
var _props_feedbackState;
var messageFeedback = (_props_feedbackState = props.feedbackState) === null || _props_feedbackState === void 0 ? void 0 : _props_feedbackState[props.message.id];
var instantSearchStatus = getInstantSearchStatus(props.context.tools);
// Read the row's own side, mirroring `DefaultMessage`, so one role's change
// neither invalidates the other's completed rows nor goes unnoticed here.
var messageProps = props.message.role === 'user' ? props.userMessageProps : props.assistantMessageProps;
var showReasoning = (messageProps === null || messageProps === void 0 ? void 0 : messageProps.showReasoning) !== false;
var parseMarkdown = messageProps === null || messageProps === void 0 ? void 0 : messageProps.parseMarkdown;
var textComponent = messageProps === null || messageProps === void 0 ? void 0 : messageProps.textComponent;
var reasoningComponent = messageProps === null || messageProps === void 0 ? void 0 : messageProps.reasoningComponent;
// A completed row is memoized against its own message, but `shouldRender`
// reads the whole `context`: a predicate can hide an older tool result once a
// newer message arrives. Track the verdicts themselves rather than
// `context.messages`, so the row re-renders exactly when one flips instead of
// on every streaming delta.
var shouldRenderVerdicts = getShouldRenderVerdicts(props.context, props.message);
// Custom text components receive the conversation, so their completed rows
// must update with it. Keep the default renderer's streaming optimization.
var textComponentMessages = textComponent ? props.context.messages : undefined;
// A custom reasoning component receives the full context, but completed
// rows only need to update for its semantic state, so the memo tracks those
// fields rather than `props.context`. The context's callback identities and
// its scroll-only changes stay out. `reasoningComponent` is tracked, so
// replacing the component still takes effect.
var reasoningComponentMessages = reasoningComponent ? props.context.messages : undefined;
var reasoningComponentStatus = reasoningComponent ? props.context.status : undefined;
var reasoningComponentError = reasoningComponent ? props.context.error : undefined;
var reasoningComponentIsClearing = reasoningComponent ? props.context.isClearing : undefined;
var reasoningComponentActivePart = reasoningComponent ? props.context.activePart : undefined;
var reasoningComponentTools = reasoningComponent ? props.context.tools : undefined;
// Object-level fallback, matching the render: the spread replaces
// `translations` wholesale, and it copies a key holding `undefined` too. Both
// are why this resolves by own-key presence rather than key by key.
var reasoningTranslations = hasOwnKey(messageProps, 'translations') ? messageProps === null || messageProps === void 0 ? void 0 : messageProps.translations : props.messageTranslations;
var reasoningLabel = reasoningTranslations === null || reasoningTranslations === void 0 ? void 0 : reasoningTranslations.reasoningLabel;
var reasoningClassNames = hasOwnKey(messageProps, 'classNames') ? messageProps === null || messageProps === void 0 ? void 0 : messageProps.classNames : props.classNames;
var reasoningClassName = cx(reasoningClassNames === null || reasoningClassNames === void 0 ? void 0 : reasoningClassNames.reasoning);
var reasoningHeaderClassName = cx(reasoningClassNames === null || reasoningClassNames === void 0 ? void 0 : reasoningClassNames.reasoningHeader);
var reasoningIconClassName = cx(reasoningClassNames === null || reasoningClassNames === void 0 ? void 0 : reasoningClassNames.reasoningIcon);
var reasoningLabelClassName = cx(reasoningClassNames === null || reasoningClassNames === void 0 ? void 0 : reasoningClassNames.reasoningLabel);
var reasoningChevronClassName = cx(reasoningClassNames === null || reasoningClassNames === void 0 ? void 0 : reasoningClassNames.reasoningChevron);
var reasoningBodyClassName = cx(reasoningClassNames === null || reasoningClassNames === void 0 ? void 0 : reasoningClassNames.reasoningBody);
var reasoningTextClassName = cx(reasoningClassNames === null || reasoningClassNames === void 0 ? void 0 : reasoningClassNames.reasoningText);
// The row comparator. The full props object would recompile every completed
// message on each streaming update, and `props.context` is a fresh object
// every render — so track the specific context fields a completed row can
// render from (panel display state read by tool components) rather than the
// object itself, which would defeat the memo.
return useMemo(function() {
return /*#__PURE__*/ createElement(DefaultMessageComponent, props);
}, [
props.message,
props.isCurrentMessage,
props.status,
shouldRenderVerdicts,
props.context.maximized,
props.context.open,
instantSearchStatus,
props.suggestionsElement,
props.loaderElement,
messageFeedback,
showReasoning,
parseMarkdown,
textComponent,
textComponentMessages,
reasoningComponent,
reasoningComponentMessages,
reasoningComponentStatus,
reasoningComponentError,
reasoningComponentIsClearing,
reasoningComponentActivePart,
reasoningComponentTools,
reasoningLabel,
reasoningClassName,
reasoningHeaderClassName,
reasoningIconClassName,
reasoningLabelClassName,
reasoningChevronClassName,
reasoningBodyClassName,
reasoningTextClassName
]);
}
var DefaultLoaderComponent = createChatMessageLoaderComponent({
createElement: createElement
});
var DefaultErrorComponent = createChatMessageErrorComponent({
createElement: createElement
});
return function ChatMessages(userProps) {
var _ref;
var _lastMessage_parts, _lastMessage_parts1;
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, _userProps_messageClassNames = userProps.messageClassNames, messageClassNames = _userProps_messageClassNames === void 0 ? {} : _userProps_messageClassNames, messageTranslations = userProps.messageTranslations, _userProps_messages = userProps.messages, messages = _userProps_messages === void 0 ? [] : _userProps_messages, MessageComponent = userProps.messageComponent, LoaderComponent = userProps.loaderComponent, _userProps_loaderPosition = userProps.loaderPosition, loaderPosition = _userProps_loaderPosition === void 0 ? 'messages-end' : _userProps_loaderPosition, shouldShowLoader = userProps.shouldShowLoader, _userProps_loaderShowDelay = userProps.loaderShowDelay, loaderShowDelay = _userProps_loaderShowDelay === void 0 ? DEFAULT_LOADER_SHOW_DELAY : _userProps_loaderShowDelay, _userProps_loaderMinDuration = userProps.loaderMinDuration, loaderMinDuration = _userProps_loaderMinDuration === void 0 ? DEFAULT_LOADER_MIN_DURATION : _userProps_loaderMinDuration, ErrorComponent = userProps.errorComponent, EmptyComponent = userProps.emptyComponent, ActionsComponent = userProps.actionsComponent, tools = userProps.tools, indexUiState = userProps.indexUiState, setIndexUiState = userProps.setIndexUiState, _userProps_status = userProps.status, status = _userProps_status === void 0 ? 'ready' : _userProps_status, error = userProps.error, _userProps_hideScrollToBottom = userProps.hideScrollToBottom, hideScrollToBottom = _userProps_hideScrollToBottom === void 0 ? false : _userProps_hideScrollToBottom, onReload = userProps.onReload, onNewConversation = userProps.onNewConversation, onClose = userProps.onClose, sendMessage = userProps.sendMessage, _userProps_regenerate = userProps.regenerate, regenerate = _userProps_regenerate === void 0 ? function() {
return Promise.resolve();
} : _userProps_regenerate, _userProps_stop = userProps.stop, stop = _userProps_stop === void 0 ? function() {
return Promise.resolve();
} : _userProps_stop, _userProps_open = userProps.open, open = _userProps_open === void 0 ? false : _userProps_open, _userProps_maximized = userProps.maximized, maximized = _userProps_maximized === void 0 ? false : _userProps_maximized, setInput = userProps.setInput, userTranslations = userProps.translations, userMessageProps = userProps.userMessageProps, assistantMessageProps = userProps.assistantMessageProps, _userProps_isClearing = userProps.isClearing, isClearing = _userProps_isClearing === void 0 ? false : _userProps_isClearing, onClearTransitionEnd = userProps.onClearTransitionEnd, isScrollAtBottom = userProps.isScrollAtBottom, scrollRef = userProps.scrollRef, contentRef = userProps.contentRef, onScrollToBottom = userProps.onScrollToBottom, suggestionsElement = userProps.suggestionsElement, onFeedback = userProps.onFeedback, feedbackState = userProps.feedbackState, props = _object_without_properties(userProps, [
"classNames",
"messageClassNames",
"messageTranslations",
"messages",
"messageComponent",
"loaderComponent",
"loaderPosition",
"shouldShowLoader",
"loaderShowDelay",
"loaderMinDuration",
"errorComponent",
"emptyComponent",
"actionsComponent",
"tools",
"indexUiState",
"setIndexUiState",
"status",
"error",
"hideScrollToBottom",
"onReload",
"onNewConversation",
"onClose",
"sendMessage",
"regenerate",
"stop",
"open",
"maximized",
"setInput",
"translations",
"userMessageProps",
"assistantMessageProps",
"isClearing",
"onClearTransitionEnd",
"isScrollAtBottom",
"scrollRef",
"contentRef",
"onScrollToBottom",
"suggestionsElement",
"onFeedback",
"feedbackState"
]);
var translations = _object_spread({
scrollToBottomLabel: 'Scroll to bottom',
copyToClipboardLabel: 'Copy to clipboard',
regenerateLabel: 'Regenerate',
thumbsUpLabel: 'Like',
thumbsDownLabel: 'Dislike',
feedbackThankYouText: 'Thanks for your feedback!',
sendingFeedbackLabel: 'Sending feedback...'
}, userTranslations);
var cssClasses = {
root: cx('ais-ChatMessages', classNames.root),
scroll: cx('ais-ChatMessages-scroll ais-Scrollbar', classNames.scroll),
content: cx('ais-ChatMessages-content', classNames.content),
scrollToBottom: cx('ais-ChatMessages-scrollToBottom', classNames.scrollToBottom),
scrollToBottomHidden: cx('ais-ChatMessages-scrollToBottom--hidden', classNames.scrollToBottomHidden)
};
var lastMessage = messages[messages.length - 1];
var showReasoning = (assistantMessageProps === null || assistantMessageProps === void 0 ? void 0 : assistantMessageProps.showReasoning) !== false;
var lastPart = lastMessage === null || lastMessage === void 0 ? void 0 : (_lastMessage_parts = lastMessage.parts) === null || _lastMessage_parts === void 0 ? void 0 : _lastMessage_parts[lastMessage.parts.length - 1];
// `activePart` means "the part currently being processed". It must clear
// when nothing is in progress: once the response settles (`ready`/`error`),
// and while `submitted` still shows the user's own message (the assistant
// hasn't produced a part yet). Otherwise overrides render a part that isn't
// actually streaming.
var isProcessing = status === 'submitted' || status === 'streaming';
var activePart = isProcessing && (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) === 'assistant' ? lastPart : undefined;
// The scan slices the remaining parts per candidate, and only the loader reads
// it, so skip it entirely once `showReasoning` is off.
// The loader reports on the assistant's turn, so it only ever belongs to an
// assistant message. While `submitted` the last message is still the user's
// own, and the loader belongs to no message at all.
var loaderMessage = (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) === 'assistant' ? lastMessage : undefined;
var hasActiveReasoning = showReasoning ? (_ref = lastMessage === null || lastMessage === void 0 ? void 0 : (_lastMessage_parts1 = lastMessage.parts) === null || _lastMessage_parts1 === void 0 ? void 0 : _lastMessage_parts1.some(function(_, index, parts) {
return isReasoningPartActive(parts, index);
})) !== null && _ref !== void 0 ? _ref : false : false;
// The shared context handed to every overridable chat component, so custom
// components can read the current chat state and common callbacks from a
// single, consistent place.
var context = {
messages: messages,
status: status,
error: error,
isClearing: isClearing,
open: open,
maximized: maximized,
activePart: activePart,
tools: tools,
sendMessage: sendMessage,
regenerate: regenerate,
stop: stop,
setInput: setInput,
onReload: onReload,
onNewConversation: onNewConversation,
onClose: onClose
};
// The loader also reads what the turn is doing, which no other component
// needs, so its context extends the shared one.
var loaderContext = _object_spread_props(_object_spread({}, context), {
phase: getLoaderPhase(status, loaderMessage, showReasoning),
message: loaderMessage
});
var defaultShowLoader = getShowLoader(context, showReasoning, hasActiveReasoning);
var isLoading = shouldShowLoader ? shouldShowLoader(_object_spread_props(_object_spread({}, loaderContext), {
defaultValue: defaultShowLoader
})) : defaultShowLoader;
var showLoader = useLoaderVisibility({
isLoading: isLoading,
isTurnActive: isProcessing,
showDelay: loaderShowDelay,
minDuration: loaderMinDuration
});
var showEmpty = messages.length === 0 && !showLoader && !isClearing && status !== 'error';
var DefaultMessage = MessageComponent || MemoizedDefaultMessage;
var DefaultLoader = LoaderComponent || DefaultLoaderComponent;
var DefaultError = ErrorComponent || DefaultErrorComponent;
// An inline loader needs an assistant message to live in; before the first
// response part there is none, so it falls back to its own row.
var isLoaderInline = loaderPosition === 'message-inline' && loaderMessage !== undefined;
var loaderText = typeof translations.loaderText === 'function' ? translations.loaderText(loaderContext) : translations.loaderText;
var loaderElement = showLoader ? /*#__PURE__*/ createElement(DefaultLoader, {
context: loaderContext,
inline: isLoaderInline,
translations: {
loaderText: loaderText
}
}) : undefined;
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx(cssClasses.root, props.className),
role: "log",
"aria-live": "polite",
"aria-busy": isProcessing ? 'true' : undefined
}), /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.scroll),
ref: scrollRef
}, /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.content, isClearing && 'ais-ChatMessages-content--clearing'),
ref: contentRef,
onTransitionEnd: function onTransitionEnd(e) {
if (e.target === e.currentTarget && e.propertyName === 'opacity' && isClearing) {
onClearTransitionEnd === null || onClearTransitionEnd === void 0 ? void 0 : onClearTransitionEnd();
}
}
}, showEmpty && EmptyComponent && /*#__PURE__*/ createElement(EmptyComponent, {
// Deprecated root-level props, kept alongside `context` for
// empty/greeting components written against the previous API.
// Remove in the next major.
sendMessage: sendMessage,
setInput: setInput,
status: status,
onClose: onClose,
context: context
}), messages.map(function(message, index) {
return /*#__PURE__*/ createElement(DefaultMessage, {
key: message.id,
message: message,
isCurrentMessage: index === messages.length - 1,
status: status,
userMessageProps: userMessageProps,
assistantMessageProps: assistantMessageProps,
indexUiState: indexUiState,
setIndexUiState: setIndexUiState,
onReload: onReload,
onFeedback: onFeedback,
feedbackState: feedbackState,
actionsComponent: ActionsComponent,
translations: translations,
classNames: messageClassNames,
messageTranslations: messageTranslations,
context: context,
suggestionsElement: status === 'ready' && message.role === 'assistant' && index === messages.length - 1 ? suggestionsElement : undefined,
loaderElement: isLoaderInline && index === messages.length - 1 ? loaderElement : undefined
});
}), !isLoaderInline && loaderElement, status === 'error' && /*#__PURE__*/ createElement(DefaultError, {
onNewConversation: onNewConversation,
errorMessage: error === null || error === void 0 ? void 0 : error.message,
translations: // `fallbackResponse` that's safe to display verbatim; for
// every other error we keep hiding the raw `error.message`
// behind the friendly default. Detection is by `error.name`
// to avoid coupling this package to `instantsearch.js`.
(error === null || error === void 0 ? void 0 : error.name) === 'GuardrailViolationError' ? {
errorMessage: function errorMessage(param) {
var rawMessage = param.errorMessage;
return rawMessage !== null && rawMessage !== void 0 ? rawMessage : '';
}
} : undefined,
context: context
}))), /*#__PURE__*/ createElement(Button, {
variant: "outline",
size: "sm",
iconOnly: true,
className: cx(cssClasses.scrollToBottom, (hideScrollToBottom || isScrollAtBottom) && cssClasses.scrollToBottomHidden),
onClick: onScrollToBottom,
"aria-label": translations.scrollToBottomLabel,
tabIndex: isScrollAtBottom ? -1 : 0
}, /*#__PURE__*/ createElement(ChevronDownIcon, {
createElement: createElement
})));
};
}
var getLoaderPhase = function getLoaderPhase(status, message, showReasoning) {
if (status === 'submitted') return 'submitted';
var lastPart = findLastProgressPart(message === null || message === void 0 ? void 0 : message.parts);
if (!lastPart) return 'thinking';
if (isPartTool(lastPart)) return 'tool';
if (showReasoning && lastPart.type === 'reasoning') return 'reasoning';
return 'thinking';
};
/**
* A stable signature of every `shouldRender` verdict in a message, so a memoized
* row can be invalidated when a verdict changes. `undefined` when no tool part
* in the message declares the predicate.
*/ var getShouldRenderVerdicts = function getShouldRenderVerdicts(context, message) {
var _message_parts;
var verdicts;
(_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.forEach(function(part, index) {
var _findTool;
if (!isPartTool(part)) {
return;
}
var shouldRender = (_findTool = findTool(part.type, context.tools)) === null || _findTool === void 0 ? void 0 : _findTool.shouldRender;
if (!shouldRender) {
return;
}
verdicts = "".concat(verdicts !== null && verdicts !== void 0 ? verdicts : '').concat(index, ":").concat(shouldRender(_object_spread_props(_object_spread({}, context), {
message: part,
parentMessage: message
})), ";");
});
return verdicts;
};
var getShowLoader = function getShowLoader(context, showReasoning, hasActiveReasoning) {
var status = context.status, messages = context.messages, tools = context.tools;
if (status !== 'submitted' && status !== 'streaming') return false;
if (status === 'submitted') return true;
var lastMessage = messages[messages.length - 1];
// `processStream` sets `streaming` before the `start` chunk pushes the
// assistant. Until then the last message is still the user's, and its text
// must not be read as the answer or the loader hides and comes back.
if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) !== 'assistant') return true;
// Parts that render nothing must not answer for the turn's progress, or the
// loader flips on a part that changed nothing on screen.
var lastPart = findLastProgressPart(lastMessage.parts);
if (!lastPart) return true;
// An active disclosure carries its own progress affordance, so the loader would
// double it. Settled reasoning still shows it: the answer has not started.
if (showReasoning && hasActiveReasoning) return false;
if (isPartText(lastPart)) return false;
if (isPartTool(lastPart)) {
var _tool_shouldRender;
var tool = findTool(lastPart.type, tools);
// A part the tool declines to render leaves nothing on screen, so the turn
// still reads as in progress — keep the loader up rather than letting a
// settled-but-hidden part terminate it.
if (lastMessage && (tool === null || tool === void 0 ? void 0 : (_tool_shouldRender = tool.shouldRender) === null || _tool_shouldRender === void 0 ? void 0 : _tool_shouldRender.call(tool, _object_spread_props(_object_spread({}, context), {
message: lastPart,
parentMessage: lastMessage
}))) === false) {
return true;
}
if (lastPart.state === 'input-streaming') {
return !(tool === null || tool === void 0 ? void 0 : tool.streamInput);
}
}
return true;
};
function createChatOverlayLayoutComponent(param) {
var createElement = param.createElement;
return function ChatOverlayLayout(userProps) {
var open = userProps.open, maximized = userProps.maximized, headerComponent = userProps.headerComponent, messagesComponent = userProps.messagesComponent, promptComponent = userProps.promptComponent, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, className = userProps.className; // Chat state props (destructured to avoid spreading on div)
userProps.messages;
userProps.status;
userProps.isClearing;
userProps.clearMessages;
userProps.onClearTransitionEnd;
userProps.suggestions;
userProps.tools;
userProps.sendMessage;
userProps.regenerate;
userProps.stop;
userProps.error;
var rest = _object_without_properties(userProps, [
"open",
"maximized",
"headerComponent",
"messagesComponent",
"promptComponent",
"classNames",
"className",
"messages",
"status",
"isClearing",
"clearMessages",
"onClearTransitionEnd",
"suggestions",
"tools",
"sendMessage",
"regenerate",
"stop",
"error"
]);
// React versions before 19 preserve unknown boolean attributes as numbers.
var inert = open ? undefined : 1;
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, rest), {
className: cx('ais-Chat', 'ais-ChatOverlayLayout', maximized && 'ais-ChatOverlayLayout--maximized', classNames.root, className)
}), /*#__PURE__*/ createElement("div", {
inert: inert,
className: cx('ais-Chat-container', open && 'ais-Chat-container--open', maximized && 'ais-Chat-container--maximized', classNames.container)
}, headerComponent, messagesComponent, promptComponent));
};
}
function createChatPromptComponent(param) {
var createElement = param.createElement;
var Button = createButtonComponent({
createElement: createElement
});
var textAreaElement = null;
var lineHeight = 0;
var padding = 0;
var adjustHeight = function adjustHeight() {
if (!textAreaElement) return;
textAreaElement.style.height = 'auto';
var fullHeight = textAreaElement.scrollHeight;
if (textAreaElement.getAttribute('data-max-rows')) {
var maxRows = parseInt(textAreaElement.getAttribute('data-max-rows') || '0', 10);
if (maxRows > 0) {
var maxHeight = maxRows * lineHeight + padding;
textAreaElement.style.overflowY = fullHeight > maxHeight ? 'auto' : 'hidden';
textAreaElement.style.height = "".concat(Math.min(fullHeight, maxHeight), "px");
return;
}
}
textAreaElement.style.overflowY = 'hidden';
textAreaElement.style.height = "".concat(fullHeight, "px");
};
var setTextAreaRef = function setTextAreaRef(element, promptRef) {
textAreaElement = element;
if (promptRef) {
promptRef.current = element;
}
if (element) {
var styles = getComputedStyle(element);
lineHeight = parseFloat(styles.lineHeight);
var pt = parseFloat(styles.paddingTop);
var pb = parseFloat(styles.paddingBottom);
padding = pt + pb;
adjustHeight();
}
};
return function ChatPrompt(userProps) {
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, HeaderComponent = userProps.headerComponent, FooterComponent = userProps.footerComponent, value = userProps.value, placeholder = userProps.placeholder, _userProps_status = userProps.status, status = _userProps_status === void 0 ? 'ready' : _userProps_status, _userProps_disabled = userProps.disabled, disabled = _userProps_disabled === void 0 ? false : _userProps_disabled, _userProps_maxRows = userProps.maxRows, maxRows = _userProps_maxRows === void 0 ? 5 : _userProps_maxRows, _userProps_autoFocus = userProps.autoFocus, autoFocus = _userProps_autoFocus === void 0 ? true : _userProps_autoFocus, userTranslations = userProps.translations, onInput = userProps.onInput, onSubmit = userProps.onSubmit, onKeyDown = userProps.onKeyDown, onStop = userProps.onStop, promptRef = userProps.promptRef, props = _object_without_properties(userProps, [
"classNames",
"headerComponent",
"footerComponent",
"value",
"placeholder",
"status",
"disabled",
"maxRows",
"autoFocus",
"translations",
"onInput",
"onSubmit",
"onKeyDown",
"onStop",
"promptRef"
]);
var translations = _object_spread({
textareaLabel: 'Type your message...',
textareaPlaceholder: 'Type your message...',
emptyMessageTooltip: 'Message is empty',
stopResponseTooltip: 'Stop response',
sendMessageTooltip: 'Send message',
disclaimer: 'AI can make mistakes. Verify responses.'
}, userTranslations);
var cssClasses = {
root: cx('ais-ChatPrompt', classNames.root),
header: cx('ais-ChatPrompt-header', classNames.header),
body: cx('ais-ChatPrompt-body', classNames.body),
textarea: cx('ais-ChatPrompt-textarea ais-Scrollbar', disabled && 'ais-ChatPrompt-textarea--disabled', classNames.textarea),
actions: cx('ais-ChatPrompt-actions', classNames.actions, disabled && 'ais-ChatPrompt-actions--disabled'),
submit: cx('ais-ChatPrompt-submit', classNames.submit),
footer: cx('ais-ChatPrompt-footer', classNames.footer)
};
var hasValue = typeof value === 'string' ? value.trim() !== '' : Boolean(value);
var canStop = status === 'submitted' || status === 'streaming';
var buttonDisabled = !hasValue && !canStop || disabled;
var submitIcon = canStop ? /*#__PURE__*/ createElement(StopIcon, {
createElement: createElement
}) : /*#__PURE__*/ createElement(ArrowUpIcon, {
createElement: createElement
});
return /*#__PURE__*/ createElement("form", {
className: cx(cssClasses.root, props.className),
onSubmit: function onSubmit1(event) {
event.preventDefault();
if (canStop) {
onStop === null || onStop === void 0 ? void 0 : onStop();
return;
}
if (!hasValue) {
return;
}
onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit(event);
}
}, HeaderComponent && /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.header)
}, /*#__PURE__*/ createElement(HeaderComponent, null)), /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.body),
onClick: function onClick(e) {
if (e.target === textAreaElement) return;
textAreaElement === null || textAreaElement === void 0 ? void 0 : textAreaElement.focus();
}
}, /*#__PURE__*/ createElement("textarea", _object_spread_props(_object_spread({}, props), {
ref: function ref(element) {
return setTextAreaRef(element, promptRef);
},
"data-max-rows": maxRows,
className: cx(cssClasses.textarea),
value: value,
placeholder: placeholder || translations.textareaPlaceholder,
"aria-label": translations.textareaLabel,
disabled: disabled,
autoFocus: autoFocus,
onInput: function onInput1(event) {
adjustHeight();
onInput === null || onInput === void 0 ? void 0 : onInput(event);
},
onKeyDown: function onKeyDown1(event) {
onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(event);
if (event.key === 'Enter' && !event.shiftKey) {
event.preventDefault();
if (canStop) {
onStop === null || onStop === void 0 ? void 0 : onStop();
return;
}
if (!hasValue) {
return;
}
onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit(event);
}
if (event.key === 'Escape') {
if (event.currentTarget && event.currentTarget.blur) {
event.currentTarget.blur();
}
}
}
})), /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.actions)
}, /*#__PURE__*/ createElement(Button, {
type: "submit",
variant: "primary",
size: "sm",
iconOnly: true,
className: cx(cssClasses.submit),
disabled: buttonDisabled,
"aria-label": function() {
if (buttonDisabled) return translations.emptyMessageTooltip;
if (canStop) return translations.stopResponseTooltip;
return translations.sendMessageTooltip;
}(),
"data-status": status
}, submitIcon))), /*#__PURE__*/ createElement("div", {
className: cx(cssClasses.footer)
}, FooterComponent ? /*#__PURE__*/ createElement(FooterComponent, null) : /*#__PURE__*/ createElement("div", {
className: "ais-ChatPrompt-disclaimer"
}, translations.disclaimer)));
};
}
function createChatPromptSuggestionsComponent(param) {
var createElement = param.createElement;
var Button = createButtonComponent({
createElement: createElement
});
return function ChatPromptSuggestions(userProps) {
var _userProps_suggestions = userProps.suggestions, suggestions = _userProps_suggestions === void 0 ? [] : _userProps_suggestions, onSuggestionClick = userProps.onSuggestionClick, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
var visibleSuggestions = suggestions.filter(function(suggestion) {
return suggestion.trim() !== '';
});
if (visibleSuggestions.length === 0) {
return null;
}
return /*#__PURE__*/ createElement("div", {
className: cx('ais-ChatPromptSuggestions', classNames.root)
}, visibleSuggestions.map(function(suggestion, index) {
return /*#__PURE__*/ createElement(Button, {
key: index,
size: "sm",
variant: "primary",
className: cx('ais-ChatPromptSuggestions-suggestion', classNames.suggestion),
onClick: function onClick() {
return onSuggestionClick(suggestion);
}
}, suggestion);
}));
};
}
function prefersReducedMotion() {
return typeof window !== 'undefined' && typeof window.matchMedia === 'function' && window.matchMedia('(prefers-reduced-motion: reduce)').matches;
}
function createChatComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment, useMemo = param.useMemo, useState = param.useState, useEffect = param.useEffect;
var ChatHeader = createChatHeaderComponent({
createElement: createElement,
Fragment: Fragment
});
var ChatMessages = createChatMessagesComponent({
createElement: createElement,
Fragment: Fragment,
useMemo: useMemo,
useState: useState,
useEffect: useEffect
});
var ChatPrompt = createChatPromptComponent({
createElement: createElement,
Fragment: Fragment
});
var ChatPromptSuggestions = createChatPromptSuggestionsComponent({
createElement: createElement,
Fragment: Fragment
});
var OverlayLayout = createChatOverlayLayoutComponent({
createElement: createElement,
Fragment: Fragment
});
return function Chat(userProps) {
var open = userProps.open, _userProps_maximized = userProps.maximized, maximized = _userProps_maximized === void 0 ? false : _userProps_maximized, headerProps = userProps.headerProps, messagesProps = userProps.messagesProps, suggestionsProps = userProps.suggestionsProps, _userProps_promptProps = userProps.promptProps, promptProps = _userProps_promptProps === void 0 ? {} : _userProps_promptProps, HeaderComponent = userProps.headerComponent, PromptComponent = userProps.promptComponent, SuggestionsComponent = userProps.suggestionsComponent, tmp = userProps.layoutComponent, LayoutComponent = tmp === void 0 ? OverlayLayout : tmp, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, className = userProps.className, sendMessage = userProps.sendMessage, regenerate = userProps.regenerate, stop = userProps.stop, error = userProps.error, props = _object_without_properties(userProps, [
"open",
"maximized",
"headerProps",
"messagesProps",
"suggestionsProps",
"promptProps",
"headerComponent",
"promptComponent",
"suggestionsComponent",
"layoutComponent",
"classNames",
"className",
"sendMessage",
"regenerate",
"stop",
"error"
]);
var _useState = _sliced_to_array(useState(false), 2), isClearing = _useState[0], setIsClearing = _useState[1];
var commitClear = headerProps.onClear || messagesProps.onNewConversation;
var startClear = function startClear() {
if (!commitClear) {
return;
}
// Reduced motion disables the transition, so `transitionend` never fires;
// commit immediately instead of waiting for it.
if (prefersReducedMotion()) {
commitClear();
return;
}
// Stop streaming now so the assistant stops immediately, not after the fade.
if (messagesProps.status === 'submitted' || messagesProps.status === 'streaming') {
stop();
}
setIsClearing(true);
};
var finishClear = function finishClear() {
commitClear === null || commitClear === void 0 ? void 0 : commitClear();
setIsClearing(false);
};
var headerComponent = createElement(HeaderComponent || ChatHeader, _object_spread_props(_object_spread({}, headerProps), {
onClear: commitClear ? startClear : headerProps.onClear,
canClear: headerProps.canClear && !isClearing,
classNames: classNames.header,
maximized: maximized
}));
var messagesComponent = /*#__PURE__*/ createElement(ChatMessages, _object_spread_props(_object_spread({}, messagesProps), {
open: open,
maximized: maximized,
regenerate: regenerate,
stop: stop,
isClearing: isClearing,
onClearTransitionEnd: finishClear,
onNewConversation: commitClear ? startClear : messagesProps.onNewConversation,
error: error,
classNames: classNames.messages,
messageClassNames: classNames.message,
suggestionsElement: createElement(SuggestionsComponent || ChatPromptSuggestions, _object_spread_props(_object_spread({}, suggestionsProps), {
classNames: classNames.suggestions
}))
}));
var promptComponent = createElement(PromptComponent || ChatPrompt, _object_spread_props(_object_spread({}, promptProps), {
classNames: classNames.prompt
}));
return /*#__PURE__*/ createElement(LayoutComponent, _object_spread_props(_object_spread({}, props), {
open: open,
maximized: maximized,
headerComponent: headerComponent,
messagesComponent: messagesComponent,
promptComponent: promptComponent,
classNames: {
root: classNames.root,
container: classNames.container
},
className: className,
messages: messagesProps.messages,
status: messagesProps.status,
tools: messagesProps.tools,
isClearing: isClearing,
clearMessages: commitClear ? startClear : headerProps.onClear,
onClearTransitionEnd: finishClear,
suggestions: suggestionsProps.suggestions,
sendMessage: sendMessage,
regenerate: regenerate,
stop: stop,
error: error
}));
};
}
function createChatInlineLayoutComponent(param) {
var createElement = param.createElement;
return function ChatInlineLayout(userProps) {
var headerComponent = userProps.headerComponent, messagesComponent = userProps.messagesComponent, promptComponent = userProps.promptComponent, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, className = userProps.className;
userProps.open;
userProps.maximized; // Chat state props (destructured to avoid spreading on div)
userProps.messages;
userProps.status;
userProps.isClearing;
userProps.clearMessages;
userProps.onClearTransitionEnd;
userProps.suggestions;
userProps.tools;
userProps.sendMessage;
userProps.regenerate;
userProps.stop;
userProps.error;
var rest = _object_without_properties(userProps, [
"headerComponent",
"messagesComponent",
"promptComponent",
"classNames",
"className",
"open",
"maximized",
"messages",
"status",
"isClearing",
"clearMessages",
"onClearTransitionEnd",
"suggestions",
"tools",
"sendMessage",
"regenerate",
"stop",
"error"
]);
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, rest), {
className: cx('ais-Chat', 'ais-ChatInlineLayout', classNames.root, className)
}), /*#__PURE__*/ createElement("div", {
className: cx('ais-Chat-container', classNames.container)
}, headerComponent, messagesComponent, promptComponent));
};
}
function createChatSidePanelLayoutComponent(param) {
var createElement = param.createElement;
var originalMargins = new WeakMap();
return function ChatSidePanelLayout(userProps) {
var open = userProps.open, maximized = userProps.maximized, headerComponent = userProps.headerComponent, messagesComponent = userProps.messagesComponent, promptComponent = userProps.promptComponent, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, className = userProps.className, parentElement = userProps.parentElement; // Chat state props (destructured to avoid spreading on div)
userProps.messages;
userProps.status;
userProps.isClearing;
userProps.clearMessages;
userProps.onClearTransitionEnd;
userProps.suggestions;
userProps.tools;
userProps.sendMessage;
userProps.regenerate;
userProps.stop;
userProps.error;
var rest = _object_without_properties(userProps, [
"open",
"maximized",
"headerComponent",
"messagesComponent",
"promptComponent",
"classNames",
"className",
"parentElement",
"messages",
"status",
"isClearing",
"clearMessages",
"onClearTransitionEnd",
"suggestions",
"tools",
"sendMessage",
"regenerate",
"stop",
"error"
]);
// React versions before 19 preserve unknown boolean attributes as numbers.
var inert = open ? undefined : 1;
var element = typeof document !== 'undefined' ? parentElement ? document.querySelector(parentElement) : document.body : null;
if (element) {
if (open && !originalMargins.has(element)) {
originalMargins.set(element, element.style.marginRight);
var chatWidth = getComputedStyle(document.documentElement).getPropertyValue('--ais-chat-width').trim() || '22.5rem';
var original = originalMargins.get(element);
element.style.marginRight = original ? "calc(".concat(original, " + ").concat(chatWidth, ")") : chatWidth;
} else if (!open && originalMargins.has(element)) {
var saved = originalMargins.get(element);
if (saved) {
element.style.marginRight = saved;
} else {
element.style.removeProperty('margin-right');
}
originalMargins.delete(element);
}
}
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, rest), {
className: cx('ais-Chat', 'ais-ChatSidePanelLayout', maximized && 'ais-ChatSidePanelLayout--maximized', classNames.root, className)
}), /*#__PURE__*/ createElement("div", {
inert: inert,
className: cx('ais-Chat-container', open && 'ais-Chat-container--open', maximized && 'ais-Chat-container--maximized', classNames.container)
}, headerComponent, messagesComponent, promptComponent));
};
}
function createChatGreetingComponent(param) {
var createElement = param.createElement;
return function ChatGreeting(// eslint-disable-next-line typescript/no-deprecated
userProps) {
var _ref, _ref1;
var userTranslations = userProps.translations, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
userProps.context;
var banner = userProps.banner; // Read from `context` instead. Destructured only to keep the deprecated
// root-level props out of the DOM spread below; remove in the next major.
userProps.sendMessage;
userProps.status;
userProps.onClose;
userProps.setInput;
var props = _object_without_properties(userProps, [
"translations",
"classNames",
"context",
"banner",
"sendMessage",
"status",
"onClose",
"setInput"
]);
var translations = {
heading: (_ref = userTranslations === null || userTranslations === void 0 ? void 0 : userTranslations.heading) !== null && _ref !== void 0 ? _ref : 'How can I help you today?',
subheading: (_ref1 = userTranslations === null || userTranslations === void 0 ? void 0 : userTranslations.subheading) !== null && _ref1 !== void 0 ? _ref1 : "Ask me anything about our products, and I'll do my best to assist you."
};
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-ChatGreeting', classNames.root, props.className)
}), banner && /*#__PURE__*/ createElement("img", {
className: cx('ais-ChatGreeting-banner', classNames.banner),
src: banner,
alt: ""
}), /*#__PURE__*/ createElement("h2", {
className: cx('ais-ChatGreeting-heading', classNames.heading)
}, translations.heading), /*#__PURE__*/ createElement("p", {
className: cx('ais-ChatGreeting-subheading', classNames.subheading)
}, translations.subheading));
};
}
function createPromptSuggestionsComponent(param) {
var createElement = param.createElement;
var Button = createButtonComponent({
createElement: createElement
});
function DefaultHeader(param) {
var classNames = param.classNames, translations = param.translations;
return /*#__PURE__*/ createElement("div", {
className: cx('ais-PromptSuggestions-header', classNames.header)
}, /*#__PURE__*/ createElement("span", {
className: cx('ais-PromptSuggestions-headerTitle', classNames.headerTitle)
}, translations.headerTitle));
}
return function PromptSuggestions(userProps) {
var _userProps_suggestions = userProps.suggestions, suggestions = _userProps_suggestions === void 0 ? [] : _userProps_suggestions, onSuggestionClick = userProps.onSuggestionClick, _userProps_isLoading = userProps.isLoading, isLoading = _userProps_isLoading === void 0 ? false : _userProps_isLoading, _userProps_skeletonCount = userProps.skeletonCount, skeletonCount = _userProps_skeletonCount === void 0 ? 3 : _userProps_skeletonCount, _userProps_disabled = userProps.disabled, disabled = _userProps_disabled === void 0 ? false : _userProps_disabled, headerComponent = userProps.headerComponent, userTranslations = userProps.translations, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, props = _object_without_properties(userProps, [
"suggestions",
"onSuggestionClick",
"isLoading",
"skeletonCount",
"disabled",
"headerComponent",
"translations",
"classNames"
]);
var translations = _object_spread({
headerTitle: 'Suggestions'
}, userTranslations);
var HeaderComponent = headerComponent === false ? null : headerComponent !== null && headerComponent !== void 0 ? headerComponent : DefaultHeader;
var visibleSuggestions = suggestions.filter(function(suggestion) {
return suggestion.trim() !== '';
});
var hasContent = visibleSuggestions.length > 0 || isLoading;
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-PromptSuggestions', classNames.root, props.className)
}), HeaderComponent && hasContent && /*#__PURE__*/ createElement(HeaderComponent, {
classNames: {
header: classNames.header,
headerTitle: classNames.headerTitle
},
translations: translations
}), isLoading && visibleSuggestions.length === 0 ? /*#__PURE__*/ createElement("div", {
className: cx('ais-PromptSuggestions-skeleton', classNames.skeleton)
}, _to_consumable_array(new Array(skeletonCount)).map(function(_, i) {
return /*#__PURE__*/ createElement("div", {
key: i,
className: cx('ais-PromptSuggestions-skeletonItem', classNames.skeletonItem)
});
})) : visibleSuggestions.map(function(suggestion, index) {
return /*#__PURE__*/ createElement(Button, {
key: index,
size: "sm",
variant: "primary",
className: cx('ais-PromptSuggestions-suggestion', classNames.suggestion),
// Ignore clicks while streaming so an unfinished prompt (e.g.
// `Wh..`) can't be sent before generation settles — without
// toggling `disabled`, which would swap the pill's styling
// mid-stream.
onClick: function onClick() {
if (isLoading) return;
onSuggestionClick(suggestion);
},
disabled: disabled
}, suggestion);
}));
};
}
function createChatToggleButtonComponent(param) {
var createElement = param.createElement;
var Button = createButtonComponent({
createElement: createElement
});
return function ChatToggleButton(userProps) {
var open = userProps.open, onClick = userProps.onClick, ToggleIcon = userProps.toggleIconComponent, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, className = userProps.className, props = _object_without_properties(userProps, [
"open",
"onClick",
"toggleIconComponent",
"classNames",
"className"
]);
var defaultIcon = open ? /*#__PURE__*/ createElement(ChevronUpIcon, {
createElement: createElement
}) : /*#__PURE__*/ createElement(SparklesIcon, {
createElement: createElement
});
return /*#__PURE__*/ createElement(Button, _object_spread({
variant: "primary",
size: "md",
iconOnly: true,
className: cx('ais-ChatToggleButton', open && 'ais-ChatToggleButton--open', classNames.root, className),
onClick: onClick
}, props), ToggleIcon ? /*#__PURE__*/ createElement(ToggleIcon, {
isOpen: open
}) : defaultIcon);
};
}
function addAbsolutePosition(hits, page, hitsPerPage) {
return hits.map(function(hit, idx) {
return _object_spread_props(_object_spread({}, hit), {
__position: hitsPerPage * page + idx + 1
});
});
}
function addQueryID(hits, queryID) {
if (!queryID) {
return hits;
}
return hits.map(function(hit) {
return _object_spread_props(_object_spread({}, hit), {
__queryID: queryID
});
});
}
function createHeaderComponent(param) {
var createElement = param.createElement;
var Button = createButtonComponent({
createElement: createElement
});
return function HeaderComponent(param) {
var showViewAll = param.showViewAll, canScrollLeft = param.canScrollLeft, canScrollRight = param.canScrollRight, scrollLeft = param.scrollLeft, scrollRight = param.scrollRight, nbHits = param.nbHits, input = param.input, resolvedSearchParams = param.resolvedSearchParams, nbItems = param.nbItems, applyFilters = param.applyFilters, getSearchPageURL = param.getSearchPageURL, onClose = param.onClose;
if (nbItems < 1) {
return null;
}
return /*#__PURE__*/ createElement("div", {
className: "ais-ChatToolSearchIndexCarouselHeader"
}, /*#__PURE__*/ createElement("div", {
className: "ais-ChatToolSearchIndexCarouselHeaderResults"
}, nbHits && /*#__PURE__*/ createElement("div", {
className: "ais-ChatToolSearchIndexCarouselHeaderCount"
}, nbItems, " of ", nbHits.toLocaleString(), " result", nbHits > 1 ? 's' : ''), showViewAll && /*#__PURE__*/ createElement(Button, {
variant: "ghost",
size: "sm",
onClick: function onClick() {
if (!input || !applyFilters) return;
var params = applyFilters(getApplyFiltersParamsFromToolInput(input, resolvedSearchParams));
if (getSearchPageURL) {
var searchPageURL = getSearchPageURL(params);
var resolvedURL = new URL(searchPageURL, window.location.href);
if (resolvedURL.pathname !== window.location.pathname) {
window.location.href = searchPageURL;
}
}
onClose();
},
className: "ais-ChatToolSearchIndexCarouselHeaderViewAll"
}, "View all", /*#__PURE__*/ createElement(ArrowRightIcon, {
createElement: createElement
}))), nbItems > 2 && /*#__PURE__*/ createElement("div", {
className: "ais-ChatToolSearchIndexCarouselHeaderScrollButtons"
}, /*#__PURE__*/ createElement(Button, {
variant: "outline",
size: "sm",
iconOnly: true,
onClick: scrollLeft,
disabled: !canScrollLeft,
className: "ais-ChatToolSearchIndexCarouselHeaderScrollButton"
}, /*#__PURE__*/ createElement(ChevronLeftIcon, {
createElement: createElement
})), /*#__PURE__*/ createElement(Button, {
variant: "outline",
size: "sm",
iconOnly: true,
onClick: scrollRight,
disabled: !canScrollRight,
className: "ais-ChatToolSearchIndexCarouselHeaderScrollButton"
}, /*#__PURE__*/ createElement(ChevronRightIcon, {
createElement: createElement
}))));
};
}
function createCarouselToolComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment, useEffect = param.useEffect, useMemo = param.useMemo, useRef = param.useRef, useState = param.useState;
var DefaultHeader = createHeaderComponent({
createElement: createElement,
Fragment: Fragment
});
var Carousel = createCarouselComponent({
createElement: createElement,
Fragment: Fragment,
useEffect: useEffect,
useRef: useRef
});
return function CarouselTool(userProps) {
var _ref;
var ItemComponent = userProps.itemComponent, HeaderComponent = userProps.headerComponent, getSearchPageURL = userProps.getSearchPageURL, context = userProps.toolProps.context, showViewAll = userProps.headerProps.showViewAll;
var message = context.message, applyFilters = context.applyFilters, insightsEventContext = context.insightsEventContext, sendEvent = context.sendEvent, onClose = context.onClose;
var instantSearchStatus = (_ref = insightsEventContext === null || insightsEventContext === void 0 ? void 0 : insightsEventContext.instantSearchStatus) !== null && _ref !== void 0 ? _ref : 'idle';
var input = message === null || message === void 0 ? void 0 : message.input;
// What the server actually searched with, when it sent it. Absent for the
// default search tool and whenever the MCP server emits no `_meta`.
var resolvedSearchParams = useMemo(function() {
return getResolvedSearchParams(context.messages, message === null || message === void 0 ? void 0 : message.toolCallId);
}, [
context.messages,
message === null || message === void 0 ? void 0 : message.toolCallId
]);
var output = message === null || message === void 0 ? void 0 : message.output;
var hits = (output === null || output === void 0 ? void 0 : output.hits) || [];
var items = addQueryID(addAbsolutePosition(hits, 0, hits.length), output === null || output === void 0 ? void 0 : output.queryID);
var viewedItemsSignature = items.map(function(item) {
return "".concat(item.objectID, ":").concat(item.__position);
}).join('|');
var lastViewedItemsSignatureRef = useRef(undefined);
useEffect(function() {
if (instantSearchStatus !== 'idle' || items.length === 0 || viewedItemsSignature === lastViewedItemsSignatureRef.current) {
return;
}
var timer = setTimeout(function() {
lastViewedItemsSignatureRef.current = viewedItemsSignature;
sendEvent('view:internal', items, 'items_shown');
}, 0);
return function() {
clearTimeout(timer);
};
}, [
instantSearchStatus,
items,
sendEvent,
viewedItemsSignature
]);
var _useState = _sliced_to_array(useState(false), 2), canScrollLeft = _useState[0], setCanScrollLeft = _useState[1];
var _useState1 = _sliced_to_array(useState(true), 2), canScrollRight = _useState1[0], setCanScrollRight = _useState1[1];
var carouselIdRef = useRef('');
if (!carouselIdRef.current) {
carouselIdRef.current = generateCarouselId();
}
var carouselRefs = {
listRef: useRef(null),
nextButtonRef: useRef(null),
previousButtonRef: useRef(null),
carouselIdRef: carouselIdRef,
canScrollLeft: canScrollLeft,
canScrollRight: canScrollRight,
setCanScrollLeft: setCanScrollLeft,
setCanScrollRight: setCanScrollRight
};
var MemoedHeaderComponent = useMemo(function() {
if (HeaderComponent) {
return function(props) {
return /*#__PURE__*/ createElement(HeaderComponent, _object_spread({
showViewAll: showViewAll,
nbHits: output === null || output === void 0 ? void 0 : output.nbHits,
input: input,
resolvedSearchParams: resolvedSearchParams,
applyFilters: applyFilters,
getSearchPageURL: getSearchPageURL,
onClose: onClose
}, props));
};
}
return function(props) {
return /*#__PURE__*/ createElement(DefaultHeader, _object_spread({
showViewAll: showViewAll,
nbHits: output === null || output === void 0 ? void 0 : output.nbHits,
input: input,
resolvedSearchParams: resolvedSearchParams,
applyFilters: applyFilters,
getSearchPageURL: getSearchPageURL,
onClose: onClose
}, props));
};
}, [
showViewAll,
HeaderComponent,
output === null || output === void 0 ? void 0 : output.nbHits,
input,
resolvedSearchParams,
applyFilters,
getSearchPageURL,
onClose
]);
return /*#__PURE__*/ createElement(Carousel, _object_spread_props(_object_spread({}, carouselRefs), {
items: items,
itemComponent: ItemComponent,
headerComponent: MemoedHeaderComponent,
showNavigation: false,
sendEvent: sendEvent
}));
};
}
var isObject = function isObject(value) {
return value !== null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object';
};
var hasOwn = function hasOwn(value, key) {
return Object.prototype.hasOwnProperty.call(value, key);
};
var claimsDisplayResultsPayload = function claimsDisplayResultsPayload(value) {
return isObject(value) && (hasOwn(value, 'intro') || hasOwn(value, 'groups'));
};
/**
* Decodes a raw property-key body with JSON string semantics, so an escaped
* spelling of `objectID` compares equal to the name `JSON.parse` produces.
* An undecodable key is kept verbatim: it matches no name below, and the
* document holding it cannot parse either.
*/ var decodeJsonKey = function decodeJsonKey(rawKey) {
if (rawKey.indexOf('\\') === -1) {
return rawKey;
}
try {
return JSON.parse('"'.concat(rawKey, '"'));
} catch (unused) {
return rawKey;
}
};
/**
* Reports whether the raw input ends inside an unterminated
* `groups[].results[].objectID` value.
*
* Partial input is parsed with repair that closes an open string literal, so an
* identifier still mid-delta reaches `input` looking complete and can hydrate a
* different record whose identifier is a prefix of the real one.
*/ var endsInsideResultObjectId = function endsInsideResultObjectId(rawInput) {
var _frames_, _frames_1, _frames_2;
var frames = [];
var inString = false;
var isEscaped = false;
var isKey = false;
var expectValue = false;
var stringStart = 0;
for(var index = 0; index < rawInput.length; index++){
var char = rawInput[index];
if (inString) {
if (isEscaped) {
isEscaped = false;
} else if (char === '\\') {
isEscaped = true;
} else if (char === '"') {
inString = false;
if (isKey) {
frames[frames.length - 1].lastKey = decodeJsonKey(rawInput.slice(stringStart, index));
} else {
expectValue = false;
}
}
continue;
}
if (char === '"') {
var _frames_3;
inString = true;
stringStart = index + 1;
isKey = !expectValue && ((_frames_3 = frames[frames.length - 1]) === null || _frames_3 === void 0 ? void 0 : _frames_3.isObject) === true;
} else if (char === ':') {
expectValue = true;
} else if (char === ',') {
expectValue = false;
} else if (char === '{' || char === '[') {
var _ref;
var _frames_4;
frames.push({
key: expectValue ? (_ref = (_frames_4 = frames[frames.length - 1]) === null || _frames_4 === void 0 ? void 0 : _frames_4.lastKey) !== null && _ref !== void 0 ? _ref : '' : '',
lastKey: '',
isObject: char === '{'
});
expectValue = false;
} else if (char === '}' || char === ']') {
frames.pop();
expectValue = false;
}
}
return inString && !isKey && ((_frames_ = frames[frames.length - 1]) === null || _frames_ === void 0 ? void 0 : _frames_.lastKey) === 'objectID' && ((_frames_1 = frames[frames.length - 2]) === null || _frames_1 === void 0 ? void 0 : _frames_1.key) === 'results' && ((_frames_2 = frames[frames.length - 4]) === null || _frames_2 === void 0 ? void 0 : _frames_2.key) === 'groups';
};
var DEFAULT_TRANSLATIONS$1 = {
streamingLabel: 'Curating results…'
};
function createDisplayResultsToolComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment, useEffect = param.useEffect, useRef = param.useRef;
return function DisplayResultsTool(userProps) {
var _ref;
var toolProps = userProps.toolProps, renderGroupCarousel = userProps.groupCarouselComponent, userTranslations = userProps.translations;
var context = toolProps.context;
var message = context.message, insightsEventContext = context.insightsEventContext, sendEvent = context.sendEvent, messages = context.messages, status = context.status, records = context.records;
var instantSearchStatus = (_ref = insightsEventContext === null || insightsEventContext === void 0 ? void 0 : insightsEventContext.instantSearchStatus) !== null && _ref !== void 0 ? _ref : 'idle';
var translations = _object_spread({}, DEFAULT_TRANSLATIONS$1, userTranslations);
var inputClaimsPayload = claimsDisplayResultsPayload(message === null || message === void 0 ? void 0 : message.input);
var legacyOutput = (message === null || message === void 0 ? void 0 : message.state) === 'output-available' && message.preliminary !== true && !inputClaimsPayload ? message.output : undefined;
var payload = inputClaimsPayload ? message === null || message === void 0 ? void 0 : message.input : claimsDisplayResultsPayload(legacyOutput) ? legacyOutput : undefined;
var intro = typeof (payload === null || payload === void 0 ? void 0 : payload.intro) === 'string' ? payload.intro : undefined;
var groups = Array.isArray(payload === null || payload === void 0 ? void 0 : payload.groups) ? payload.groups.filter(isObject) : [];
var latestMessage = messages === null || messages === void 0 ? void 0 : messages[messages.length - 1];
var isStreaming = status === 'streaming' && (message === null || message === void 0 ? void 0 : message.state) === 'input-streaming' && (latestMessage === null || latestMessage === void 0 ? void 0 : latestMessage.parts.some(function(part) {
return part === message;
})) === true;
// Only the last result of the last group can still be mid-delta, so it is
// the only one ever withheld.
var rawInput = (message === null || message === void 0 ? void 0 : message.state) === 'input-streaming' ? message.rawInput : undefined;
var withholdsTrailingResult = typeof rawInput === 'string' && endsInsideResultObjectId(rawInput);
var lastGroupIndex = groups.length - 1;
var renderableGroups = groups.reduce(function(renderedGroups, group, groupIndex) {
var suppliedResults = Array.isArray(group.results) ? withholdsTrailingResult && groupIndex === lastGroupIndex ? group.results.slice(0, -1) : group.results : [];
var results = suppliedResults.filter(function(result) {
return isObject(result) && typeof result.objectID === 'string' && result.objectID !== '';
});
var items = results.reduce(function(renderedItems, result) {
// The backend sends this tool object IDs only.
var hydrated = records === null || records === void 0 ? void 0 : records.get(result.objectID);
if (!hydrated) {
return renderedItems;
}
renderedItems.push(_object_spread_props(_object_spread({}, hydrated), {
objectID: result.objectID,
__position: renderedItems.length + 1,
__displayToolResult: result
}));
return renderedItems;
}, []);
if (items.length === 0) {
return renderedGroups;
}
renderedGroups.push({
key: groupIndex,
title: typeof group.title === 'string' ? group.title : undefined,
why: typeof group.why === 'string' ? group.why : undefined,
items: items
});
return renderedGroups;
}, []);
var viewedItems = renderableGroups.flatMap(function(group) {
return group.items;
});
var viewedItemsSignature = viewedItems.map(function(item) {
return "".concat(item.objectID, ":").concat(item.__position);
}).join('|');
var lastViewedItemsSignatureRef = useRef(undefined);
useEffect(function() {
if (instantSearchStatus !== 'idle' || viewedItems.length === 0 || viewedItemsSignature === lastViewedItemsSignatureRef.current) {
return;
}
var timer = setTimeout(function() {
lastViewedItemsSignatureRef.current = viewedItemsSignature;
sendEvent('view:internal', viewedItems, 'items_shown');
}, 0);
return function() {
clearTimeout(timer);
};
}, [
instantSearchStatus,
sendEvent,
viewedItems,
viewedItemsSignature
]);
if (!intro && renderableGroups.length === 0 && !isStreaming) {
return /*#__PURE__*/ createElement(Fragment, null);
}
return /*#__PURE__*/ createElement("div", {
className: "ais-ChatToolDisplayResults"
}, intro && /*#__PURE__*/ createElement("div", {
className: "ais-ChatToolDisplayResults-intro"
}, intro), renderableGroups.map(function(group) {
return /*#__PURE__*/ createElement("div", {
key: group.key,
className: "ais-ChatToolDisplayResults-group"
}, group.title && /*#__PURE__*/ createElement("div", {
className: "ais-ChatToolDisplayResults-groupTitle"
}, group.title), group.why && /*#__PURE__*/ createElement("div", {
className: "ais-ChatToolDisplayResults-groupWhy"
}, group.why), renderGroupCarousel({
items: group.items,
sendEvent: sendEvent
}));
}), isStreaming && /*#__PURE__*/ createElement("div", {
className: "ais-ChatToolDisplayResults-streaming"
}, translations.streamingLabel));
};
}
function createDefaultEmptyComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
return function DefaultEmpty() {
return /*#__PURE__*/ createElement(Fragment, null, "No results");
};
}
function createDefaultHeaderComponent(param) {
var createElement = param.createElement;
return function DefaultHeader(userProps) {
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, items = userProps.items, translations = userProps.translations;
if (!items || items.length < 1) {
return null;
}
if (!translations.title) {
return null;
}
return /*#__PURE__*/ createElement("h3", {
className: classNames.title
}, translations.title);
};
}
function createListComponent(param) {
var createElement = param.createElement;
return function List(userProps) {
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, ItemComponent = userProps.itemComponent, items = userProps.items, sendEvent = userProps.sendEvent;
return /*#__PURE__*/ createElement("div", {
className: classNames.container
}, /*#__PURE__*/ createElement("ol", {
className: classNames.list
}, items.map(function(item) {
return /*#__PURE__*/ createElement("li", {
key: item.objectID,
className: classNames.item,
onClick: function onClick() {
sendEvent('click:internal', item, 'Item Clicked');
},
onAuxClick: function onAuxClick() {
sendEvent('click:internal', item, 'Item Clicked');
}
}, /*#__PURE__*/ createElement(ItemComponent, {
item: item,
sendEvent: sendEvent
}));
})));
};
}
function createFrequentlyBoughtTogetherComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
return function FrequentlyBoughtTogether(userProps) {
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, tmp = userProps.emptyComponent, EmptyComponent = tmp === void 0 ? createDefaultEmptyComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp, tmp1 = userProps.headerComponent, HeaderComponent = tmp1 === void 0 ? createDefaultHeaderComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp1, tmp2 = userProps.itemComponent, ItemComponent = tmp2 === void 0 ? createDefaultItemComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp2, tmp3 = userProps.layout, Layout = tmp3 === void 0 ? createListComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp3, items = userProps.items, status = userProps.status, userTranslations = userProps.translations, sendEvent = userProps.sendEvent, props = _object_without_properties(userProps, [
"classNames",
"emptyComponent",
"headerComponent",
"itemComponent",
"layout",
"items",
"status",
"translations",
"sendEvent"
]);
var translations = _object_spread({
title: 'Frequently bought together',
sliderLabel: 'Frequently bought together products'
}, userTranslations);
var cssClasses = {
root: cx('ais-FrequentlyBoughtTogether', classNames.root),
emptyRoot: cx('ais-FrequentlyBoughtTogether', classNames.root, 'ais-FrequentlyBoughtTogether--empty', classNames.emptyRoot, props.className),
title: cx('ais-FrequentlyBoughtTogether-title', classNames.title),
container: cx('ais-FrequentlyBoughtTogether-container', classNames.container),
list: cx('ais-FrequentlyBoughtTogether-list', classNames.list),
item: cx('ais-FrequentlyBoughtTogether-item', classNames.item)
};
if (items.length === 0 && status === 'idle') {
return /*#__PURE__*/ createElement("section", _object_spread_props(_object_spread({}, props), {
className: cssClasses.emptyRoot
}), /*#__PURE__*/ createElement(EmptyComponent, null));
}
return /*#__PURE__*/ createElement("section", _object_spread_props(_object_spread({}, props), {
className: cssClasses.root
}), /*#__PURE__*/ createElement(HeaderComponent, {
classNames: cssClasses,
items: items,
translations: translations
}), /*#__PURE__*/ createElement(Layout, {
classNames: cssClasses,
itemComponent: ItemComponent,
items: items,
sendEvent: sendEvent
}));
};
}
function createHighlightPartComponent(param) {
var createElement = param.createElement;
return function HighlightPart(param) {
var classNames = param.classNames, children = param.children, highlightedTagName = param.highlightedTagName, isHighlighted = param.isHighlighted, nonHighlightedTagName = param.nonHighlightedTagName;
var TagName = isHighlighted ? highlightedTagName : nonHighlightedTagName;
return /*#__PURE__*/ createElement(TagName, {
className: isHighlighted ? classNames.highlighted : classNames.nonHighlighted
}, children);
};
}
function createHighlightComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
var HighlightPart = createHighlightPartComponent({
createElement: createElement,
Fragment: Fragment
});
return function Highlight(userProps) {
var parts = userProps.parts, _userProps_highlightedTagName = userProps.highlightedTagName, highlightedTagName = _userProps_highlightedTagName === void 0 ? 'mark' : _userProps_highlightedTagName, _userProps_nonHighlightedTagName = userProps.nonHighlightedTagName, nonHighlightedTagName = _userProps_nonHighlightedTagName === void 0 ? 'span' : _userProps_nonHighlightedTagName, _userProps_separator = userProps.separator, separator = _userProps_separator === void 0 ? ', ' : _userProps_separator, className = userProps.className, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, props = _object_without_properties(userProps, [
"parts",
"highlightedTagName",
"nonHighlightedTagName",
"separator",
"className",
"classNames"
]);
return /*#__PURE__*/ createElement("span", _object_spread_props(_object_spread({}, props), {
className: cx(classNames.root, className)
}), parts.map(function(part, partIndex) {
var isLastPart = partIndex === parts.length - 1;
return /*#__PURE__*/ createElement(Fragment, {
key: partIndex
}, part.map(function(subPart, subPartIndex) {
return /*#__PURE__*/ createElement(HighlightPart, {
key: subPartIndex,
classNames: classNames,
highlightedTagName: highlightedTagName,
nonHighlightedTagName: nonHighlightedTagName,
isHighlighted: subPart.isHighlighted
}, subPart.value);
}), !isLastPart && /*#__PURE__*/ createElement("span", {
className: classNames.separator
}, separator));
}));
};
}
function createDefaultBannerComponent(param) {
var createElement = param.createElement;
return function DefaultBanner(param) {
var classNames = param.classNames, banner = param.banner;
if (!banner.image.urls[0].url) {
return null;
}
return /*#__PURE__*/ createElement("aside", {
className: cx('ais-Hits-banner', classNames.bannerRoot)
}, banner.link ? /*#__PURE__*/ createElement("a", {
className: cx('ais-Hits-banner-link', classNames.bannerLink),
href: banner.link.url,
target: banner.link.target
}, /*#__PURE__*/ createElement("img", {
className: cx('ais-Hits-banner-image', classNames.bannerImage),
src: banner.image.urls[0].url,
alt: banner.image.title
})) : /*#__PURE__*/ createElement("img", {
className: cx('ais-Hits-banner-image', classNames.bannerImage),
src: banner.image.urls[0].url,
alt: banner.image.title
}));
};
}
function createHitsComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
var DefaultBannerComponent = createDefaultBannerComponent({
createElement: createElement,
Fragment: Fragment
});
return function Hits(userProps) {
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, hits = userProps.hits, ItemComponent = userProps.itemComponent, sendEvent = userProps.sendEvent, EmptyComponent = userProps.emptyComponent, banner = userProps.banner, BannerComponent = userProps.bannerComponent, props = _object_without_properties(userProps, [
"classNames",
"hits",
"itemComponent",
"sendEvent",
"emptyComponent",
"banner",
"bannerComponent"
]);
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-Hits', classNames.root, hits.length === 0 && cx('ais-Hits--empty', classNames.emptyRoot), props.className)
}), banner && (BannerComponent ? /*#__PURE__*/ createElement(BannerComponent, {
className: cx('ais-Hits-banner', classNames.bannerRoot),
banner: banner
}) : /*#__PURE__*/ createElement(DefaultBannerComponent, {
classNames: classNames,
banner: banner
})), hits.length === 0 && EmptyComponent ? /*#__PURE__*/ createElement(EmptyComponent, null) : /*#__PURE__*/ createElement("ol", {
className: cx('ais-Hits-list', classNames.list)
}, hits.map(function(hit, index) {
return /*#__PURE__*/ createElement(ItemComponent, {
key: hit.objectID,
hit: hit,
index: index,
className: cx('ais-Hits-item', classNames.item),
onClick: function onClick() {
sendEvent('click:internal', hit, 'Hit Clicked');
},
onAuxClick: function onAuxClick() {
sendEvent('click:internal', hit, 'Hit Clicked');
}
});
})));
};
}
function createLookingSimilarComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
return function LookingSimilar(userProps) {
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, tmp = userProps.emptyComponent, EmptyComponent = tmp === void 0 ? createDefaultEmptyComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp, tmp1 = userProps.headerComponent, HeaderComponent = tmp1 === void 0 ? createDefaultHeaderComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp1, tmp2 = userProps.itemComponent, ItemComponent = tmp2 === void 0 ? createDefaultItemComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp2, tmp3 = userProps.layout, Layout = tmp3 === void 0 ? createListComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp3, items = userProps.items, status = userProps.status, userTranslations = userProps.translations, sendEvent = userProps.sendEvent, props = _object_without_properties(userProps, [
"classNames",
"emptyComponent",
"headerComponent",
"itemComponent",
"layout",
"items",
"status",
"translations",
"sendEvent"
]);
var translations = _object_spread({
title: 'Looking similar',
sliderLabel: 'Looking similar'
}, userTranslations);
var cssClasses = {
root: cx('ais-LookingSimilar', classNames.root),
emptyRoot: cx('ais-LookingSimilar', classNames.root, 'ais-LookingSimilar--empty', classNames.emptyRoot, props.className),
title: cx('ais-LookingSimilar-title', classNames.title),
container: cx('ais-LookingSimilar-container', classNames.container),
list: cx('ais-LookingSimilar-list', classNames.list),
item: cx('ais-LookingSimilar-item', classNames.item)
};
if (items.length === 0 && status === 'idle') {
return /*#__PURE__*/ createElement("section", _object_spread_props(_object_spread({}, props), {
className: cssClasses.emptyRoot
}), /*#__PURE__*/ createElement(EmptyComponent, null));
}
return /*#__PURE__*/ createElement("section", _object_spread_props(_object_spread({}, props), {
className: cssClasses.root
}), /*#__PURE__*/ createElement(HeaderComponent, {
classNames: cssClasses,
items: items,
translations: translations
}), /*#__PURE__*/ createElement(Layout, {
classNames: cssClasses,
itemComponent: ItemComponent,
items: items,
sendEvent: sendEvent
}));
};
}
function createRelatedProductsComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
return function RelatedProducts(userProps) {
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, tmp = userProps.emptyComponent, EmptyComponent = tmp === void 0 ? createDefaultEmptyComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp, tmp1 = userProps.headerComponent, HeaderComponent = tmp1 === void 0 ? createDefaultHeaderComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp1, tmp2 = userProps.itemComponent, ItemComponent = tmp2 === void 0 ? createDefaultItemComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp2, tmp3 = userProps.layout, Layout = tmp3 === void 0 ? createListComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp3, items = userProps.items, status = userProps.status, userTranslations = userProps.translations, sendEvent = userProps.sendEvent, props = _object_without_properties(userProps, [
"classNames",
"emptyComponent",
"headerComponent",
"itemComponent",
"layout",
"items",
"status",
"translations",
"sendEvent"
]);
var translations = _object_spread({
title: 'Related products',
sliderLabel: 'Related products'
}, userTranslations);
var cssClasses = {
root: cx('ais-RelatedProducts', classNames.root),
emptyRoot: cx('ais-RelatedProducts', classNames.root, 'ais-RelatedProducts--empty', classNames.emptyRoot, props.className),
title: cx('ais-RelatedProducts-title', classNames.title),
container: cx('ais-RelatedProducts-container', classNames.container),
list: cx('ais-RelatedProducts-list', classNames.list),
item: cx('ais-RelatedProducts-item', classNames.item)
};
if (items.length === 0 && status === 'idle') {
return /*#__PURE__*/ createElement("section", _object_spread_props(_object_spread({}, props), {
className: cssClasses.emptyRoot
}), /*#__PURE__*/ createElement(EmptyComponent, null));
}
return /*#__PURE__*/ createElement("section", _object_spread_props(_object_spread({}, props), {
className: cssClasses.root
}), /*#__PURE__*/ createElement(HeaderComponent, {
classNames: cssClasses,
items: items,
translations: translations
}), /*#__PURE__*/ createElement(Layout, {
classNames: cssClasses,
itemComponent: ItemComponent,
items: items,
sendEvent: sendEvent
}));
};
}
function createTrendingItemsComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
return function TrendingItems(userProps) {
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, tmp = userProps.emptyComponent, EmptyComponent = tmp === void 0 ? createDefaultEmptyComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp, tmp1 = userProps.headerComponent, HeaderComponent = tmp1 === void 0 ? createDefaultHeaderComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp1, tmp2 = userProps.itemComponent, ItemComponent = tmp2 === void 0 ? createDefaultItemComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp2, tmp3 = userProps.layout, Layout = tmp3 === void 0 ? createListComponent({
createElement: createElement,
Fragment: Fragment
}) : tmp3, items = userProps.items, status = userProps.status, userTranslations = userProps.translations, sendEvent = userProps.sendEvent, props = _object_without_properties(userProps, [
"classNames",
"emptyComponent",
"headerComponent",
"itemComponent",
"layout",
"items",
"status",
"translations",
"sendEvent"
]);
var translations = _object_spread({
title: 'Trending items',
sliderLabel: 'Trending items'
}, userTranslations);
var cssClasses = {
root: cx('ais-TrendingItems', classNames.root),
emptyRoot: cx('ais-TrendingItems', classNames.root, 'ais-TrendingItems--empty', classNames.emptyRoot, props.className),
title: cx('ais-TrendingItems-title', classNames.title),
container: cx('ais-TrendingItems-container', classNames.container),
list: cx('ais-TrendingItems-list', classNames.list),
item: cx('ais-TrendingItems-item', classNames.item)
};
if (items.length === 0 && status === 'idle') {
return /*#__PURE__*/ createElement("section", _object_spread_props(_object_spread({}, props), {
className: cssClasses.emptyRoot
}), /*#__PURE__*/ createElement(EmptyComponent, null));
}
return /*#__PURE__*/ createElement("section", _object_spread_props(_object_spread({}, props), {
className: cssClasses.root
}), /*#__PURE__*/ createElement(HeaderComponent, {
classNames: cssClasses,
items: items,
translations: translations
}), /*#__PURE__*/ createElement(Layout, {
classNames: cssClasses,
itemComponent: ItemComponent,
items: items,
sendEvent: sendEvent
}));
};
}
function createTrendingFacetsComponent(param) {
var createElement = param.createElement, Fragment = param.Fragment;
function DefaultHeader(param) {
var _param_classNames = param.classNames, classNames = _param_classNames === void 0 ? {} : _param_classNames, items = param.items, translations = param.translations;
if (!items || items.length < 1) {
return null;
}
if (!translations.title) {
return null;
}
return /*#__PURE__*/ createElement("h3", {
className: classNames.title
}, translations.title);
}
function DefaultItem(param) {
var item = param.item;
return /*#__PURE__*/ createElement(Fragment, null, item.facetValue);
}
function DefaultEmpty() {
return /*#__PURE__*/ createElement(Fragment, null, "No results");
}
return function TrendingFacets(userProps) {
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, tmp = userProps.emptyComponent, EmptyComponent = tmp === void 0 ? DefaultEmpty : tmp, tmp1 = userProps.headerComponent, HeaderComponent = tmp1 === void 0 ? DefaultHeader : tmp1, tmp2 = userProps.itemComponent, ItemComponent = tmp2 === void 0 ? DefaultItem : tmp2, items = userProps.items, status = userProps.status, userTranslations = userProps.translations, props = _object_without_properties(userProps, [
"classNames",
"emptyComponent",
"headerComponent",
"itemComponent",
"items",
"status",
"translations"
]);
var translations = _object_spread({
title: 'Trending'
}, userTranslations);
var cssClasses = {
root: cx('ais-TrendingFacets', classNames.root),
emptyRoot: cx('ais-TrendingFacets', classNames.root, 'ais-TrendingFacets--empty', classNames.emptyRoot, props.className),
title: cx('ais-TrendingFacets-title', classNames.title),
container: cx('ais-TrendingFacets-container', classNames.container),
list: cx('ais-TrendingFacets-list', classNames.list),
item: cx('ais-TrendingFacets-item', classNames.item)
};
if (items.length === 0 && status === 'idle') {
return /*#__PURE__*/ createElement("section", _object_spread_props(_object_spread({}, props), {
className: cssClasses.emptyRoot
}), /*#__PURE__*/ createElement(EmptyComponent, null));
}
return /*#__PURE__*/ createElement("section", _object_spread_props(_object_spread({}, props), {
className: cssClasses.root
}), /*#__PURE__*/ createElement(HeaderComponent, {
classNames: cssClasses,
items: items,
translations: translations
}), /*#__PURE__*/ createElement("div", {
className: cssClasses.container
}, /*#__PURE__*/ createElement("ol", {
className: cssClasses.list
}, items.map(function(item, index) {
return /*#__PURE__*/ createElement("li", {
key: "".concat(item.facetName, ":").concat(item.facetValue, ":").concat(index),
className: cssClasses.item
}, /*#__PURE__*/ createElement(ItemComponent, {
item: item
}));
}))));
};
}
function createFilterSuggestionsComponent(param) {
var createElement = param.createElement;
var Button = createButtonComponent({
createElement: createElement
});
function DefaultHeader(param) {
var classNames = param.classNames;
return /*#__PURE__*/ createElement("div", {
className: cx('ais-FilterSuggestions-header', classNames.header)
}, /*#__PURE__*/ createElement("span", {
className: cx('ais-FilterSuggestions-headerIcon', classNames.headerIcon)
}, /*#__PURE__*/ createElement(SparklesIcon, {
createElement: createElement
})), /*#__PURE__*/ createElement("span", {
className: cx('ais-FilterSuggestions-headerTitle', classNames.headerTitle)
}, "Filter suggestions"));
}
function DefaultItem(param) {
var suggestion = param.suggestion, classNames = param.classNames, refine = param.refine;
return /*#__PURE__*/ createElement(Button, {
variant: "outline",
size: "sm",
className: cx(classNames.button),
onClick: refine
}, /*#__PURE__*/ createElement("span", {
className: cx('ais-FilterSuggestions-label', classNames.label)
}, suggestion.label, ": ", suggestion.value), /*#__PURE__*/ createElement("span", {
className: cx('ais-FilterSuggestions-count', classNames.count)
}, suggestion.count));
}
return function FilterSuggestions(userProps) {
var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, suggestions = userProps.suggestions, isLoading = userProps.isLoading, refine = userProps.refine, _userProps_skeletonCount = userProps.skeletonCount, skeletonCount = _userProps_skeletonCount === void 0 ? 3 : _userProps_skeletonCount, tmp = userProps.itemComponent, ItemComponent = tmp === void 0 ? DefaultItem : tmp, headerComponent = userProps.headerComponent, EmptyComponent = userProps.emptyComponent, props = _object_without_properties(userProps, [
"classNames",
"suggestions",
"isLoading",
"refine",
"skeletonCount",
"itemComponent",
"headerComponent",
"emptyComponent"
]);
var HeaderComponent = headerComponent === false ? null : headerComponent !== null && headerComponent !== void 0 ? headerComponent : DefaultHeader;
var isEmpty = suggestions.length === 0;
if (isEmpty && !isLoading) {
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-FilterSuggestions', classNames.root, 'ais-FilterSuggestions--empty', classNames.emptyRoot, props.className)
}), EmptyComponent && /*#__PURE__*/ createElement(EmptyComponent, {
classNames: {
emptyRoot: classNames.emptyRoot
}
}));
}
var headerClassNames = {
header: classNames.header,
headerIcon: classNames.headerIcon,
headerTitle: classNames.headerTitle
};
var itemClassNames = {
item: classNames.item,
button: classNames.button,
label: classNames.label,
count: classNames.count
};
return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-FilterSuggestions', classNames.root, isLoading && cx('ais-FilterSuggestions--loading', classNames.loadingRoot), props.className)
}), HeaderComponent && /*#__PURE__*/ createElement(HeaderComponent, {
classNames: headerClassNames
}), isLoading ? /*#__PURE__*/ createElement("div", {
className: cx('ais-FilterSuggestions-skeleton', classNames.skeleton)
}, _to_consumable_array(new Array(skeletonCount)).map(function(_, i) {
return /*#__PURE__*/ createElement("div", {
key: i,
className: cx('ais-FilterSuggestions-skeletonItem', classNames.skeletonItem)
});
})) : /*#__PURE__*/ createElement("ul", {
className: cx('ais-FilterSuggestions-list', classNames.list)
}, suggestions.map(function(suggestion) {
return /*#__PURE__*/ createElement("li", {
key: "".concat(suggestion.attribute, "-").concat(suggestion.value),
className: cx('ais-FilterSuggestions-item', classNames.item)
}, /*#__PURE__*/ createElement(ItemComponent, {
suggestion: suggestion,
classNames: itemClassNames,
refine: function refine1() {
return refine(suggestion.attribute, suggestion.value);
}
}));
})));
};
}
var DEFAULT_SPRING_ANIMATION = {
/**
* A value from 0 to 1, on how much to damp the animation.
* 0 means no damping, 1 means full damping.
*
* @default 0.7
*/ damping: 0.7,
/**
* The stiffness of how fast/slow the animation gets up to speed.
*
* @default 0.05
*/ stiffness: 0.05,
/**
* The inertial mass associated with the animation.
* Higher numbers make the animation slower.
*
* @default 1.25
*/ mass: 1.25
};
var STICK_TO_BOTTOM_OFFSET_PX = 70;
var SIXTY_FPS_INTERVAL_MS = 1000 / 60;
var RETAIN_ANIMATION_DURATION_MS = 350;
var mouseDown = false;
if (typeof window !== 'undefined') {
var _window_document, _window_document1, _window_document2;
(_window_document = window.document) === null || _window_document === void 0 ? void 0 : _window_document.addEventListener('mousedown', function() {
mouseDown = true;
});
(_window_document1 = window.document) === null || _window_document1 === void 0 ? void 0 : _window_document1.addEventListener('mouseup', function() {
mouseDown = false;
});
(_window_document2 = window.document) === null || _window_document2 === void 0 ? void 0 : _window_document2.addEventListener('click', function() {
mouseDown = false;
});
}
function createStickToBottom(param) {
var useCallback = param.useCallback, useEffect = param.useEffect, useMemo = param.useMemo, useRef = param.useRef, useState = param.useState;
return function useStickToBottom() {
var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var _useState = _sliced_to_array(useState(false), 2), escapedFromLock = _useState[0], updateEscapedFromLock = _useState[1];
var _useState1 = _sliced_to_array(useState(options.initial !== false), 2), isAtBottom = _useState1[0], updateIsAtBottom = _useState1[1];
var _useState2 = _sliced_to_array(useState(false), 2), isNearBottom = _useState2[0], setIsNearBottom = _useState2[1];
var optionsRef = useRef(null);
optionsRef.current = options;
// Create refs early so they can be used in other hooks
var scrollRef = useRef(null);
var contentRef = useRef(null);
var isSelecting = useCallback(function() {
var _scrollRef_current;
if (!mouseDown) {
return false;
}
if (typeof window === 'undefined') {
return false;
}
var selection = window.getSelection();
if (!selection || !selection.rangeCount) {
return false;
}
var range = selection.getRangeAt(0);
return range.commonAncestorContainer.contains(scrollRef.current) || ((_scrollRef_current = scrollRef.current) === null || _scrollRef_current === void 0 ? void 0 : _scrollRef_current.contains(range.commonAncestorContainer));
}, []);
// biome-ignore lint/correctness/useExhaustiveDependencies: state is intentionally stable
var state = useMemo(function() {
var lastCalculation;
return {
escapedFromLock: escapedFromLock,
isAtBottom: isAtBottom,
resizeDifference: 0,
accumulated: 0,
velocity: 0,
get scrollTop () {
var _ref;
var _scrollRef_current;
return (_ref = (_scrollRef_current = scrollRef.current) === null || _scrollRef_current === void 0 ? void 0 : _scrollRef_current.scrollTop) !== null && _ref !== void 0 ? _ref : 0;
},
set scrollTop (scrollTop){
if (scrollRef.current) {
scrollRef.current.scrollTop = scrollTop;
state.ignoreScrollToTop = scrollRef.current.scrollTop;
}
},
get targetScrollTop () {
if (!scrollRef.current || !contentRef.current) {
return 0;
}
return scrollRef.current.scrollHeight - 1 - scrollRef.current.clientHeight;
},
get calculatedTargetScrollTop () {
if (!scrollRef.current || !contentRef.current) {
return 0;
}
var targetScrollTop = this.targetScrollTop;
if (!optionsRef.current.targetScrollTop) {
return targetScrollTop;
}
if ((lastCalculation === null || lastCalculation === void 0 ? void 0 : lastCalculation.targetScrollTop) === targetScrollTop) {
return lastCalculation.calculatedScrollTop;
}
var calculatedScrollTop = Math.max(Math.min(optionsRef.current.targetScrollTop(targetScrollTop, {
scrollElement: scrollRef.current,
contentElement: contentRef.current
}), targetScrollTop), 0);
lastCalculation = {
targetScrollTop: targetScrollTop,
calculatedScrollTop: calculatedScrollTop
};
requestAnimationFrame(function() {
lastCalculation = undefined;
});
return calculatedScrollTop;
},
get scrollDifference () {
return this.calculatedTargetScrollTop - this.scrollTop;
},
get isNearBottom () {
return this.scrollDifference <= STICK_TO_BOTTOM_OFFSET_PX;
}
};
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []);
var setIsAtBottom = useCallback(function(value) {
state.isAtBottom = value;
updateIsAtBottom(value);
}, [
state
]);
var setEscapedFromLock = useCallback(function(value) {
state.escapedFromLock = value;
updateEscapedFromLock(value);
}, [
state
]);
var scrollToBottom = useCallback(function() {
var scrollOptions = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var _state_animation;
if (typeof scrollOptions === 'string') {
scrollOptions = {
animation: scrollOptions
};
}
if (!scrollOptions.preserveScrollPosition) {
setIsAtBottom(true);
}
var waitElapsed = Date.now() + (Number(scrollOptions.wait) || 0);
var behavior = mergeAnimations(optionsRef.current, scrollOptions.animation);
var _scrollOptions_ignoreEscapes = scrollOptions.ignoreEscapes, ignoreEscapes = _scrollOptions_ignoreEscapes === void 0 ? false : _scrollOptions_ignoreEscapes;
var durationElapsed;
var startTarget = state.calculatedTargetScrollTop;
if (_instanceof(scrollOptions.duration, Promise)) {
scrollOptions.duration.then(function() {
durationElapsed = Date.now();
}, function() {
durationElapsed = Date.now();
});
} else {
var _scrollOptions_duration;
durationElapsed = waitElapsed + ((_scrollOptions_duration = scrollOptions.duration) !== null && _scrollOptions_duration !== void 0 ? _scrollOptions_duration : 0);
}
var next = function next1() {
var promise = new Promise(requestAnimationFrame).then(function() {
var _state_lastTick, _state;
if (!state.isAtBottom) {
state.animation = undefined;
return false;
}
var scrollTop1 = state.scrollTop;
var tick = performance.now();
var tickDelta = (tick - ((_state_lastTick = state.lastTick) !== null && _state_lastTick !== void 0 ? _state_lastTick : tick)) / SIXTY_FPS_INTERVAL_MS;
(_state = state).animation || (_state.animation = {
behavior: behavior,
promise: promise,
ignoreEscapes: ignoreEscapes
});
if (state.animation.behavior === behavior) {
state.lastTick = tick;
}
if (isSelecting()) {
return next();
}
if (waitElapsed > Date.now()) {
return next();
}
if (scrollTop1 < Math.min(startTarget, state.calculatedTargetScrollTop)) {
var _state_animation;
if (((_state_animation = state.animation) === null || _state_animation === void 0 ? void 0 : _state_animation.behavior) === behavior) {
if (behavior === 'instant') {
state.scrollTop = state.calculatedTargetScrollTop;
return next();
}
state.velocity = (behavior.damping * state.velocity + behavior.stiffness * state.scrollDifference) / behavior.mass;
state.accumulated += state.velocity * tickDelta;
state.scrollTop += state.accumulated;
if (state.scrollTop !== scrollTop1) {
state.accumulated = 0;
}
}
return next();
}
if (durationElapsed > Date.now()) {
startTarget = state.calculatedTargetScrollTop;
return next();
}
state.animation = undefined;
/**
* If we're still below the target, then queue
* up another scroll to the bottom with the last
* requested animatino.
*/ if (state.scrollTop < state.calculatedTargetScrollTop) {
return scrollToBottom({
animation: mergeAnimations(optionsRef.current, optionsRef.current.resize),
ignoreEscapes: ignoreEscapes,
duration: Math.max(0, durationElapsed - Date.now()) || undefined
});
}
return state.isAtBottom;
});
return promise.then(function(result) {
requestAnimationFrame(function() {
if (!state.animation) {
state.lastTick = undefined;
state.velocity = 0;
}
});
return result;
});
};
if (scrollOptions.wait !== true) {
state.animation = undefined;
}
if (((_state_animation = state.animation) === null || _state_animation === void 0 ? void 0 : _state_animation.behavior) === behavior) {
return state.animation.promise;
}
return next();
}, [
setIsAtBottom,
isSelecting,
state
]);
var stopScroll = useCallback(function() {
setEscapedFromLock(true);
setIsAtBottom(false);
}, [
setEscapedFromLock,
setIsAtBottom
]);
var handleScroll = useCallback(function(param) {
var target = param.target;
if (target !== scrollRef.current) {
return;
}
var scrollTop1 = state.scrollTop, ignoreScrollToTop = state.ignoreScrollToTop;
var _state_lastScrollTop = state.lastScrollTop, lastScrollTop = _state_lastScrollTop === void 0 ? scrollTop1 : _state_lastScrollTop;
var isNearBottom = state.isNearBottom;
state.lastScrollTop = scrollTop1;
state.ignoreScrollToTop = undefined;
if (ignoreScrollToTop && ignoreScrollToTop > scrollTop1) {
/**
* When the user scrolls up while the animation plays, the `scrollTop` may
* not come in separate events; if this happens, to make sure `isScrollingUp`
* is correct, set the lastScrollTop to the ignored event.
*/ lastScrollTop = ignoreScrollToTop;
}
setIsNearBottom(isNearBottom);
/**
* Scroll events may come before a ResizeObserver event,
* so in order to ignore resize events correctly we use a
* timeout.
*
* @see https://github.com/WICG/resize-observer/issues/25#issuecomment-248757228
*/ setTimeout(function() {
var _state_animation;
/**
* When theres a resize difference ignore the resize event.
*/ if (state.resizeDifference || scrollTop1 === ignoreScrollToTop) {
return;
}
if (isSelecting()) {
setEscapedFromLock(true);
setIsAtBottom(false);
return;
}
var isScrollingDown = scrollTop1 > lastScrollTop;
var isScrollingUp = scrollTop1 < lastScrollTop;
if ((_state_animation = state.animation) === null || _state_animation === void 0 ? void 0 : _state_animation.ignoreEscapes) {
state.scrollTop = lastScrollTop;
return;
}
if (isScrollingUp) {
setEscapedFromLock(true);
setIsAtBottom(false);
}
if (isScrollingDown) {
setEscapedFromLock(false);
}
if (!state.escapedFromLock && isNearBottom) {
setIsAtBottom(true);
}
}, 1);
}, [
setEscapedFromLock,
setIsAtBottom,
isSelecting,
state
]);
var handleWheel = useCallback(function(param) {
var target = param.target, deltaY = param.deltaY;
var _state_animation;
var element = target;
while(![
'scroll',
'auto'
].includes(getComputedStyle(element).overflow)){
if (!element.parentElement) {
return;
}
element = element.parentElement;
}
/**
* The browser may cancel the scrolling from the mouse wheel
* if we update it from the animation in meantime.
* To prevent this, always escape when the wheel is scrolled up.
*/ if (element === scrollRef.current && deltaY < 0 && scrollRef.current.scrollHeight > scrollRef.current.clientHeight && !((_state_animation = state.animation) === null || _state_animation === void 0 ? void 0 : _state_animation.ignoreEscapes)) {
setEscapedFromLock(true);
setIsAtBottom(false);
}
}, [
setEscapedFromLock,
setIsAtBottom,
state
]);
// Attach scroll and wheel event listeners
useEffect(function() {
var scroll = scrollRef.current;
if (!scroll) {
return undefined;
}
scroll.addEventListener('scroll', handleScroll, {
passive: true
});
scroll.addEventListener('wheel', handleWheel, {
passive: true
});
return function() {
scroll.removeEventListener('scroll', handleScroll);
scroll.removeEventListener('wheel', handleWheel);
};
}, [
handleScroll,
handleWheel
]);
// Attach ResizeObserver to content element
useEffect(function() {
var content = contentRef.current;
if (!content) {
return undefined;
}
var previousHeight;
var resizeObserver = new ResizeObserver(function(param) {
var _param = _sliced_to_array(param, 1), entry = _param[0];
var height = entry.contentRect.height;
var difference = height - (previousHeight !== null && previousHeight !== void 0 ? previousHeight : height);
state.resizeDifference = difference;
/**
* Sometimes the browser can overscroll past the target,
* so check for this and adjust appropriately.
*/ if (state.scrollTop > state.targetScrollTop) {
state.scrollTop = state.targetScrollTop;
}
setIsNearBottom(state.isNearBottom);
if (difference >= 0) {
/**
* If it's a positive resize, scroll to the bottom when
* we're already at the bottom.
*/ var animation = mergeAnimations(optionsRef.current, previousHeight ? optionsRef.current.resize : optionsRef.current.initial);
scrollToBottom({
animation: animation,
wait: true,
preserveScrollPosition: true,
duration: animation === 'instant' ? undefined : RETAIN_ANIMATION_DURATION_MS
});
} else if (state.isNearBottom) {
/**
* Else if it's a negative resize, check if we're near the bottom
* if we are want to un-escape from the lock, because the resize
* could have caused the container to be at the bottom.
*/ setEscapedFromLock(false);
setIsAtBottom(true);
}
previousHeight = height;
/**
* Reset the resize difference after the scroll event
* has fired. Requires a rAF to wait for the scroll event,
* and a setTimeout to wait for the other timeout we have in
* resizeObserver in case the scroll event happens after the
* resize event.
*/ requestAnimationFrame(function() {
setTimeout(function() {
if (state.resizeDifference === difference) {
state.resizeDifference = 0;
}
}, 1);
});
});
resizeObserver.observe(content);
state.resizeObserver = resizeObserver;
return function() {
resizeObserver.disconnect();
state.resizeObserver = undefined;
};
}, [
state,
setIsNearBottom,
setEscapedFromLock,
setIsAtBottom,
scrollToBottom
]);
return {
contentRef: contentRef,
scrollRef: scrollRef,
scrollToBottom: scrollToBottom,
stopScroll: stopScroll,
isAtBottom: isAtBottom || isNearBottom,
isNearBottom: isNearBottom,
escapedFromLock: escapedFromLock,
state: state
};
};
}
var animationCache = new Map();
function mergeAnimations() {
for(var _len = arguments.length, animations = new Array(_len), _key = 0; _key < _len; _key++){
animations[_key] = arguments[_key];
}
var result = _object_spread({}, DEFAULT_SPRING_ANIMATION);
var instant = false;
animations.forEach(function(animation) {
var _animation_damping, _animation_stiffness, _animation_mass;
if (animation === 'instant') {
instant = true;
return;
}
if ((typeof animation === "undefined" ? "undefined" : _type_of(animation)) !== 'object') {
return;
}
instant = false;
result.damping = (_animation_damping = animation.damping) !== null && _animation_damping !== void 0 ? _animation_damping : result.damping;
result.stiffness = (_animation_stiffness = animation.stiffness) !== null && _animation_stiffness !== void 0 ? _animation_stiffness : result.stiffness;
result.mass = (_animation_mass = animation.mass) !== null && _animation_mass !== void 0 ? _animation_mass : result.mass;
});
var key = JSON.stringify(result);
if (!animationCache.has(key)) {
animationCache.set(key, Object.freeze(result));
}
return instant ? 'instant' : animationCache.get(key);
}
var PROMPT_SUGGESTION_FLAG = '__isPromptSuggestion';
function getPromptSuggestionHits(param) {
var hits = param.hits, limit = param.limit;
return hits.slice(0, limit).map(function(hit) {
return _object_spread_props(_object_spread({}, hit), _define_property({}, PROMPT_SUGGESTION_FLAG, true));
});
}
function isPromptSuggestion(item) {
return Boolean(item && (typeof item === "undefined" ? "undefined" : _type_of(item)) === 'object' && item[PROMPT_SUGGESTION_FLAG]);
}
var tryParseJson = function tryParseJson(value) {
try {
return JSON.parse(value);
} catch (unused) {
return undefined;
}
};
var repairPartialJson = function repairPartialJson(value) {
var repaired = value.trim();
if (!repaired) {
return repaired;
}
var inString = false;
var isEscaped = false;
var stack = [];
for(var index = 0; index < repaired.length; index++){
var char = repaired[index];
if (inString) {
if (isEscaped) {
isEscaped = false;
} else if (char === '\\') {
isEscaped = true;
} else if (char === '"') {
inString = false;
}
continue;
}
if (char === '"') {
inString = true;
continue;
}
if (char === '{' || char === '[') {
stack.push(char);
continue;
}
if (char === '}' && stack[stack.length - 1] === '{') {
stack.pop();
continue;
}
if (char === ']' && stack[stack.length - 1] === '[') {
stack.pop();
}
}
if (inString && !isEscaped) {
repaired += '"';
}
repaired = repaired.replace(RegExp(",\\s*$", "u"), '');
if (stack.length > 0) {
repaired += stack.reverse().map(function(opening) {
return opening === '{' ? '}' : ']';
}).join('');
}
return repaired.replace(RegExp(",\\s*([}\\]])", "gu"), '$1');
};
var parsePartialJson = function parsePartialJson(accumulatedRawJson, fallbackValue) {
var normalized = accumulatedRawJson.trim();
if (!normalized) {
return fallbackValue;
}
var directParsed = tryParseJson(normalized);
if (directParsed !== undefined) {
return directParsed;
}
var repairedParsed = tryParseJson(repairPartialJson(normalized));
if (repairedParsed !== undefined) {
return repairedParsed;
}
return fallbackValue;
};
/**
* Stream parser for parsing SSE (Server-Sent Events) streams.
* The AI SDK 5 format uses SSE with JSON payloads prefixed by "data: ".
*/ /**
* Parse a stream of bytes as SSE (Server-Sent Events) and convert to UIMessageChunk events.
* Handles the "data: " prefix used by the AI SDK 5 streaming format.
*
* @param stream - The input stream of raw bytes
* @returns A ReadableStream of parsed UIMessageChunk events
*/ function parseJsonEventStream(stream) {
var decoder = new TextDecoder();
var buffer = '';
return new ReadableStream({
start: function start(controller) {
var reader = stream.getReader();
var processChunk = function processChunk1() {
reader.read().then(function(param) {
var done = param.done, value = param.value;
if (done) {
// Process any remaining data in the buffer
if (buffer.trim()) {
var jsonData = extractJsonFromLine(buffer.trim());
if (jsonData) {
try {
var chunk = JSON.parse(jsonData);
controller.enqueue(chunk);
} catch (unused) {
// Ignore parsing errors for incomplete data at end
}
}
}
controller.close();
return;
}
// Decode the chunk and add to buffer
buffer += decoder.decode(value, {
stream: true
});
// Process complete lines
var lines = buffer.split('\n');
// Keep the last potentially incomplete line in the buffer
buffer = lines.pop() || '';
for(var i = 0; i < lines.length; i++){
var trimmedLine = lines[i].trim();
// eslint-disable-next-line no-continue
if (!trimmedLine) continue;
// Extract JSON from SSE data line or plain JSON
var jsonData1 = extractJsonFromLine(trimmedLine);
// eslint-disable-next-line no-continue
if (!jsonData1) continue;
try {
var chunk1 = JSON.parse(jsonData1);
controller.enqueue(chunk1);
} catch (unused) {
// Skip malformed lines
}
}
// Continue reading
processChunk();
}, function(error) {
controller.error(error);
});
};
processChunk();
}
});
}
/**
* Extract JSON data from an SSE line or plain JSON line.
* Handles both "data: {...}" SSE format and plain "{...}" NDJSON format.
*/ function extractJsonFromLine(line) {
// Handle SSE format: "data: {...}"
if (line.startsWith('data:')) {
var data = line.slice(5).trim();
// Skip SSE stream termination signal
if (data === '[DONE]') return null;
return data;
}
// Handle plain JSON (NDJSON format)
if (line.startsWith('{')) {
return line;
}
// Skip other SSE fields (event:, id:, retry:, etc.)
return null;
}
/**
* Process a ReadableStream using a callback for each value.
* This is a non-async alternative to for-await-of iteration.
*/ function processStream(stream, onChunk, onDone, onError) {
var reader = stream.getReader();
var read = function read1() {
reader.read().then(function(param) {
var done = param.done, value = param.value;
if (done) {
reader.releaseLock();
onDone();
return;
}
try {
var result = onChunk(value);
if (result && typeof result.then === 'function') {
result.then(function() {
return read();
}, function(error) {
reader.releaseLock();
onError(error);
});
} else {
read();
}
} catch (error) {
reader.releaseLock();
onError(error);
}
}, function(error) {
reader.releaseLock();
onError(error);
});
};
read();
}
function _construct(Parent, args, Class) {
if (_is_native_reflect_construct()) _construct = Reflect.construct;
else {
_construct = function construct(Parent, args, Class) {
var a = [null];
a.push.apply(a, args);
var Constructor = Function.bind.apply(Parent, a);
var instance = new Constructor();
if (Class) _set_prototype_of(instance, Class.prototype);
return instance;
};
}
return _construct.apply(null, arguments);
}
function _is_native_function(fn) {
return Function.toString.call(fn).indexOf("[native code]") !== -1;
}
function _wrap_native_super(Class) {
var _cache = typeof Map === "function" ? new Map() : undefined;
_wrap_native_super = function(Class) {
if (Class === null || !_is_native_function(Class)) return Class;
if (typeof Class !== "function") throw new TypeError("Super expression must either be null or a function");
if (typeof _cache !== "undefined") {
if (_cache.has(Class)) return _cache.get(Class);
_cache.set(Class, Wrapper);
}
function Wrapper() {
return _construct(Class, arguments, _get_prototype_of(this).constructor);
}
Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
return _set_prototype_of(Wrapper, Class);
};
return _wrap_native_super(Class);
}
function generateId() {
return Math.random().toString(36).substring(2, 9);
}
function isToolOrDynamicToolUIPart(part) {
if ((typeof part === "undefined" ? "undefined" : _type_of(part)) !== 'object' || part === null) return false;
var p = part;
return typeof p.type === 'string' && (p.type.startsWith('tool-') || p.type === 'dynamic-tool');
}
function lastAssistantMessageIsCompleteWithToolCalls(param) {
var messages = param.messages;
if (messages.length === 0) return false;
var lastMessage = messages[messages.length - 1];
if (lastMessage.role !== 'assistant') return false;
if (!lastMessage.parts || lastMessage.parts.length === 0) return false;
// Only the last step of the message counts: earlier steps were answered
// before the model was called again, so their resolved tool calls must not
// continue the turn a second time.
var lastStepStartIndex = lastMessage.parts.reduce(function(lastIndex, part, index) {
return part.type === 'step-start' ? index : lastIndex;
}, -1);
var toolParts = lastMessage.parts.slice(lastStepStartIndex + 1).filter(isToolOrDynamicToolUIPart) // A provider-executed tool call is the provider's to answer, so a turn
// made of them is already complete — continuing would resend it.
.filter(function(part) {
return !part.providerExecuted;
});
if (toolParts.length === 0) return false;
return toolParts.every(function(part) {
return part.state === 'output-available' || part.state === 'output-error';
});
}
var SerialJobExecutor = /*#__PURE__*/ function() {
function SerialJobExecutor() {
_class_call_check(this, SerialJobExecutor);
_define_property(this, "queue", []);
_define_property(this, "isRunning", false);
}
_create_class(SerialJobExecutor, [
{
key: "run",
value: function run(job) {
var _this = this;
return new Promise(function(resolve, reject) {
_this.queue.push(function() {
return job().then(function(result) {
resolve(result);
}, function(error) {
reject(error);
});
});
_this.processQueue();
});
}
},
{
key: "processQueue",
value: function processQueue() {
var _this = this;
if (this.isRunning) return;
this.isRunning = true;
var processNext = function processNext1() {
if (_this.queue.length === 0) {
_this.isRunning = false;
return;
}
var job = _this.queue.shift();
if (job) {
job().then(processNext, processNext);
}
};
processNext();
}
}
]);
return SerialJobExecutor;
}();
function resolveValue(value) {
if (value === undefined) return Promise.resolve(undefined);
if (typeof value === 'function') {
return Promise.resolve(value());
}
return Promise.resolve(value);
}
/**
* Error shape for custom chat implementations that still surface a
* `data-guardrail-violation` chunk through the error UI. The `message` carries
* the service-provided `fallbackResponse`, which is authored for end-user
* display.
*
* Detection across package boundaries should rely on `error.name` rather than
* `instanceof` to avoid issues with mixed module copies in bundled apps.
*/ /*#__PURE__*/ (function(Error1) {
_inherits(GuardrailViolationError, Error1);
function GuardrailViolationError(message) {
_class_call_check(this, GuardrailViolationError);
var _this;
_this = _call_super(this, GuardrailViolationError, [
message
]);
_this.name = 'GuardrailViolationError';
return _this;
}
return GuardrailViolationError;
})(_wrap_native_super(Error));
/**
* Reads a non-empty `message` field off a JSON-serialized error envelope.
*
* Both transports backing `AbstractChat` (stream `error` chunks and HTTP error
* responses) serialize errors as `{"message": "...", ...}` — the same shape as
* the shared `ErrorResponse` on the API side. Returns the trimmed message if
* the input is such a JSON object, otherwise `undefined`.
*/ function tryParseErrorMessage(text) {
try {
var parsed = JSON.parse(text);
if (parsed && (typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) === 'object' && !Array.isArray(parsed) && typeof parsed.message === 'string') {
var message = parsed.message.trim();
if (message) {
return message;
}
}
} catch (unused) {
// Not JSON — caller falls back to its own default.
}
return undefined;
}
var _computedKey$1;
var defaultGuardrailFallbackResponse = 'Sorry, we are not able to generate a response at the moment.';
var TOOL_CALL_CANCELLED_ERROR_TEXT = 'The tool call was cancelled: the conversation moved on before a result was provided.';
var RESTORED_TOOL_CALL_ERROR_TEXT = 'The page was reloaded before a tool result was received. The operation may have completed.';
var RESTORED_TOOL_INPUT_ERROR_TEXT = 'The page was reloaded before the tool input was complete. The operation was not started.';
function getTerminalToolState(options) {
if (options.state === 'output-error') {
return {
state: 'output-error',
errorText: options.errorText || 'Tool call failed.'
};
}
if (options.state === undefined && 'errorText' in options && typeof options.errorText === 'string') {
return {
state: 'output-error',
errorText: options.errorText || 'Tool call failed.'
};
}
return {
state: 'output-available',
output: options.output
};
}
function getToolName(part) {
if (part.type === 'dynamic-tool') {
var _part_toolName;
return (_part_toolName = part.toolName) !== null && _part_toolName !== void 0 ? _part_toolName : part.type;
}
return part.type.slice('tool-'.length);
}
function warnInvalidGlobalToolResult(toolCallId) {}
// A tool call awaiting an output that the client owns. Provider-executed calls
// are resolved server-side, so they are left alone.
function isPendingToolPart(part) {
var candidate = part;
return typeof candidate.type === 'string' && typeof candidate.toolCallId === 'string' && (candidate.state === 'input-streaming' || candidate.state === 'input-available') && candidate.providerExecuted !== true;
}
// Drops the fields that only belong to the state being left behind:
// `output-error` forbids `output`, and a committed output is not `preliminary`.
function withTerminalToolState(part, terminalState) {
// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
part.preliminary; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
part.rawOutput; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
part.output; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
part.errorText;
var retainedPart = _object_without_properties(part, [
"preliminary",
"rawOutput",
"output",
"errorText"
]);
return _object_spread({}, retainedPart, terminalState);
}
_computedKey$1 = /** @internal */ '~addToolResultForMessage';
var _computedKey1$1 = _computedKey$1;
/**
* Abstract base class for chat implementations.
*/ var AbstractChat = /*#__PURE__*/ function() {
function AbstractChat(param) {
var _this = this;
var _param_generateId = param.generateId, generateId$1 = _param_generateId === void 0 ? generateId : _param_generateId, _param_id = param.id, id = _param_id === void 0 ? generateId$1() : _param_id, transport = param.transport, state = param.state, onError = param.onError, onToolCall = param.onToolCall, onFinish = param.onFinish, onData = param.onData, sendAutomaticallyWhen = param.sendAutomaticallyWhen, shouldRepairToolInput = param.shouldRepairToolInput, shouldRepairRestoredPendingToolPart = param.shouldRepairRestoredPendingToolPart, resolveCancelledToolOutput = param.resolveCancelledToolOutput;
var _this1 = this;
_class_call_check(this, AbstractChat);
_define_property(this, "conversationId", void 0);
_define_property(this, "generateId", void 0);
_define_property(this, "state", void 0);
_define_property(this, "transport", void 0);
_define_property(this, "onError", void 0);
_define_property(this, "onToolCall", void 0);
_define_property(this, "onFinish", void 0);
_define_property(this, "onData", void 0);
_define_property(this, "sendAutomaticallyWhen", void 0);
_define_property(this, "shouldRepairToolInput", void 0);
_define_property(this, "shouldRepairRestoredPendingToolPart", void 0);
_define_property(this, "resolveCancelledToolOutput", void 0);
_define_property(this, "activeResponse", null);
_define_property(this, "latestResponse", null);
_define_property(this, "responsesByToolCallId", new Map());
_define_property(this, "responseByMessage", new WeakMap());
_define_property(this, "restoredToolCalls", void 0);
// Once tool ownership is discarded, an identifier-only result cannot prove
// which response generation submitted it. Scoped submissions remain safe.
_define_property(this, "acceptsIdentifierOnlyToolResults", true);
_define_property(this, "jobExecutor", new SerialJobExecutor());
/**
* Appends or replaces a user message to the chat list. This triggers the API call to fetch
* the assistant's response.
*/ _define_property(this, "sendMessage", function(message, options) {
return _this.jobExecutor.run(function() {
// Build the user message
var userMessagePromise;
if (message) {
var messageId = message.messageId || _this.generateId();
if ('parts' in message && message.parts) {
// Full message with parts provided
userMessagePromise = Promise.resolve(_object_spread({
id: messageId,
role: 'user'
}, message));
} else if ('text' in message && message.text) {
// Build from text
var parts = [
{
type: 'text',
text: message.text
}
];
// Add file parts if provided
if (message.files) {
userMessagePromise = _this.convertFilesToParts(message.files).then(function(fileParts) {
var _parts;
(_parts = parts).push.apply(_parts, _to_consumable_array(fileParts));
return {
id: messageId,
role: 'user',
parts: parts,
metadata: message.metadata
};
});
} else {
userMessagePromise = Promise.resolve({
id: messageId,
role: 'user',
parts: parts,
metadata: message.metadata
});
}
} else if ('files' in message && message.files) {
// Files only
userMessagePromise = _this.convertFilesToParts(message.files).then(function(fileParts) {
return {
id: messageId,
role: 'user',
parts: fileParts,
metadata: message.metadata
};
});
} else {
userMessagePromise = Promise.resolve(undefined);
}
} else {
userMessagePromise = Promise.resolve(undefined);
}
return userMessagePromise.then(function(userMessage) {
if (userMessage) {
_this.state.pushMessage(userMessage);
}
return _this.makeRequest(_object_spread({
trigger: 'submit-message',
messageId: userMessage === null || userMessage === void 0 ? void 0 : userMessage.id
}, options));
});
});
});
/**
* Regenerate the assistant message with the provided message id.
* If no message id is provided, the last assistant message will be regenerated.
*/ _define_property(this, "regenerate", function() {
var _0 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : void 0;
var _ref = [
_0
], _ref1 = _sliced_to_array(_ref, 1), tmp = _ref1[0], _ref2 = tmp === void 0 ? {} : tmp, messageId = _ref2.messageId, options = _object_without_properties(_ref2, [
"messageId"
]);
return _this1.jobExecutor.run(function() {
// Find the message to regenerate from
var targetIndex = -1;
if (messageId) {
targetIndex = _this1.messages.findIndex(function(m) {
return m.id === messageId;
});
} else {
// Find the last assistant message
for(var i = _this1.messages.length - 1; i >= 0; i--){
if (_this1.messages[i].role === 'assistant') {
targetIndex = i;
break;
}
}
}
if (targetIndex >= 0) {
// Remove the assistant message and all messages after it
_this1.messages = _this1.messages.slice(0, targetIndex);
}
return _this1.makeRequest(_object_spread({
trigger: 'regenerate-message',
messageId: messageId
}, options));
});
});
/**
* Attempt to resume an ongoing streaming response.
*/ _define_property(this, "resumeStream", function(options) {
return _this.jobExecutor.run(function() {
if (!_this.transport) {
return Promise.reject(new Error('Transport is required for resuming stream. Please provide a transport when initializing the chat.'));
}
return _this.consume(function() {
return _this.transport.reconnectToStream(_object_spread({
chatId: _this.id
}, options));
});
});
});
/**
* Clear the error state and set the status to ready if the chat is in an error state.
*/ _define_property(this, "clearError", function() {
if (_this.state.status === 'error') {
_this.setStatus({
status: 'ready',
error: undefined
});
}
});
/**
* Add a tool result for a tool call.
*/ _define_property(this, "addToolResult", function(options) {
if (!_this.acceptsIdentifierOnlyToolResults) {
warnInvalidGlobalToolResult(options.toolCallId);
return Promise.resolve();
}
var owners = _this.responsesByToolCallId.get(options.toolCallId);
var response = (owners === null || owners === void 0 ? void 0 : owners.size) === 1 ? owners.values().next().value : undefined;
if (response) return _this.submitToolResult(response, options);
var findMatchingMessage = function findMatchingMessage() {
var matchingMessages = _this.messages.filter(function(message) {
var _message_parts;
return (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.some(function(part) {
return 'toolCallId' in part && part.toolCallId === options.toolCallId;
});
});
return matchingMessages.length === 1 ? matchingMessages[0] : undefined;
};
if (!findMatchingMessage()) {
warnInvalidGlobalToolResult(options.toolCallId);
return Promise.resolve();
}
return _this.jobExecutor.run(function() {
if (!_this.acceptsIdentifierOnlyToolResults) {
warnInvalidGlobalToolResult(options.toolCallId);
return Promise.resolve();
}
var message = findMatchingMessage();
if (!message) {
warnInvalidGlobalToolResult(options.toolCallId);
return Promise.resolve();
}
if (!_this.commit(options.toolCallId, getTerminalToolState(options), message.id, undefined, message)) {
return Promise.resolve();
}
return _this.continueResponse();
});
});
_define_property(this, _computedKey1$1, function(message, options) {
var hasToolCall = function hasToolCall(candidate) {
var _candidate_parts;
return ((_candidate_parts = candidate.parts) === null || _candidate_parts === void 0 ? void 0 : _candidate_parts.some(function(part) {
return 'toolCallId' in part && part.toolCallId === options.toolCallId;
})) === true;
};
if (!hasToolCall(message)) {
return Promise.resolve();
}
var response = _this.responseByMessage.get(message);
var currentMessage = _this.messages.includes(message) ? message : response && !response.isRetired ? _this.messages.find(function(candidate) {
return candidate.id === message.id && _this.responseByMessage.get(candidate) === response && hasToolCall(candidate);
}) : undefined;
if (!currentMessage) return Promise.resolve();
return _this.submitToolResult(response, options, currentMessage.id, currentMessage);
});
/**
* Abort the current request immediately, keep the generated tokens if any.
*/ _define_property(this, "stop", function() {
if (_this.activeResponse) {
var response = _this.activeResponse;
response.outcome = 'aborted';
_this.activeResponse = null;
response.abortController.abort();
}
_this.setStatus({
status: 'ready'
});
return Promise.resolve();
});
this.conversationId = id;
this.generateId = generateId$1;
this.state = state;
this.transport = transport;
this.onError = onError;
this.onToolCall = onToolCall;
this.onFinish = onFinish;
this.onData = onData;
this.sendAutomaticallyWhen = sendAutomaticallyWhen;
this.shouldRepairToolInput = shouldRepairToolInput;
this.shouldRepairRestoredPendingToolPart = shouldRepairRestoredPendingToolPart;
this.resolveCancelledToolOutput = resolveCancelledToolOutput;
}
_create_class(AbstractChat, [
{
key: "id",
get: function get() {
return this.conversationId;
}
},
{
key: "status",
get: /**
* Hook status:
*
* - `submitted`: The message has been sent to the API and we're awaiting the start of the response stream.
* - `streaming`: The response is actively streaming in from the API, receiving chunks of data.
* - `ready`: The full response has been received and processed; a new user message can be submitted.
* - `error`: An error occurred during the API request, preventing successful completion.
*/ function get() {
return this.state.status;
}
},
{
key: "setStatus",
value: function setStatus(param) {
var status = param.status, error = param.error;
this.state.status = status;
if (error !== undefined) {
this.state.error = error;
}
}
},
{
key: "error",
get: function get() {
return this.state.error;
}
},
{
/**
* Starts a new server-side conversation thread by rotating the id sent as
* `chatId` / `id` on the next request. The InstantSearch connector calls this
* after the user clears the transcript so completions are not tied to prior
* context.
*/ key: "resetConversationId",
value: function resetConversationId() {
if (this.responsesByToolCallId.size > 0 || this.messages.some(function(message) {
var _message_parts;
return (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.some(function(part) {
return 'toolCallId' in part;
});
})) {
this.acceptsIdentifierOnlyToolResults = false;
}
this.conversationId = this.generateId();
}
},
{
key: "messages",
get: function get() {
return this.state.messages;
},
set: function set(messages) {
var _this = this;
var getToolOccurrences = function getToolOccurrences(message) {
return message.parts.filter(function(part) {
return 'toolCallId' in part;
}).map(function(part) {
return {
type: part.type,
toolCallId: part.toolCallId,
state: 'state' in part ? part.state : undefined,
input: 'input' in part ? part.input : undefined,
output: 'output' in part ? part.output : undefined,
errorText: 'errorText' in part ? part.errorText : undefined,
providerExecuted: 'providerExecuted' in part ? part.providerExecuted : undefined
};
});
};
var isEquivalentRehydration = function isEquivalentRehydration(message) {
var replacements = messages.filter(function(candidate) {
return candidate.id === message.id;
});
if (replacements.length !== 1) return false;
var toolOccurrences = getToolOccurrences(message);
var replacementToolOccurrences = getToolOccurrences(replacements[0]);
return toolOccurrences.length > 0 || replacementToolOccurrences.length > 0 ? isEqual(toolOccurrences, replacementToolOccurrences) : isEqual(message.parts, replacements[0].parts);
};
var detachedResponses = new Set();
this.state.messages.forEach(function(message) {
if (!messages.includes(message)) {
var response = _this.responseByMessage.get(message);
if (response && !isEquivalentRehydration(message)) {
detachedResponses.add(response);
}
}
});
var removedToolOwner = this.state.messages.some(function(message) {
var _message_parts;
return ((_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.some(function(part) {
return 'toolCallId' in part;
})) && !messages.includes(message) && !isEquivalentRehydration(message);
});
var toolCallIds = new Set();
var hasDuplicateToolCallId = messages.some(function(message) {
var _message_parts;
return ((_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.some(function(part) {
if (!('toolCallId' in part)) {
return false;
}
if (toolCallIds.has(part.toolCallId)) {
return true;
}
toolCallIds.add(part.toolCallId);
return false;
})) === true;
});
if (removedToolOwner || hasDuplicateToolCallId) {
this.acceptsIdentifierOnlyToolResults = false;
}
this.state.messages = messages;
var retainedMessageIds = new Set(messages.map(function(message) {
return message.id;
}));
var responses = new Set();
this.responsesByToolCallId.forEach(function(owners) {
owners.forEach(function(response) {
return responses.add(response);
});
});
if (this.activeResponse) {
responses.add(this.activeResponse);
}
detachedResponses.forEach(function(response) {
responses.add(response);
_this.retireResponse(response);
});
responses.forEach(function(response) {
var message = response.messageId ? messages.find(function(candidate) {
return candidate.id === response.messageId;
}) : undefined;
if (message && !response.isRetired && !detachedResponses.has(response)) {
_this.responseByMessage.set(message, response);
}
});
responses.forEach(function(response) {
if (detachedResponses.has(response) || response.messageId && !retainedMessageIds.has(response.messageId)) {
_this.pruneDetachedResponse(response);
}
});
}
},
{
key: "lastMessage",
get: function get() {
return this.state.messages[this.state.messages.length - 1];
}
},
{
key: "replaceMessage",
value: function replaceMessage(index, message, response) {
var _this_messages_index;
this.state.replaceMessage(index, message);
var canonicalMessage = (_this_messages_index = this.messages[index]) !== null && _this_messages_index !== void 0 ? _this_messages_index : message;
if (response && this.messages.includes(canonicalMessage)) {
this.responseByMessage.set(canonicalMessage, response);
}
return canonicalMessage;
}
},
{
key: "commit",
value: function commit(toolCallId, terminalState, messageId, response, expectedMessage) {
var isTargetPart = function isTargetPart(part) {
return 'toolCallId' in part && part.toolCallId === toolCallId;
};
var messageIndex = this.messages.findIndex(function(message) {
return (!messageId || message.id === messageId) && (!expectedMessage || message === expectedMessage) && message.parts.some(isTargetPart);
});
if (messageIndex === -1) return false;
var message = this.messages[messageIndex];
var partIndex = message.parts.findIndex(isTargetPart);
var part = message.parts[partIndex];
if (!('state' in part) || part.state === 'output-available' && !part.preliminary || part.state === 'output-error') {
return false;
}
var updatedParts = _to_consumable_array(message.parts);
updatedParts[partIndex] = withTerminalToolState(part, terminalState);
var updatedMessage = _object_spread_props(_object_spread({}, message), {
parts: updatedParts
});
this.replaceMessage(messageIndex, updatedMessage, response);
return true;
}
},
{
key: "captureRestoredToolCalls",
value: function captureRestoredToolCalls() {
var restoredToolCalls = new Map();
this.messages.forEach(function(message) {
message.parts.forEach(function(part) {
var _restoredToolCalls_get;
if (!isPendingToolPart(part)) return;
var toolCallIds = (_restoredToolCalls_get = restoredToolCalls.get(message.id)) !== null && _restoredToolCalls_get !== void 0 ? _restoredToolCalls_get : new Set();
toolCallIds.add(part.toolCallId);
restoredToolCalls.set(message.id, toolCallIds);
});
});
this.restoredToolCalls = restoredToolCalls;
}
},
{
key: "clearRestoredToolCalls",
value: function clearRestoredToolCalls() {
this.restoredToolCalls = undefined;
}
},
{
key: "repairRestoredPendingToolParts",
value: function repairRestoredPendingToolParts() {
var _this = this;
var shouldRepairRestoredPendingToolPart = this.shouldRepairRestoredPendingToolPart;
if (!shouldRepairRestoredPendingToolPart) return;
this.messages.forEach(function(message, messageIndex) {
message.parts.forEach(function(part) {
var _this_restoredToolCalls_get;
if (!isPendingToolPart(part)) return;
if (_this.restoredToolCalls && !((_this_restoredToolCalls_get = _this.restoredToolCalls.get(message.id)) === null || _this_restoredToolCalls_get === void 0 ? void 0 : _this_restoredToolCalls_get.has(part.toolCallId))) {
return;
}
var shouldRepair = false;
try {
shouldRepair = shouldRepairRestoredPendingToolPart({
toolName: getToolName(part),
toolCallId: part.toolCallId,
input: 'input' in part ? part.input : undefined
});
} catch (unused) {
return;
}
if (!shouldRepair) return;
_this.commit(part.toolCallId, {
state: 'output-error',
errorText: part.state === 'input-streaming' ? RESTORED_TOOL_INPUT_ERROR_TEXT : RESTORED_TOOL_CALL_ERROR_TEXT
}, message.id, undefined, _this.messages[messageIndex]);
});
});
}
},
{
key: "getOutboundMessages",
value: /**
* The transcript to send, with every tool call still awaiting an output
* reported as cancelled — a provider rejects a turn holding a tool call with
* no matching result.
*
* The repair stays on this copy rather than being committed to `messages`:
* the card is still mounted, so a result submitted after the send must still
* land, and is sent as the real output from then on.
*/ function getOutboundMessages() {
var _this = this;
var outboundMessages;
this.messages.forEach(function(message, messageIndex) {
var repairedParts;
message.parts.forEach(function(part, partIndex) {
if (!isPendingToolPart(part)) return;
repairedParts = repairedParts || _to_consumable_array(message.parts);
repairedParts[partIndex] = withTerminalToolState(part, _this.resolveToolCallCancellation(part));
});
if (repairedParts) {
outboundMessages = outboundMessages || _to_consumable_array(_this.messages);
outboundMessages[messageIndex] = _object_spread_props(_object_spread({}, message), {
parts: repairedParts
});
}
});
return outboundMessages || this.messages;
}
},
{
key: "resolveToolCallCancellation",
value: function resolveToolCallCancellation(part) {
var cancellation;
// Repairing the outbound transcript must never fail the request build.
try {
var _this_resolveCancelledToolOutput, _this;
cancellation = (_this_resolveCancelledToolOutput = (_this = this).resolveCancelledToolOutput) === null || _this_resolveCancelledToolOutput === void 0 ? void 0 : _this_resolveCancelledToolOutput.call(_this, {
toolName: getToolName(part),
toolCallId: part.toolCallId,
input: 'input' in part ? part.input : undefined
});
} catch (unused) {
cancellation = undefined;
}
return cancellation ? {
state: 'output-available',
output: cancellation.output
} : {
state: 'output-error',
errorText: TOOL_CALL_CANCELLED_ERROR_TEXT
};
}
},
{
key: "continueResponse",
value: function continueResponse(response) {
var _this = this;
if (response) {
this.pruneDetachedResponse(response);
if (response.isRetired || response.outcome !== 'succeeded' || response.requiredToolCallIds.size === 0 || Array.from(response.requiredToolCallIds).some(function(toolCallId) {
return !response.resolvedToolCallIds.has(toolCallId);
}) || !response.didNotifyFinish || response.didEvaluateContinuation) {
return Promise.resolve();
}
response.didEvaluateContinuation = true;
}
if (!this.sendAutomaticallyWhen) return Promise.resolve();
return Promise.resolve().then(function() {
return _this.sendAutomaticallyWhen({
messages: _this.messages
});
}).then(function(shouldSend) {
if (response) {
_this.pruneDetachedResponse(response);
if (response.isRetired) return undefined;
}
return shouldSend ? _this.makeRequest({
trigger: 'submit-message'
}) : undefined;
}).catch(function(error) {
if (response) {
_this.pruneDetachedResponse(response);
if (response.isRetired) return;
_this.handleError(error, {
updateState: _this.latestResponse === response
});
return;
}
_this.handleError(error);
});
}
},
{
key: "retireResponse",
value: function retireResponse(response) {
if (response.isRetired) return;
response.isRetired = true;
response.didEvaluateContinuation = true;
if (this.activeResponse === response) {
response.outcome = 'aborted';
this.activeResponse = null;
response.abortController.abort();
this.setStatus({
status: 'ready'
});
}
}
},
{
key: "pruneDetachedResponse",
value: function pruneDetachedResponse(response) {
var _this = this;
if (!response.isRetired) {
if (!response.messageId || this.messages.some(function(message) {
return message.id === response.messageId;
})) {
return;
}
this.retireResponse(response);
}
// Keep a routing tombstone while a callback is running so public
// addToolResult calls settle directly instead of entering the executor.
if (response.pendingToolCallbacks > 0) return;
this.responsesByToolCallId.forEach(function(owners, toolCallId) {
owners.delete(response);
if (owners.size === 0) {
_this.responsesByToolCallId.delete(toolCallId);
}
});
}
},
{
key: "submitToolResult",
value: function submitToolResult(response, options) {
var _this = this;
var messageId = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : response === null || response === void 0 ? void 0 : response.messageId, expectedMessage = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : messageId ? this.messages.find(function(message) {
return message.id === messageId;
}) : undefined;
if (response === null || response === void 0 ? void 0 : response.isRetired) return Promise.resolve();
var commitResult = function commitResult() {
if (!_this.commit(options.toolCallId, getTerminalToolState(options), messageId, response, expectedMessage)) {
return Promise.resolve();
}
if (response === null || response === void 0 ? void 0 : response.requiredToolCallIds.has(options.toolCallId)) {
response.resolvedToolCallIds.add(options.toolCallId);
}
return _this.continueResponse(response);
};
if (response && (this.activeResponse === response || response.outcome !== 'succeeded' || response.didEvaluateContinuation)) {
return commitResult();
}
return this.jobExecutor.run(commitResult);
}
},
{
key: "makeRequest",
value: function makeRequest(options) {
var _this = this;
if (!this.transport) {
return Promise.reject(new Error('Transport is required for sending messages. Please provide a transport when initializing the chat.'));
}
// Resolved as late as possible, so a tool that submits its output in the
// meantime is sent as answered.
var messages = this.getOutboundMessages();
return this.consume(function(abortSignal) {
return _this.transport.sendMessages({
chatId: _this.id,
messages: messages,
abortSignal: abortSignal,
trigger: options.trigger,
messageId: options.messageId,
headers: options.headers,
body: options.body,
requestMetadata: options.metadata
});
});
}
},
{
key: "consume",
value: function consume(createStream) {
var _this = this;
if (this.activeResponse) {
this.activeResponse.outcome = 'aborted';
this.activeResponse.abortController.abort();
}
var response = {
abortController: new AbortController(),
outcome: 'active',
isRetired: false,
requiredToolCallIds: new Set(),
resolvedToolCallIds: new Set(),
returnedToolCallbacks: [],
pendingToolCallbacks: 0,
didNotifyFinish: false,
didEvaluateContinuation: false
};
this.activeResponse = response;
this.latestResponse = response;
this.setStatus({
status: 'submitted'
});
return createStream(response.abortController.signal).then(function(stream) {
if (_this.activeResponse === response) {
if (stream) return _this.processStream(stream, response);
response.outcome = 'succeeded';
_this.activeResponse = null;
_this.setStatus({
status: 'ready'
});
}
return undefined;
}, function(error) {
if (_this.activeResponse !== response) return;
_this.activeResponse = null;
if (error.name === 'AbortError') {
response.outcome = 'aborted';
_this.setStatus({
status: 'ready'
});
} else {
response.outcome = 'failed';
_this.handleError(error);
}
});
}
},
{
key: "processStream",
value: function processStream1(stream, response) {
var _this = this;
this.setStatus({
status: 'streaming'
});
var currentMessageId;
var currentMessage;
var currentMessageIndex = -1;
var isAbort = false;
var isError = false;
var toolRawInputByCallId = {};
var toolRawOutputByCallId = {};
var findToolPart = function findToolPart(toolCallId) {
return currentMessage.parts.findIndex(function(part) {
return 'toolCallId' in part && part.toolCallId === toolCallId;
});
};
var setPart = function setPart(index, part) {
var parts = _to_consumable_array(currentMessage.parts);
parts[index < 0 ? parts.length : index] = part;
currentMessage = _object_spread_props(_object_spread({}, currentMessage), {
parts: parts
});
currentMessage = _this.replaceMessage(currentMessageIndex, currentMessage, response);
};
var mergeCallProviderMetadata = function mergeCallProviderMetadata(toolCallId, metadata) {
var toolIndex = findToolPart(toolCallId);
if (toolIndex < 0) return;
var existingPart = currentMessage.parts[toolIndex];
setPart(toolIndex, _object_spread_props(_object_spread({}, existingPart), {
callProviderMetadata: metadata !== null && metadata !== void 0 ? metadata : existingPart.callProviderMetadata
}));
};
var getCanonicalMessage = function getCanonicalMessage() {
var _this_messages_find;
return response.messageId ? (_this_messages_find = _this.messages.find(function(message) {
return message.id === response.messageId;
})) !== null && _this_messages_find !== void 0 ? _this_messages_find : currentMessage : currentMessage;
};
var notifyFinish = function notifyFinish(param) {
var isAbort = param.isAbort, isDisconnect = param.isDisconnect, isError = param.isError, message = param.message, _param_allowRetired = param.allowRetired, allowRetired = _param_allowRetired === void 0 ? false : _param_allowRetired;
_this.pruneDetachedResponse(response);
if (response.isRetired && !allowRetired || response.didNotifyFinish) {
return;
}
response.didNotifyFinish = true;
var canonicalMessage = message !== null && message !== void 0 ? message : getCanonicalMessage();
if (_this.onFinish && canonicalMessage) {
_this.onFinish({
message: canonicalMessage,
messages: _this.messages,
isAbort: isAbort,
isDisconnect: isDisconnect,
isError: isError
});
}
};
var failToolCall = function failToolCall(reason) {
if (response.outcome !== 'active') return;
var message = getCanonicalMessage();
var wasRetired = response.isRetired;
var error = _instanceof(reason, Error) ? reason : new Error(String(reason));
response.outcome = 'failed';
response.abortController.abort();
if (_this.activeResponse === response) {
_this.activeResponse = null;
_this.handleError(error);
}
notifyFinish({
isAbort: false,
isDisconnect: false,
isError: true,
message: message,
allowRetired: !wasRetired
});
};
// A tool call the server answers itself is server-owned, even when the
// stream omits `providerExecuted`: nothing is left for the client to
// submit, so the response must stop requiring a result for it. Dropping it
// from `requiredToolCallIds` also keeps the turn from auto-continuing on
// the server's behalf — a turn made of server-executed tool calls is
// already complete, and resending it would repeat the whole answer.
var acceptServerToolResult = function acceptServerToolResult(toolCallId) {
if (response.requiredToolCallIds.delete(toolCallId)) {
response.resolvedToolCallIds.add(toolCallId);
}
};
return new Promise(function(resolve) {
var finish = function finish(error) {
if (response.outcome === 'failed') {
resolve();
return;
}
isAbort || (isAbort = response.outcome === 'aborted' || !!error && error.name === 'AbortError');
response.outcome = isAbort ? 'aborted' : error ? 'failed' : 'succeeded';
if (_this.activeResponse === response) {
_this.activeResponse = null;
if (error && !isAbort) {
_this.handleError(error);
} else {
_this.setStatus({
status: 'ready'
});
}
}
notifyFinish({
isAbort: isAbort,
isDisconnect: !!error && !isAbort,
isError: isError
});
resolve(isAbort || error ? undefined : _this.continueResponse(response));
};
processStream(stream, function(chunk) {
if (_this.activeResponse !== response || response.isRetired) return;
if (currentMessageId) {
var canonicalMessageIndex = _this.messages.findIndex(function(message) {
return message.id === currentMessageId;
});
if (canonicalMessageIndex === -1) {
_this.pruneDetachedResponse(response);
return;
}
currentMessageIndex = canonicalMessageIndex;
currentMessage = _this.messages[canonicalMessageIndex];
_this.responseByMessage.set(currentMessage, response);
}
switch(chunk.type){
case 'start':
{
currentMessageId = chunk.messageId || _this.generateId();
response.messageId = currentMessageId;
// Check if we're continuing an existing message or creating a new one
var lastMessage = _this.lastMessage;
if (lastMessage && lastMessage.role === 'assistant' && lastMessage.id === currentMessageId) {
if (lastMessage.parts.some(function(part) {
return 'toolCallId' in part;
})) {
_this.acceptsIdentifierOnlyToolResults = false;
}
currentMessage = _object_spread_props(_object_spread({}, lastMessage), {
parts: _to_consumable_array(lastMessage.parts)
});
currentMessageIndex = _this.messages.length - 1;
currentMessage = _this.replaceMessage(currentMessageIndex, currentMessage, response);
} else {
currentMessage = {
id: currentMessageId,
role: 'assistant',
parts: [],
metadata: chunk.messageMetadata
};
_this.state.pushMessage(currentMessage);
currentMessageIndex = _this.messages.length - 1;
_this.responseByMessage.set(currentMessage, response);
}
break;
}
case 'text-start':
case 'reasoning-start':
{
if (!currentMessage) break;
var type = chunk.type === 'text-start' ? 'text' : 'reasoning';
setPart(-1, {
type: type,
text: '',
state: 'streaming',
providerMetadata: chunk.providerMetadata
});
break;
}
case 'text-delta':
case 'reasoning-delta':
{
var type1 = chunk.type === 'text-delta' ? 'text' : 'reasoning';
if (!currentMessage) break;
var partIndex = currentMessage.parts.findIndex(function(part) {
return part.type === type1 && part.state === 'streaming';
});
if (partIndex === -1) break;
var part = currentMessage.parts[partIndex];
setPart(partIndex, _object_spread_props(_object_spread({}, part), {
text: part.text + chunk.delta
}));
break;
}
case 'text-end':
case 'reasoning-end':
{
if (!currentMessage) break;
var type2 = chunk.type === 'text-end' ? 'text' : 'reasoning';
var partIndex1 = currentMessage.parts.findIndex(function(part) {
return part.type === type2 && part.state === 'streaming';
});
if (partIndex1 === -1) break;
setPart(partIndex1, _object_spread_props(_object_spread({}, currentMessage.parts[partIndex1]), {
state: 'done'
}));
break;
}
case 'tool-input-start':
{
if (!currentMessage) break;
var completedPart = currentMessage.parts.find(function(part) {
return 'toolCallId' in part && part.toolCallId === chunk.toolCallId && 'state' in part && (part.state === 'output-available' || part.state === 'output-error');
});
if (completedPart) break;
var initialRawInput = typeof chunk.input === 'string' ? chunk.input : chunk.input !== undefined ? JSON.stringify(chunk.input) : '';
toolRawInputByCallId[chunk.toolCallId] = initialRawInput;
var toolPart = {
type: "tool-".concat(chunk.toolName),
toolCallId: chunk.toolCallId,
state: 'input-streaming',
input: chunk.input,
rawInput: initialRawInput || undefined,
providerExecuted: chunk.providerExecuted
};
setPart(-1, toolPart);
break;
}
case 'tool-input-delta':
{
var _ref, _ref1, _chunk_toolName, _ref2;
var _existingPart_type, _this_shouldRepairToolInput, _this1;
if (!currentMessage) break;
var toolIndex = findToolPart(chunk.toolCallId);
var existingPart = toolIndex >= 0 ? currentMessage.parts[toolIndex] : null;
if ((existingPart === null || existingPart === void 0 ? void 0 : existingPart.state) === 'output-available' || (existingPart === null || existingPart === void 0 ? void 0 : existingPart.state) === 'output-error') {
break;
}
var previousRawInput = (_ref = (_ref1 = existingPart === null || existingPart === void 0 ? void 0 : existingPart.rawInput) !== null && _ref1 !== void 0 ? _ref1 : toolRawInputByCallId[chunk.toolCallId]) !== null && _ref !== void 0 ? _ref : '';
var nextRawInput = "".concat(previousRawInput).concat(chunk.inputTextDelta);
toolRawInputByCallId[chunk.toolCallId] = nextRawInput;
var toolName = (_chunk_toolName = chunk.toolName) !== null && _chunk_toolName !== void 0 ? _chunk_toolName : existingPart === null || existingPart === void 0 ? void 0 : (_existingPart_type = existingPart.type) === null || _existingPart_type === void 0 ? void 0 : _existingPart_type.replace('tool-', '');
var shouldRepair = toolName ? (_ref2 = (_this_shouldRepairToolInput = (_this1 = _this).shouldRepairToolInput) === null || _this_shouldRepairToolInput === void 0 ? void 0 : _this_shouldRepairToolInput.call(_this1, toolName)) !== null && _ref2 !== void 0 ? _ref2 : true : true;
var parsedInput = shouldRepair ? parsePartialJson(nextRawInput, existingPart === null || existingPart === void 0 ? void 0 : existingPart.input) : existingPart === null || existingPart === void 0 ? void 0 : existingPart.input;
var nextToolPart = _object_spread_props(_object_spread({}, existingPart !== null && existingPart !== void 0 ? existingPart : {
type: "tool-".concat(chunk.toolName),
toolCallId: chunk.toolCallId
}), {
state: 'input-streaming',
input: parsedInput,
rawInput: nextRawInput
});
setPart(toolIndex, nextToolPart);
break;
}
case 'tool-input-available':
{
if (!currentMessage) break;
if (response.requiredToolCallIds.has(chunk.toolCallId)) break;
delete toolRawInputByCallId[chunk.toolCallId];
// Find existing tool part or create new one
var existingIndex = findToolPart(chunk.toolCallId);
var existingPart1 = existingIndex >= 0 ? currentMessage.parts[existingIndex] : null;
if ((existingPart1 === null || existingPart1 === void 0 ? void 0 : existingPart1.state) === 'output-available' || (existingPart1 === null || existingPart1 === void 0 ? void 0 : existingPart1.state) === 'output-error') {
break;
}
var toolPart1 = {
type: "tool-".concat(chunk.toolName),
toolCallId: chunk.toolCallId,
state: 'input-available',
input: chunk.input,
callProviderMetadata: chunk.callProviderMetadata,
providerExecuted: chunk.providerExecuted
};
setPart(existingIndex, toolPart1);
if (_this.messages.some(function(message) {
var _message_parts;
return message !== currentMessage && ((_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.some(function(part) {
return 'toolCallId' in part && part.toolCallId === chunk.toolCallId;
}));
})) {
_this.acceptsIdentifierOnlyToolResults = false;
}
// Trigger onToolCall callback only for client-executed tools
// (server-executed tools have providerExecuted: true and don't need client handling)
if (_this.onToolCall && !chunk.providerExecuted) {
var _this_responsesByToolCallId_get;
var owners = (_this_responsesByToolCallId_get = _this.responsesByToolCallId.get(chunk.toolCallId)) !== null && _this_responsesByToolCallId_get !== void 0 ? _this_responsesByToolCallId_get : new Set();
var existingOwners = Array.from(owners).filter(function(owner) {
return owner !== response;
});
if (existingOwners.length > 0) {
_this.acceptsIdentifierOnlyToolResults = false;
var conflictingOwner = existingOwners.find(function(owner) {
return !owner.isRetired && (owner.outcome === 'active' || owner.outcome === 'succeeded' && (!owner.resolvedToolCallIds.has(chunk.toolCallId) || owner.pendingToolCallbacks > 0));
});
if (conflictingOwner) {
// Neither response may continue once ownership is ambiguous.
conflictingOwner.didEvaluateContinuation = true;
failToolCall(new Error('Tool call "'.concat(chunk.toolCallId, '" is already owned by another response.')));
break;
}
}
response.requiredToolCallIds.add(chunk.toolCallId);
owners.add(response);
_this.responsesByToolCallId.set(chunk.toolCallId, owners);
response.pendingToolCallbacks++;
try {
var _this_restoredToolCalls_get, _this_restoredToolCalls;
(_this_restoredToolCalls = _this.restoredToolCalls) === null || _this_restoredToolCalls === void 0 ? void 0 : (_this_restoredToolCalls_get = _this_restoredToolCalls.get(currentMessage.id)) === null || _this_restoredToolCalls_get === void 0 ? void 0 : _this_restoredToolCalls_get.delete(chunk.toolCallId);
var result = _this.onToolCall({
toolCall: {
toolName: chunk.toolName,
toolCallId: chunk.toolCallId,
input: chunk.input,
dynamic: 'dynamic' in chunk ? chunk.dynamic : undefined
},
signal: response.abortController.signal
}, function(options) {
return response.isRetired ? Promise.resolve() : _this.submitToolResult(response, options);
});
if (result) {
response.returnedToolCallbacks.push(Promise.resolve(result).catch(failToolCall).then(function() {
response.pendingToolCallbacks--;
_this.pruneDetachedResponse(response);
}));
} else {
response.pendingToolCallbacks--;
_this.pruneDetachedResponse(response);
}
} catch (error) {
response.pendingToolCallbacks--;
failToolCall(error);
_this.pruneDetachedResponse(response);
}
}
break;
}
case 'data-tool-output-delta':
{
var _ref3, _ref4;
if (!currentMessage) break;
var _chunk_data = chunk.data, toolCallId = _chunk_data.toolCallId, toolName1 = _chunk_data.toolName, delta = _chunk_data.delta;
if (response.resolvedToolCallIds.has(toolCallId)) break;
var toolIndex1 = findToolPart(toolCallId);
var existingPart2 = toolIndex1 >= 0 ? currentMessage.parts[toolIndex1] : null;
var previousRawOutput = (_ref3 = (_ref4 = existingPart2 === null || existingPart2 === void 0 ? void 0 : existingPart2.rawOutput) !== null && _ref4 !== void 0 ? _ref4 : toolRawOutputByCallId[toolCallId]) !== null && _ref3 !== void 0 ? _ref3 : '';
var nextRawOutput = "".concat(previousRawOutput).concat(delta);
toolRawOutputByCallId[toolCallId] = nextRawOutput;
var parsedOutput = parsePartialJson(nextRawOutput, existingPart2 === null || existingPart2 === void 0 ? void 0 : existingPart2.output);
var nextToolPart1 = _object_spread_props(_object_spread({}, existingPart2 !== null && existingPart2 !== void 0 ? existingPart2 : {
type: "tool-".concat(toolName1),
toolCallId: toolCallId,
input: undefined
}), {
state: 'output-available',
output: parsedOutput,
rawOutput: nextRawOutput,
preliminary: true
});
setPart(toolIndex1, nextToolPart1);
break;
}
case 'tool-output-available':
{
if (!currentMessage) break;
var toolIndex2 = findToolPart(chunk.toolCallId);
if (toolIndex2 >= 0) {
delete toolRawInputByCallId[chunk.toolCallId];
delete toolRawOutputByCallId[chunk.toolCallId];
var existingPart3 = currentMessage.parts[toolIndex2];
if (response.resolvedToolCallIds.has(chunk.toolCallId)) {
mergeCallProviderMetadata(chunk.toolCallId, chunk.callProviderMetadata);
break;
}
// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
var _ignored = existingPart3.rawOutput, rest = _object_without_properties(existingPart3, [
"rawOutput"
]);
setPart(toolIndex2, _object_spread_props(_object_spread({}, rest), {
state: 'output-available',
output: chunk.output,
callProviderMetadata: chunk.callProviderMetadata,
preliminary: chunk.preliminary
}));
if (!chunk.preliminary) {
acceptServerToolResult(chunk.toolCallId);
}
}
break;
}
case 'tool-input-error':
{
var _chunk_input, _chunk_providerExecuted, _chunk_providerMetadata;
if (!currentMessage) break;
if (response.resolvedToolCallIds.has(chunk.toolCallId)) {
mergeCallProviderMetadata(chunk.toolCallId, chunk.providerMetadata);
break;
}
delete toolRawInputByCallId[chunk.toolCallId];
delete toolRawOutputByCallId[chunk.toolCallId];
var toolIndex3 = findToolPart(chunk.toolCallId);
var existingPart4 = toolIndex3 >= 0 ? currentMessage.parts[toolIndex3] : null;
var _ref5 = existingPart4 !== null && existingPart4 !== void 0 ? existingPart4 : {}, _ignoredOutput = _ref5.output, _ignoredRawOutput = _ref5.rawOutput, _ignoredPreliminary = _ref5.preliminary, carryOver = _object_without_properties(_ref5, [
"output",
"rawOutput",
"preliminary"
]);
var nextToolPart2 = _object_spread_props(_object_spread({}, carryOver), {
type: "tool-".concat(chunk.toolName),
toolCallId: chunk.toolCallId,
state: 'output-error',
input: undefined,
rawInput: (_chunk_input = chunk.input) !== null && _chunk_input !== void 0 ? _chunk_input : carryOver.rawInput,
errorText: chunk.errorText,
providerExecuted: (_chunk_providerExecuted = chunk.providerExecuted) !== null && _chunk_providerExecuted !== void 0 ? _chunk_providerExecuted : carryOver.providerExecuted,
callProviderMetadata: (_chunk_providerMetadata = chunk.providerMetadata) !== null && _chunk_providerMetadata !== void 0 ? _chunk_providerMetadata : carryOver.callProviderMetadata
});
setPart(toolIndex3, nextToolPart2);
acceptServerToolResult(chunk.toolCallId);
break;
}
case 'tool-output-error':
{
var _chunk_providerExecuted1, _chunk_providerMetadata1;
if (!currentMessage) break;
if (response.resolvedToolCallIds.has(chunk.toolCallId)) {
mergeCallProviderMetadata(chunk.toolCallId, chunk.providerMetadata);
break;
}
var toolIndex4 = findToolPart(chunk.toolCallId);
if (toolIndex4 < 0) break;
delete toolRawInputByCallId[chunk.toolCallId];
delete toolRawOutputByCallId[chunk.toolCallId];
var existingPart5 = currentMessage.parts[toolIndex4];
var _ignoredRawOutput1 = existingPart5.rawOutput, _ignoredPreliminary1 = existingPart5.preliminary, _ignoredOutput1 = existingPart5.output, rest1 = _object_without_properties(existingPart5, [
"rawOutput",
"preliminary",
"output"
]);
setPart(toolIndex4, _object_spread_props(_object_spread({}, rest1), {
state: 'output-error',
errorText: chunk.errorText,
providerExecuted: (_chunk_providerExecuted1 = chunk.providerExecuted) !== null && _chunk_providerExecuted1 !== void 0 ? _chunk_providerExecuted1 : rest1.providerExecuted,
callProviderMetadata: (_chunk_providerMetadata1 = chunk.providerMetadata) !== null && _chunk_providerMetadata1 !== void 0 ? _chunk_providerMetadata1 : rest1.callProviderMetadata
}));
acceptServerToolResult(chunk.toolCallId);
break;
}
case 'source-url':
{
if (!currentMessage) break;
var sourcePart = {
type: 'source-url',
sourceId: chunk.sourceId,
url: chunk.url,
title: chunk.title
};
setPart(-1, sourcePart);
break;
}
case 'source-document':
{
if (!currentMessage) break;
var docPart = {
type: 'source-document',
sourceId: chunk.sourceId,
mediaType: chunk.mediaType,
title: chunk.title,
filename: chunk.filename,
providerMetadata: chunk.providerMetadata
};
setPart(-1, docPart);
break;
}
case 'file':
{
if (!currentMessage) break;
var filePart = {
type: 'file',
url: chunk.url,
mediaType: chunk.mediaType
};
setPart(-1, filePart);
break;
}
case 'start-step':
{
if (!currentMessage) break;
setPart(-1, {
type: 'step-start'
});
break;
}
case 'message-metadata':
{
if (!currentMessage) break;
currentMessage = _object_spread_props(_object_spread({}, currentMessage), {
metadata: chunk.messageMetadata
});
currentMessage = _this.replaceMessage(currentMessageIndex, currentMessage, response);
break;
}
case 'error':
{
isError = true;
var text = chunk.errorText.trim();
throw new Error(tryParseErrorMessage(text) || text || 'Unknown error');
}
case 'abort':
{
isAbort = true;
break;
}
case 'finish':
{
if (currentMessage && chunk.messageMetadata !== undefined) {
currentMessage = _object_spread_props(_object_spread({}, currentMessage), {
metadata: chunk.messageMetadata
});
currentMessage = _this.replaceMessage(currentMessageIndex, currentMessage, response);
}
break;
}
case 'data-guardrail-violation':
{
// `chunk.data` widens to `unknown` here: the chunk union also
// carries a generic `data-${string}` member, and the literal
// matches both, so narrowing can't pick the specific shape.
var fallbackResponse = chunk.data.fallbackResponse;
var fallbackText = fallbackResponse || defaultGuardrailFallbackResponse;
// The stream closes after a guardrail violation; keep the
// fallback as the current message so the normal finish path runs.
currentMessage = {
id: (currentMessage === null || currentMessage === void 0 ? void 0 : currentMessage.id) || currentMessageId || _this.generateId(),
role: 'assistant',
metadata: currentMessage === null || currentMessage === void 0 ? void 0 : currentMessage.metadata,
parts: [
{
type: 'text',
text: fallbackText,
state: 'done'
}
]
};
if (currentMessageIndex >= 0) {
currentMessage = _this.replaceMessage(currentMessageIndex, currentMessage, response);
} else {
_this.state.pushMessage(currentMessage);
currentMessageIndex = _this.messages.length - 1;
_this.responseByMessage.set(currentMessage, response);
}
currentMessageId = currentMessage.id;
break;
}
default:
{
// Handle generic data parts (data-*)
var chunkType = chunk.type;
if ((chunkType === null || chunkType === void 0 ? void 0 : chunkType.startsWith('data-')) && currentMessage) {
var dataPart = {
type: chunkType,
id: chunk.id,
data: chunk.data
};
setPart(-1, dataPart);
// Trigger onData callback
if (_this.onData) {
_this.onData(dataPart);
}
}
}
}
}, function() {
return Promise.all(response.returnedToolCallbacks).then(function() {
return finish();
});
}, function(error) {
return finish(error);
});
});
}
},
{
key: "handleError",
value: function handleError(error) {
var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _ref_updateState = _ref.updateState, updateState = _ref_updateState === void 0 ? true : _ref_updateState;
if (updateState) {
this.setStatus({
status: 'error',
error: error
});
}
if (this.onError) {
this.onError(error);
}
}
},
{
key: "convertFilesToParts",
value: function convertFilesToParts(files) {
var _this, _loop = function _loop(i) {
var file = files[i];
promises.push(_this.fileToDataUrl(file).then(function(dataUrl) {
return {
type: 'file',
mediaType: file.type,
filename: file.name,
url: dataUrl
};
}));
};
if (Array.isArray(files)) {
return Promise.resolve(files);
}
var promises = [];
for(var i = 0; i < files.length; i++)_this = this, _loop(i);
return Promise.all(promises);
}
},
{
key: "fileToDataUrl",
value: function fileToDataUrl(file) {
return new Promise(function(resolve, reject) {
var reader = new FileReader();
reader.onload = function() {
return resolve(reader.result);
};
reader.onerror = reject;
reader.readAsDataURL(file);
});
}
}
]);
return AbstractChat;
}();
var _computedKey, _computedKey1, _computedKey2, _computedKey3, _computedKey4, _computedKey5, _computedKey6, _computedKey7;
var CACHE_KEY = 'instantsearch-chat-initial-messages';
// Message history is a browser concern, and a server render constructs a Chat
// too. Reading storage there throws during rendering; the write below only
// throws into its own `catch`, so gating it just stops a pointless attempt.
function getDefaultInitialMessages(id) {
return safelyRunOnBrowser(function() {
try {
// `sessionStorage` is not available in every environment with a
// `window` (e.g. React Native), and some browsers throw on access
// when storage is disabled.
var initialMessages = sessionStorage.getItem(CACHE_KEY + (id ? "-".concat(id) : ''));
return initialMessages ? JSON.parse(initialMessages) : [];
} catch (e) {
return [];
}
}, {
fallback: function fallback() {
return [];
}
});
}
_computedKey = '~persistMessages', _computedKey1 = '~registerMessagesCallback', _computedKey2 = '~registerStatusCallback', _computedKey3 = '~registerErrorCallback';
var _computedKey8 = _computedKey, _computedKey9 = _computedKey1, _computedKey10 = _computedKey2, _computedKey11 = _computedKey3;
var ChatState = /*#__PURE__*/ function() {
function ChatState() {
var _this = this;
var id = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : undefined, initialMessages = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : undefined, persistence = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
_class_call_check(this, ChatState);
_define_property(this, "_messages", void 0);
_define_property(this, "_status", 'ready');
_define_property(this, "_error", undefined);
_define_property(this, "_messagesCallbacks", new Set());
_define_property(this, "_statusCallbacks", new Set());
_define_property(this, "_errorCallbacks", new Set());
_define_property(this, "persistenceKey", void 0);
_define_property(this, "pushMessage", function(message) {
_this._messages = _this._messages.concat(message);
_this._callMessagesCallbacks();
});
_define_property(this, "popMessage", function() {
_this._messages = _this._messages.slice(0, -1);
_this._callMessagesCallbacks();
});
_define_property(this, "replaceMessage", function(index, message) {
_this._messages = _to_consumable_array(_this._messages.slice(0, index)).concat([
// We deep clone the message here to ensure the new React Compiler (currently in RC) detects deeply nested parts/metadata changes:
_this.snapshot(message)
], _to_consumable_array(_this._messages.slice(index + 1)));
_this._callMessagesCallbacks();
});
_define_property(this, "snapshot", function(thing) {
return JSON.parse(JSON.stringify(thing));
});
_define_property(this, _computedKey8, function() {
var persistenceKey = _this.persistenceKey;
if (!persistenceKey) return;
safelyRunOnBrowser(function() {
try {
sessionStorage.setItem(persistenceKey, JSON.stringify(_this.messages));
} catch (e) {
// Do nothing if sessionStorage is not available or full
}
});
});
_define_property(this, _computedKey9, function(onChange) {
var callback = onChange;
_this._messagesCallbacks.add(callback);
return function() {
_this._messagesCallbacks.delete(callback);
};
});
_define_property(this, _computedKey10, function(onChange) {
_this._statusCallbacks.add(onChange);
return function() {
_this._statusCallbacks.delete(onChange);
};
});
_define_property(this, _computedKey11, function(onChange) {
_this._errorCallbacks.add(onChange);
return function() {
_this._errorCallbacks.delete(onChange);
};
});
_define_property(this, "_callMessagesCallbacks", function() {
_this._messagesCallbacks.forEach(function(callback) {
return callback();
});
});
_define_property(this, "_callStatusCallbacks", function() {
_this._statusCallbacks.forEach(function(callback) {
return callback();
});
});
_define_property(this, "_callErrorCallbacks", function() {
_this._errorCallbacks.forEach(function(callback) {
return callback();
});
});
if (initialMessages !== undefined) {
this._messages = initialMessages;
} else if (persistence) {
this._messages = getDefaultInitialMessages(id);
} else {
this._messages = [];
}
if (!persistence) {
return;
}
this.persistenceKey = CACHE_KEY + (id ? "-".concat(id) : '');
var saveMessagesInSessionStorage = function saveMessagesInSessionStorage() {
if (_this.status === 'ready') {
_this['~persistMessages']();
}
};
this['~registerMessagesCallback'](saveMessagesInSessionStorage);
this['~registerStatusCallback'](saveMessagesInSessionStorage);
}
_create_class(ChatState, [
{
key: "status",
get: function get() {
return this._status;
},
set: function set(newStatus) {
this._status = newStatus;
this._callStatusCallbacks();
}
},
{
key: "error",
get: function get() {
return this._error;
},
set: function set(newError) {
this._error = newError;
this._callErrorCallbacks();
}
},
{
key: "messages",
get: function get() {
return this._messages;
},
set: function set(newMessages) {
this._messages = _to_consumable_array(newMessages);
this._callMessagesCallbacks();
}
}
]);
return ChatState;
}();
_computedKey4 = '~repairRestoredPendingToolParts', _computedKey5 = '~registerMessagesCallback', _computedKey6 = '~registerStatusCallback', _computedKey7 = '~registerErrorCallback';
var _computedKey12 = _computedKey4, _computedKey13 = _computedKey5, _computedKey14 = _computedKey6, _computedKey15 = _computedKey7;
var Chat$1 = /*#__PURE__*/ function(AbstractChat) {
_inherits(Chat, AbstractChat);
function Chat(_0) {
_class_call_check(this, Chat);
var _this;
var messages = _0.messages, agentId = _0.agentId, _0_persistence = _0.persistence, persistence = _0_persistence === void 0 ? true : _0_persistence, init = _object_without_properties(_0, [
"messages",
"agentId",
"persistence"
]);
var state = new ChatState(agentId, messages, persistence);
_this = _call_super(this, Chat, [
_object_spread_props(_object_spread({}, init), {
state: state
})
]), _define_property(_this, "_state", void 0), _define_property(_this, "hasRestoredMessages", false), _define_property(_this, _computedKey12, function() {
if (!_this.hasRestoredMessages) return;
_this.hasRestoredMessages = false;
_this.repairRestoredPendingToolParts();
_this.clearRestoredToolCalls();
_this._state['~persistMessages']();
}), _define_property(_this, _computedKey13, function(onChange) {
return _this._state['~registerMessagesCallback'](onChange);
}), _define_property(_this, _computedKey14, function(onChange) {
return _this._state['~registerStatusCallback'](onChange);
}), _define_property(_this, _computedKey15, function(onChange) {
return _this._state['~registerErrorCallback'](onChange);
});
_this._state = state;
if (messages === undefined && persistence) {
_this.hasRestoredMessages = true;
_this.captureRestoredToolCalls();
_this.repairRestoredPendingToolParts();
}
return _this;
}
return Chat;
}(AbstractChat);
// Centralizes the "open the chat from an entry point" behavior shared by the
// SearchBox AI button, the Autocomplete AI button, prompt suggestions, and any
// future entry point. The chat is always opened; the message is only sent when
// it is non-empty and the chat is not already processing a message.
// Returns true when a message was submitted, so callers can clear their input.
function openChat(chatRenderState) {
var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, message = _ref.message, referer = _ref.referer, turnContext = _ref.turnContext;
var _ref1;
var _chatRenderState_setOpen;
if (!chatRenderState) {
return false;
}
var trimmed = (_ref1 = message === null || message === void 0 ? void 0 : message.trim()) !== null && _ref1 !== void 0 ? _ref1 : '';
if (!trimmed) {
if (chatRenderState.focusInput) {
chatRenderState.focusInput();
} else {
var _chatRenderState_setOpen1;
(_chatRenderState_setOpen1 = chatRenderState.setOpen) === null || _chatRenderState_setOpen1 === void 0 ? void 0 : _chatRenderState_setOpen1.call(chatRenderState, true);
}
return false;
}
(_chatRenderState_setOpen = chatRenderState.setOpen) === null || _chatRenderState_setOpen === void 0 ? void 0 : _chatRenderState_setOpen.call(chatRenderState, true);
if (isChatBusy(chatRenderState) || !chatRenderState.sendMessage) {
return false;
}
chatRenderState.sendMessage(_object_spread({
text: trimmed
}, turnContext ? {
metadata: {
turnContext: turnContext
}
} : {}), referer ? {
headers: {
'x-algolia-referer': referer
}
} : undefined);
return true;
}
function isChatBusy(chatRenderState) {
return (chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.status) === 'submitted' || (chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.status) === 'streaming';
}
var SearchIndexToolType = 'algolia_search_index';
var RecommendToolType = 'algolia_recommend';
var MemorizeToolType = 'algolia_memorize';
var MemorySearchToolType = 'algolia_memory_search';
var PonderToolType = 'algolia_ponder';
var DisplayResultsToolType = 'algolia_display_results';
var GroupedResultsToolType = 'algolia_grouped_results';
/**
* Whether `toolName` is the search tool as the Algolia MCP Server exposes it:
* one tool per index, named after the index it searches
* (`algolia_search_index_products`).
*/ var matchesSearchIndexToolName = function matchesSearchIndexToolName(toolName) {
return toolName.startsWith("".concat(SearchIndexToolType, "_"));
};
function flat(arr) {
return arr.reduce(function(acc, array) {
return acc.concat(array);
}, []);
}
/**
* Reads a human-readable message from a failed HTTP response body when the
* server returns JSON such as `{ "message": "..." }` (the shared
* `ErrorResponse` shape used by every status code), falling back to the HTTP
* status line when the body is empty or not parseable.
*/ function getHttpErrorMessage(response) {
var fallback = "HTTP error: ".concat(response.status, " ").concat(response.statusText);
return response.text().then(function(text) {
var _tryParseErrorMessage;
return (_tryParseErrorMessage = tryParseErrorMessage(text)) !== null && _tryParseErrorMessage !== void 0 ? _tryParseErrorMessage : fallback;
}).catch(function() {
return fallback;
});
}
/**
* Abstract base class for HTTP-based chat transports.
*/ var HttpChatTransport = /*#__PURE__*/ function() {
function HttpChatTransport(param) {
var _param_api = param.api, api = _param_api === void 0 ? '/api/chat' : _param_api, credentials = param.credentials, headers = param.headers, body = param.body, customFetch = param.fetch, prepareSendMessagesRequest = param.prepareSendMessagesRequest, prepareReconnectToStreamRequest = param.prepareReconnectToStreamRequest;
_class_call_check(this, HttpChatTransport);
_define_property(this, "api", void 0);
_define_property(this, "credentials", void 0);
_define_property(this, "headers", void 0);
_define_property(this, "body", void 0);
_define_property(this, "fetch", void 0);
_define_property(this, "prepareSendMessagesRequest", void 0);
_define_property(this, "prepareReconnectToStreamRequest", void 0);
this.api = api;
this.credentials = credentials;
this.headers = headers;
this.body = body;
this.fetch = customFetch;
this.prepareSendMessagesRequest = prepareSendMessagesRequest;
this.prepareReconnectToStreamRequest = prepareReconnectToStreamRequest;
}
_create_class(HttpChatTransport, [
{
key: "sendMessages",
value: function sendMessages(param) {
var _this = this;
var abortSignal = param.abortSignal, chatId = param.chatId, messages = param.messages, requestMetadata = param.requestMetadata, trigger = param.trigger, messageId = param.messageId, requestHeaders = param.headers, requestBody = param.body;
var _this_fetch;
var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
// Resolve configurable values
return Promise.all([
resolveValue(this.credentials),
resolveValue(this.headers),
resolveValue(this.body)
]).then(function(param) {
var _param = _sliced_to_array(param, 3), resolvedCredentials = _param[0], resolvedHeaders = _param[1], resolvedBody = _param[2];
// Build default request options
var api = _this.api;
var body = _object_spread({
id: chatId,
messages: messages
}, resolvedBody, requestBody);
var headers = _object_spread({
'Content-Type': 'application/json'
}, _instanceof(resolvedHeaders, Headers) ? Object.fromEntries(resolvedHeaders.entries()) : resolvedHeaders, _instanceof(requestHeaders, Headers) ? Object.fromEntries(requestHeaders.entries()) : requestHeaders);
var credentials = resolvedCredentials;
// Apply custom preparation if provided
var prepareRequestBody = _object_spread({}, resolvedBody, requestBody);
var preparePromise = _this.prepareSendMessagesRequest ? Promise.resolve(_this.prepareSendMessagesRequest({
id: chatId,
messages: messages,
requestMetadata: requestMetadata,
body: prepareRequestBody,
credentials: resolvedCredentials,
headers: resolvedHeaders,
api: _this.api,
trigger: trigger,
messageId: messageId
})) : Promise.resolve(null);
return preparePromise.then(function(prepared) {
if (prepared) {
body = prepared.body;
if (prepared.api) api = prepared.api;
if (prepared.headers) {
headers = _object_spread({
'Content-Type': 'application/json'
}, _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers);
}
if (prepared.credentials) credentials = prepared.credentials;
}
return fetchFn(api, {
method: 'POST',
headers: headers,
body: JSON.stringify(body),
signal: abortSignal,
credentials: credentials
}).then(function(response) {
if (!response.ok) {
return getHttpErrorMessage(response).then(function(message) {
throw new Error(message);
});
}
if (!response.body) {
throw new Error('Response body is empty');
}
return _this.processResponseStream(response.body);
});
});
});
}
},
{
key: "reconnectToStream",
value: function reconnectToStream(param) {
var _this = this;
var chatId = param.chatId, requestHeaders = param.headers, requestBody = param.body;
var _this_fetch;
var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
// Resolve configurable values
return Promise.all([
resolveValue(this.credentials),
resolveValue(this.headers),
resolveValue(this.body)
]).then(function(param) {
var _param = _sliced_to_array(param, 3), resolvedCredentials = _param[0], resolvedHeaders = _param[1], resolvedBody = _param[2];
// Build default request options
var api = _this.api;
var headers = _object_spread({}, _instanceof(resolvedHeaders, Headers) ? Object.fromEntries(resolvedHeaders.entries()) : resolvedHeaders, _instanceof(requestHeaders, Headers) ? Object.fromEntries(requestHeaders.entries()) : requestHeaders);
var credentials = resolvedCredentials;
// Apply custom preparation if provided
var prepareRequestBody = _object_spread({}, resolvedBody, requestBody);
var preparePromise = _this.prepareReconnectToStreamRequest ? Promise.resolve(_this.prepareReconnectToStreamRequest({
id: chatId,
requestMetadata: undefined,
body: prepareRequestBody,
credentials: resolvedCredentials,
headers: resolvedHeaders,
api: _this.api
})) : Promise.resolve(null);
return preparePromise.then(function(prepared) {
if (prepared) {
if (prepared.api) api = prepared.api;
if (prepared.headers) {
headers = _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers;
}
if (prepared.credentials) credentials = prepared.credentials;
}
// GET request for reconnection
return fetchFn("".concat(api, "?chatId=").concat(chatId), {
method: 'GET',
headers: headers,
credentials: credentials
}).then(function(response) {
if (!response.ok) {
// 404 means no stream to reconnect to, which is not an error
if (response.status === 404) {
return null;
}
return getHttpErrorMessage(response).then(function(message) {
throw new Error(message);
});
}
if (!response.body) {
return null;
}
return _this.processResponseStream(response.body);
});
});
});
}
}
]);
return HttpChatTransport;
}();
/**
* Default chat transport implementation using NDJSON streaming.
*/ var DefaultChatTransport = /*#__PURE__*/ function(HttpChatTransport) {
_inherits(DefaultChatTransport, HttpChatTransport);
function DefaultChatTransport() {
var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
_class_call_check(this, DefaultChatTransport);
return _call_super(this, DefaultChatTransport, [
options
]);
}
_create_class(DefaultChatTransport, [
{
key: "processResponseStream",
value: function processResponseStream(stream) {
return parseJsonEventStream(stream);
}
}
]);
return DefaultChatTransport;
}(HttpChatTransport);
var withUsage$q = createDocumentationMessageGenerator({
name: 'chat',
connector: true
});
var DEFAULT_TOOL_TIMEOUT = 20000;
var TOOL_TIMEOUT_ERROR_TEXT = 'The tool call timed out before a result was received. The operation may have completed.';
var TOOL_ABORTED_ERROR_TEXT = 'The tool call was cancelled before a result was received.';
var OPEN_STATE_CACHE_KEY = 'instantsearch-chat-open-state';
function normalizePersistence(persistence, hasCustomChat) {
if (hasCustomChat) {
return {
messages: false,
open: persistence === undefined || (typeof persistence === "undefined" ? "undefined" : _type_of(persistence)) === 'object' && persistence.open === true
};
}
if (persistence === undefined || persistence === true) {
return {
messages: true,
open: true
};
}
if (persistence === false) {
return {
messages: false,
open: false
};
}
return {
messages: persistence.messages === true,
open: persistence.open === true
};
}
function getOpenStateCacheKey(type) {
return "".concat(OPEN_STATE_CACHE_KEY, "-").concat(type);
}
function readPersistedOpen(type) {
try {
return safelyRunOnBrowser(function(param) {
var browserWindow = param.window;
return browserWindow.sessionStorage.getItem(getOpenStateCacheKey(type)) === 'true';
}, {
fallback: function fallback() {
return false;
}
});
} catch (unused) {
return false;
}
}
function writePersistedOpen(type, open) {
try {
safelyRunOnBrowser(function(param) {
var browserWindow = param.window;
browserWindow.sessionStorage.setItem(getOpenStateCacheKey(type), String(open));
});
} catch (unused) {
// Storage availability must not block the visible state change.
}
}
function getAttributesToClear$1(param) {
var results = param.results, helper = param.helper;
return uniq(getRefinements(results, helper.state, true).map(function(refinement) {
return refinement.attribute;
}));
}
/**
* One Algolia `numericFilters` entry: `'price <= 1500'`. The operators are
* exactly the set `helper.addNumericRefinement` accepts, and exactly the set
* the Algolia MCP Server emits.
*/ var NUMERIC_FILTER = /^(.+?)\s*(<=|>=|!=|=|<|>)\s*(-?\d+(?:\.\d+)?)$/;
function updateStateFromSearchToolInput(params, helper) {
// clear all filters first
var attributesToClear = getAttributesToClear$1({
results: helper.lastResults,
helper: helper
});
helper.setState(clearRefinements({
helper: helper,
attributesToClear: attributesToClear
}));
if (params.facetFilters) {
var refinements = flat(params.facetFilters).reduce(function(acc, filter) {
var separatorIndex = filter.indexOf(':');
if (separatorIndex > 0) {
acc.push({
attribute: filter.slice(0, separatorIndex),
value: filter.slice(separatorIndex + 1)
});
}
return acc;
}, []);
var hierarchicalRefinements = new Map();
refinements.forEach(function(param) {
var attribute = param.attribute, value = param.value;
var hierarchicalFacet = helper.state.hierarchicalFacets.find(function(facet) {
return facet.name === attribute || facet.attributes.includes(attribute);
});
if (hierarchicalFacet) {
var currentValue = hierarchicalRefinements.get(hierarchicalFacet.name);
if (currentValue === undefined || value.length > currentValue.length) {
hierarchicalRefinements.set(hierarchicalFacet.name, value);
}
return;
}
if (!helper.state.isConjunctiveFacet(attribute) && !helper.state.isDisjunctiveFacet(attribute)) {
helper.setState(helper.state.addDisjunctiveFacet(attribute));
}
helper.toggleFacetRefinement(attribute, value);
});
hierarchicalRefinements.forEach(function(value, name) {
helper.toggleFacetRefinement(name, value);
});
}
if (params.numericFilters) {
params.numericFilters.forEach(function(filter) {
var match = filter.match(NUMERIC_FILTER);
if (!match) {
return;
}
var _match = _sliced_to_array(match, 4), attribute = _match[1], operator = _match[2], value = _match[3];
helper.addNumericRefinement(attribute, operator, Number(value));
});
}
if (params.query) {
helper.setQuery(params.query);
}
helper.search();
return helper.state;
}
var connectChat = function connectChat(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$q());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_resume = _ref.resume, resume = _ref_resume === void 0 ? false : _ref_resume, tmp = _ref.tools, tools_ = tmp === void 0 ? {} : tmp, _ref_type = _ref.type, type = _ref_type === void 0 ? 'chat' : _ref_type, persistence = _ref.persistence, context = _ref.context, initialUserMessage = _ref.initialUserMessage, initialMessages = _ref.initialMessages, _ref_disableTriggerValidation = _ref.disableTriggerValidation, disableTriggerValidation = _ref_disableTriggerValidation === void 0 ? false : _ref_disableTriggerValidation, _ref_sendAutomaticallyWhen = _ref.sendAutomaticallyWhen, sendAutomaticallyWhen = _ref_sendAutomaticallyWhen === void 0 ? lastAssistantMessageIsCompleteWithToolCalls : _ref_sendAutomaticallyWhen, _ref_requiresSearch = _ref.requiresSearch, requiresSearch = _ref_requiresSearch === void 0 ? true : _ref_requiresSearch, options = _object_without_properties(_ref, [
"resume",
"tools",
"type",
"persistence",
"context",
"initialUserMessage",
"initialMessages",
"disableTriggerValidation",
"sendAutomaticallyWhen",
"requiresSearch"
]);
var normalizedPersistence = normalizePersistence(persistence, 'chat' in options);
// The Algolia MCP Server exposes the search tool once per index and names
// it after the index (`algolia_search_index_products`). A `matchesToolName`
// set by the user wins, as does a tool registered under the derived name.
var tools = tools_[SearchIndexToolType] && tools_[SearchIndexToolType].matchesToolName === undefined ? _object_spread_props(_object_spread({}, tools_), _define_property({}, SearchIndexToolType, _object_spread_props(_object_spread({}, tools_[SearchIndexToolType]), {
matchesToolName: matchesSearchIndexToolName
}))) : tools_;
var _chatInstance;
var input = '';
var open = false;
var sendEvent;
var setInput;
var setOpen;
var focusInput;
var inputFocusRequested = false;
var setFeedbackState;
var hasValidatedEntryPoints = false;
var agentId = 'agentId' in options ? options.agentId : undefined;
// Collected here rather than by the tool that searched: that tool renders
// nothing while Grouped Results presents its records, and a record has to
// outlive the render that produced it.
var records = createChatRecordsStore();
var collectRecords = function collectRecords() {
return collectChatRecords(_chatInstance.messages, records);
};
var feedbackState = {};
var _sendChatMessageFeedback;
var feedbackAbortController;
var chatSubscriptionUnsubscribers = [];
var unsubscribeChatCallbacks = function unsubscribeChatCallbacks() {
chatSubscriptionUnsubscribers.splice(0).forEach(function(unsubscribe) {
return unsubscribe();
});
};
var findSuggestionsPart = function findSuggestionsPart(message) {
var _message_parts;
return message === null || message === void 0 ? void 0 : (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.find(function(part) {
var _part_data;
return 'type' in part && part.type === 'data-suggestions' && 'data' in part && Array.isArray((_part_data = part.data) === null || _part_data === void 0 ? void 0 : _part_data.suggestions);
});
};
var findLastAssistantMessage = function findLastAssistantMessage(messages) {
return _to_consumable_array(messages).reverse().find(function(message) {
return message.role === 'assistant' && message.parts;
});
};
// Extract suggestions from the last assistant message's data-suggestions part
var getSuggestionsFromMessages = function getSuggestionsFromMessages(messages) {
var _findSuggestionsPart;
return (_findSuggestionsPart = findSuggestionsPart(findLastAssistantMessage(messages))) === null || _findSuggestionsPart === void 0 ? void 0 : _findSuggestionsPart.data.suggestions;
};
var setMessages = function setMessages(messagesParam) {
if (typeof messagesParam === 'function') {
messagesParam = messagesParam(_chatInstance.messages);
}
_chatInstance.messages = messagesParam;
};
var clearMessages = function clearMessages() {
var status = _chatInstance.status;
if (status === 'submitted' || status === 'streaming') {
_chatInstance.stop();
}
// Reset the non-reactive state first: `setMessages` and `clearError` emit
// ChatState callbacks that synchronously re-render, so they must run last
// for that render to see the cleared feedback and rotated conversation id.
feedbackState = {};
records.clear();
_chatInstance.resetConversationId();
setMessages([]);
_chatInstance.clearError();
};
var validateEntryPoints = function validateEntryPoints(instantSearchInstance) {
if (disableTriggerValidation || hasValidatedEntryPoints) {
return;
}
// warning only relevant once mounted
if (!instantSearchInstance.mainIndex) {
return;
}
walkIndex(instantSearchInstance.mainIndex, function(indexWidget) {
var widgets = indexWidget.getWidgets();
if (widgets.some(function(w) {
return w.opensChat === true;
})) ;
});
hasValidatedEntryPoints = true;
};
// Deferred because entry points can be registered after the chat itself:
// React adds widgets in mount order, so a trigger further down the tree
// only lands after this widget's `init` has run.
var deferredValidateEntryPoints = defer(validateEntryPoints);
var makeChatInstance = function makeChatInstance(instantSearchInstance) {
// A caller supplied `chat` already owns its transport, so it bypasses the
// connector's transport construction and validation below.
if ('chat' in options) {
return options.chat;
}
var transport;
var client = instantSearchInstance.client;
var _getAppIdAndApiKey = _sliced_to_array(getAppIdAndApiKey(client), 2), appId = _getAppIdAndApiKey[0], apiKey = _getAppIdAndApiKey[1];
// Filter out custom data parts (like data-suggestions) that the backend doesn't accept
var filterDataParts = function filterDataParts(messages) {
return messages.map(function(message) {
var _message_parts;
return _object_spread_props(_object_spread({}, message), {
parts: (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.filter(function(part) {
return !('type' in part && part.type.startsWith('data-'));
})
});
});
};
if ('transport' in options && options.transport) {
var originalPrepare = options.transport.prepareSendMessagesRequest;
transport = new DefaultChatTransport(_object_spread_props(_object_spread({}, options.transport), {
prepareSendMessagesRequest: function prepareSendMessagesRequest(params) {
// Call the original prepareSendMessagesRequest if it exists,
// otherwise construct a minimal default body containing only the
// request payload — without leaking transport metadata such as
// resolved headers, api URL, credentials, or `requestMetadata`.
var preparedOrPromise = originalPrepare ? originalPrepare(params) : {
body: _object_spread({
id: params.id,
messageId: params.messageId,
trigger: params.trigger,
messages: params.messages
}, params.body)
};
// Then filter out data-* parts
var applyFilter = function applyFilter(prepared) {
return _object_spread_props(_object_spread({}, prepared), {
body: _object_spread_props(_object_spread({}, prepared.body), {
messages: filterDataParts(prepared.body.messages)
})
});
};
// Handle both sync and async cases
if (preparedOrPromise && 'then' in preparedOrPromise) {
return preparedOrPromise.then(applyFilter);
}
return applyFilter(preparedOrPromise);
}
}));
}
if ('agentId' in options && options.agentId) {
var _options_requestOptions, _options_requestOptions1;
if (!appId || !apiKey) {
throw new Error(withUsage$q('Could not extract Algolia credentials from the search client.'));
}
var createApi = function createApi() {
var bypassCache = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
var _options_requestOptions;
var api = new URL("https://".concat(appId, ".algolia.net/agent-studio/1/agents/").concat(agentId, "/completions"));
var queryParameters = _object_spread(_object_spread_props(_object_spread({}, (_options_requestOptions = options.requestOptions) === null || _options_requestOptions === void 0 ? void 0 : _options_requestOptions.queryParameters), {
compatibilityMode: 'ai-sdk-5'
}), bypassCache ? {
cache: false
} : {});
api.search = new URLSearchParams(queryParameters).toString();
return api.toString();
};
var baseApi = createApi();
transport = new DefaultChatTransport({
api: baseApi,
headers: _object_spread_props(_object_spread({}, typeof Headers !== 'undefined' && _instanceof((_options_requestOptions = options.requestOptions) === null || _options_requestOptions === void 0 ? void 0 : _options_requestOptions.headers, Headers) ? Object.fromEntries(options.requestOptions.headers.entries()) : (_options_requestOptions1 = options.requestOptions) === null || _options_requestOptions1 === void 0 ? void 0 : _options_requestOptions1.headers), {
// Preserve the required Algolia identity headers and chat agent
// marker, even when requestOptions.headers contains the same keys.
'x-algolia-application-id': appId,
'x-algolia-api-key': apiKey,
'x-algolia-agent': "".concat(getAlgoliaAgent(client), "; chat")
}),
prepareSendMessagesRequest: function prepareSendMessagesRequest(param) {
var id = param.id, messages = param.messages, trigger = param.trigger, messageId = param.messageId;
return {
// Bypass cache when regenerating to ensure fresh responses
api: trigger === 'regenerate-message' ? createApi(true) : baseApi,
body: {
id: id,
messageId: messageId,
messages: filterDataParts(messages)
}
};
}
});
}
if (!transport) {
throw new Error(withUsage$q('You need to provide either an `agentId` or a `transport`.'));
}
var canRepairRestoredPendingToolParts = !resume;
var chat = new Chat$1(_object_spread_props(_object_spread({}, options), {
persistence: normalizedPersistence.messages,
sendAutomaticallyWhen: sendAutomaticallyWhen,
transport: transport,
shouldRepairToolInput: function shouldRepairToolInput(toolName) {
var tool = findTool(toolName, tools);
if (!tool) return true;
return Boolean(tool.streamInput);
},
shouldRepairRestoredPendingToolPart: function shouldRepairRestoredPendingToolPart(param) {
var toolName = param.toolName;
var tool = findTool(toolName, tools);
return Boolean(canRepairRestoredPendingToolParts && (tool === null || tool === void 0 ? void 0 : tool.onToolCall) && tool.timeout !== false);
},
resolveCancelledToolOutput: function resolveCancelledToolOutput(param) {
var toolName = param.toolName, toolCallId = param.toolCallId, input = param.input;
var _findTool;
var cancelOutput = (_findTool = findTool(toolName, tools)) === null || _findTool === void 0 ? void 0 : _findTool.cancelOutput;
if (!cancelOutput) return undefined;
try {
var output = cancelOutput({
toolCallId: toolCallId,
input: input
});
// `undefined` means the tool declined to provide an output.
return output === undefined ? undefined : {
output: output
};
} catch (unused) {
return undefined;
}
},
onToolCall: function onToolCall(param, submitToolResult) {
var toolCall = param.toolCall, signal = param.signal;
var tool = findTool(toolCall.toolName, tools);
if (!tool) {
return submitToolResult({
output: 'No tool implemented for "'.concat(toolCall.toolName, '".'),
tool: toolCall.toolName,
toolCallId: toolCall.toolCallId
});
}
if (tool.onToolCall) {
var toolAbortController = new AbortController();
var timeoutId;
var settled = false;
var resolveExecution;
var rejectExecution;
var execution = new Promise(function(resolve, reject) {
resolveExecution = resolve;
rejectExecution = reject;
});
var cleanup = function cleanup() {
if (timeoutId !== undefined) {
clearTimeout(timeoutId);
}
signal.removeEventListener('abort', abortToolCall);
};
var addToolResult = function addToolResult(options) {
if (settled) return Promise.resolve();
settled = true;
cleanup();
var submission = submitToolResult(_object_spread_props(_object_spread({}, options), {
tool: toolCall.toolName,
toolCallId: toolCall.toolCallId
}));
submission.then(resolveExecution, rejectExecution);
return submission;
};
var addToolError = function addToolError(error) {
var errorText = _instanceof(error, Error) ? error.message : String(error !== null && error !== void 0 ? error : '');
return addToolResult({
state: 'output-error',
errorText: errorText || 'Tool call failed.'
});
};
function abortToolCall() {
var submission = addToolResult({
state: 'output-error',
errorText: TOOL_ABORTED_ERROR_TEXT
});
toolAbortController.abort();
void submission.catch(function() {
return undefined;
});
}
if (signal.aborted) {
abortToolCall();
return execution;
}
signal.addEventListener('abort', abortToolCall, {
once: true
});
if (tool.timeout !== false) {
var _tool_timeout;
timeoutId = setTimeout(function() {
var submission = addToolResult({
state: 'output-error',
errorText: TOOL_TIMEOUT_ERROR_TEXT
});
toolAbortController.abort();
void submission.catch(function() {
return undefined;
});
}, (_tool_timeout = tool.timeout) !== null && _tool_timeout !== void 0 ? _tool_timeout : DEFAULT_TOOL_TIMEOUT);
}
var toolExecution;
try {
toolExecution = tool.onToolCall(_object_spread_props(_object_spread({}, toolCall), {
addToolResult: addToolResult,
signal: toolAbortController.signal
}));
} catch (error) {
return addToolError(error);
}
var returnedExecution = Promise.resolve(toolExecution).catch(addToolError);
if (tool.timeout === false) {
return Promise.race([
returnedExecution.then(cleanup),
execution
]);
}
void returnedExecution.catch(function() {
return undefined;
});
return execution;
}
return Promise.resolve();
}
}));
if (resume) {
var resumeStream = chat.resumeStream;
chat.resumeStream = function(requestOptions) {
return resumeStream(requestOptions).finally(function() {
canRepairRestoredPendingToolParts = true;
chat['~repairRestoredPendingToolParts']();
});
};
}
return chat;
};
return {
$$type: 'ais.chat',
dependsOn: requiresSearch ? 'search' : 'none',
init: function init(initOptions) {
var _this = this;
var instantSearchInstance = initOptions.instantSearchInstance;
deferredValidateEntryPoints(instantSearchInstance);
open = normalizedPersistence.open ? readPersistedOpen(type) : false;
records.clear();
_chatInstance = makeChatInstance(instantSearchInstance);
var render = function render() {
renderFn(_object_spread_props(_object_spread({}, _this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), false);
};
var updateOpen = function updateOpen(nextOpen, requestFocus) {
open = nextOpen;
inputFocusRequested = nextOpen && (inputFocusRequested || requestFocus);
if (normalizedPersistence.open) {
writePersistedOpen(type, open);
}
render();
// `open` is read by sibling widgets (e.g. `chatTrigger`) via the
// shared `renderState`. Schedule a full re-render so they pick up
// the new value instead of staying frozen on their initial state.
// No search runs here, so it must not settle the main search.
initOptions.instantSearchInstance.scheduleRender(false);
};
setOpen = function setOpen(nextOpen) {
updateOpen(nextOpen, nextOpen && !open);
};
focusInput = function focusInput() {
updateOpen(true, true);
};
setInput = function setInput(i) {
input = i;
render();
};
setFeedbackState = function setFeedbackState(messageId, state) {
feedbackState = _object_spread_props(_object_spread({}, feedbackState), _define_property({}, messageId, state));
render();
};
var feedback = 'feedback' in options ? options.feedback : undefined;
if (agentId && feedback) {
var _getAppIdAndApiKey = _sliced_to_array(getAppIdAndApiKey(initOptions.instantSearchInstance.client), 2), appId = _getAppIdAndApiKey[0], apiKey = _getAppIdAndApiKey[1];
if (!appId || !apiKey) {
throw new Error(withUsage$q('Could not extract Algolia credentials from the search client.'));
}
feedbackAbortController = new AbortController();
_sendChatMessageFeedback = function _sendChatMessageFeedback(messageId, vote) {
if (feedbackState[messageId] !== undefined) {
return;
}
setFeedbackState(messageId, 'sending');
sendChatMessageFeedback({
agentId: agentId,
vote: vote,
messageId: messageId,
appId: appId,
apiKey: apiKey
}).finally(function() {
setFeedbackState(messageId, vote);
});
};
}
var hasExistingMessages = _chatInstance.messages.length > 0;
// Unsubscribe previous callbacks before setting initialMessages, then
// register the current callbacks after to avoid re-renders during init.
// A server render owns no conversation, so it leaves the instance empty.
safelyRunOnBrowser(function() {
unsubscribeChatCallbacks();
if ((initialMessages === null || initialMessages === void 0 ? void 0 : initialMessages.length) && !resume && !hasExistingMessages) {
_chatInstance.messages = initialMessages;
}
});
// Sibling entry points read `status` through the shared `renderState` to
// disable themselves, so a transition has to escape this widget's own
// render. Message deltas deliberately don't: they stay local to keep
// streaming cheap. The `status` setter notifies on every write, hence
// the comparison. A chat turn is not a search, so the render it
// schedules must not settle the main search.
var lastStatus = _chatInstance.status;
var renderOnStatusChange = function renderOnStatusChange() {
var statusChanged = _chatInstance.status !== lastStatus;
lastStatus = _chatInstance.status;
render();
if (statusChanged) {
initOptions.instantSearchInstance.scheduleRender(false);
}
};
safelyRunOnBrowser(function() {
chatSubscriptionUnsubscribers = [
_chatInstance['~registerErrorCallback'](render),
// Before `render`, so a delta's records are collected by the time
// the tools of that delta render.
_chatInstance['~registerMessagesCallback'](collectRecords),
_chatInstance['~registerMessagesCallback'](render),
_chatInstance['~registerStatusCallback'](renderOnStatusChange)
];
});
// Resuming and sending reach the network, which a server render must
// not: the HTML pass repeats what `getServerState` already rendered, so
// each send happens at least twice, and each failure resolves into chat
// state well after the render that started it has finished.
safelyRunOnBrowser(function() {
if (resume) {
_chatInstance.resumeStream();
}
if (initialUserMessage && !resume && !hasExistingMessages) {
_chatInstance.sendMessage({
text: initialUserMessage
});
}
});
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
// A restored open panel is new to the sibling entry points, but it is
// not a search result.
if (open) {
instantSearchInstance.scheduleRender(false);
}
},
render: function render(renderOptions) {
validateEntryPoints(renderOptions.instantSearchInstance);
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), _define_property({}, type, this.getWidgetRenderState(renderOptions)));
},
getWidgetRenderState: function getWidgetRenderState(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance, parent = renderOptions.parent, helper = renderOptions.helper;
if (!_chatInstance) {
this.init(_object_spread_props(_object_spread({}, renderOptions), {
uiState: {},
results: undefined
}));
}
if (!sendEvent) {
sendEvent = createSendEventForHits({
instantSearchInstance: renderOptions.instantSearchInstance,
helper: renderOptions.helper,
widgetType: this.$$type
});
}
function applyFilters(params) {
return updateStateFromSearchToolInput(params, helper);
}
// A restored or server-rendered conversation never emitted the messages
// callback above; collecting is idempotent, so covering it here is free.
collectRecords();
var insightsEventContext = {
agentId: agentId,
instantSearchStatus: instantSearchInstance.status
};
var toolsWithAddToolResult = {};
Object.entries(tools).forEach(function(param) {
var _param = _sliced_to_array(param, 2), key = _param[0], tool = _param[1];
var toolWithAddToolResult = _object_spread_props(_object_spread({}, tool), {
addToolResult: _chatInstance.addToolResult,
'~addToolResultForMessage': _chatInstance['~addToolResultForMessage'],
applyFilters: applyFilters,
sendEvent: sendEvent,
insightsEventContext: insightsEventContext,
records: records
});
toolsWithAddToolResult[key] = toolWithAddToolResult;
});
var sendMessageWithContext = function sendMessageWithContext(message) {
for(var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
rest[_key - 1] = arguments[_key];
}
var _chatInstance1;
if (!context || !message) {
var _chatInstance2;
return (_chatInstance2 = _chatInstance).sendMessage.apply(_chatInstance2, [
message
].concat(_to_consumable_array(rest)));
}
// Resolve once per send; let the server validate the payload and
// surface any contract violations.
var turnContext = typeof context === 'function' ? context() : context;
return (_chatInstance1 = _chatInstance).sendMessage.apply(_chatInstance1, [
_object_spread_props(_object_spread({}, message), {
metadata: _object_spread_props(_object_spread({}, message.metadata), {
turnContext: turnContext
})
})
].concat(_to_consumable_array(rest)));
};
var renderState = {
indexUiState: instantSearchInstance.getUiState()[parent.getIndexId()],
input: input,
open: open,
sendEvent: sendEvent,
setIndexUiState: parent.setIndexUiState.bind(parent),
setInput: setInput,
setOpen: setOpen,
focusInput: focusInput,
'~consumeInputFocus': function() {
var shouldFocus = inputFocusRequested;
inputFocusRequested = false;
return shouldFocus;
},
'~isOpenStatePersistenceEnabled': normalizedPersistence.open,
setMessages: setMessages,
suggestions: getSuggestionsFromMessages(_chatInstance.messages),
clearMessages: clearMessages,
tools: toolsWithAddToolResult,
records: records,
sendChatMessageFeedback: _sendChatMessageFeedback,
feedbackState: feedbackState,
widgetParams: widgetParams,
// Chat instance render state
addToolResult: _chatInstance.addToolResult,
clearError: _chatInstance.clearError,
error: _chatInstance.error,
id: _chatInstance.id,
messages: _chatInstance.messages,
regenerate: _chatInstance.regenerate,
resumeStream: _chatInstance.resumeStream,
sendMessage: sendMessageWithContext,
status: _chatInstance.status,
stop: _chatInstance.stop
};
return renderState;
},
dispose: function dispose() {
deferredValidateEntryPoints.cancel();
feedbackAbortController === null || feedbackAbortController === void 0 ? void 0 : feedbackAbortController.abort();
unsubscribeChatCallbacks();
unmountFn();
},
shouldRender: function shouldRender() {
return true;
},
get chatInstance () {
return _chatInstance;
}
};
};
};
var subscribe = function subscribe() {
return function() {};
};
var getClientSnapshot = function getClientSnapshot() {
return true;
};
var getServerSnapshot = function getServerSnapshot() {
return false;
};
function useNativeIsHydrated() {
return React__namespace.useSyncExternalStore(subscribe, getClientSnapshot, getServerSnapshot);
}
// React 16 and 17 have no `useSyncExternalStore`, so the flip waits for an
// effect and the render itself cannot tell hydration from a plain mount. These
// contexts provide that signal for the supported `getServerState` and
// `InstantSearchSSRProvider` flow: the server context covers state collection,
// and the SSR context covers HTML rendering and hydration.
//
// The shim's React 16 and 17 fallback ignores the server snapshot, so using it
// here would not distinguish initial hydration from later provider children.
function useLegacyIsHydrated() {
var _ssrContext_hydrationCompleteRef;
var serverContext = useInstantSearchServerContext();
var ssrContext = useInstantSearchSSRContext();
var isServerRendered = serverContext !== null || ssrContext !== null;
var isProviderHydrated = (ssrContext === null || ssrContext === void 0 ? void 0 : (_ssrContext_hydrationCompleteRef = ssrContext.hydrationCompleteRef) === null || _ssrContext_hydrationCompleteRef === void 0 ? void 0 : _ssrContext_hydrationCompleteRef.current) === true;
var _React_useState = _sliced_to_array(React__namespace.useState(!isServerRendered || isProviderHydrated), 2), isHydrated = _React_useState[0], setIsHydrated = _React_useState[1];
React__namespace.useEffect(function() {
setIsHydrated(true);
}, []);
return isHydrated;
}
/**
* Whether this render can use browser state, or has to reproduce the markup a
* server produced without it.
*
* @internal
*/ var useIsHydrated = typeof React__namespace.useSyncExternalStore === 'function' ? useNativeIsHydrated : useLegacyIsHydrated;
function useChat(props, additionalWidgetProperties) {
var isHydrated = useIsHydrated();
React.useRef(props);
React.useRef(null);
useIsomorphicLayoutEffect(function() {});
var chatState = useConnector(connectChat, props, additionalWidgetProperties);
useIsomorphicLayoutEffect(function() {});
if (isHydrated) {
return chatState;
}
// Server rendering only promises the closed Chat shell, so a render that has
// to reproduce that markup shows no conversation either. `status` is pinned
// with `messages` because it diverges two ways: a server render suppresses
// `resumeStream()`, which the browser runs synchronously while initialising,
// and a caller-owned chat can already be streaming. `error` is pinned because
// a caller-owned chat can already have failed, which a connector-built one
// cannot, since its failures arrive in a microtask. `suggestions` is pinned
// because the connector derives them from those messages. Only an `id` given
// as a connector option passes through, because that value is the same on
// both sides. Anything else is withheld: the default is random per Chat, and
// an `id` carried by a caller-owned instance is no safer, since the server and
// the browser each construct their own.
return _object_spread_props(_object_spread({}, chatState), {
error: undefined,
id: 'id' in props && props.id || '',
messages: [],
open: false,
status: 'ready',
suggestions: undefined
});
}
function isHeaders$1(headers) {
return !Array.isArray(headers) && 'entries' in headers && typeof headers.entries === 'function';
}
function headersToRecord$1(headers) {
if (!headers) {
return {};
}
if (isHeaders$1(headers)) {
return Object.fromEntries(headers.entries());
}
if (Array.isArray(headers)) {
return Object.fromEntries(headers);
}
return headers;
}
function withJsonContentType(headers) {
var merged = _object_spread({}, headersToRecord$1(headers));
Object.keys(merged).forEach(function(name) {
if (name.toLowerCase() === 'content-type') {
delete merged[name];
}
});
merged['Content-Type'] = 'application/json';
return merged;
}
function withStreamParam(url) {
return url.includes('?') ? "".concat(url, "&stream=true") : "".concat(url, "?stream=true");
}
function createTaskPreparationContext(context) {
function hideProperty(key) {
var value = context[key];
Object.defineProperty(context, key, {
configurable: true,
enumerable: false,
get: function get() {
return value;
},
set: function set(nextValue) {
Reflect.deleteProperty(context, key);
Object.defineProperty(context, key, {
configurable: true,
enumerable: true,
value: nextValue,
writable: true
});
}
});
}
// Rich metadata stays out of legacy body spreads until assigned as payload.
hideProperty('stream');
hideProperty('body');
hideProperty('credentials');
hideProperty('headers');
hideProperty('api');
return context;
}
function unwrap(envelope) {
if ((typeof envelope === "undefined" ? "undefined" : _type_of(envelope)) === 'object' && envelope !== null && 'output' in envelope) {
return envelope.output;
}
return undefined;
}
function consumeTaskTextStream(body, onData) {
return new Promise(function(resolve, reject) {
var decoder = new TextDecoder();
var reader = body.getReader();
var accumulatedText = '';
var latest;
var publish = function publish(output) {
if (!isEqual(output, latest)) {
latest = output;
onData === null || onData === void 0 ? void 0 : onData({
output: output
});
}
};
var read = function read1() {
reader.read().then(function(param) {
var done = param.done, value = param.value;
if (done) {
accumulatedText += decoder.decode();
reader.releaseLock();
try {
var output = JSON.parse(accumulatedText);
publish(output);
resolve({
output: output
});
} catch (error) {
reject(error);
}
return;
}
try {
accumulatedText += decoder.decode(value, {
stream: true
});
var partial = parsePartialJson(accumulatedText, latest);
if (partial !== undefined) {
publish(partial);
}
read();
} catch (error) {
reader.releaseLock();
reject(error);
}
}, function(error) {
reader.releaseLock();
reject(error);
});
};
read();
});
}
/** Default HTTP transport for named Tasks requests and task-output streams. */ var DefaultTaskTransport = /*#__PURE__*/ function() {
function DefaultTaskTransport() {
var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_api = _ref.api, api = _ref_api === void 0 ? '/api/tasks' : _ref_api, credentials = _ref.credentials, headers = _ref.headers, body = _ref.body, customFetch = _ref.fetch, prepareSendMessagesRequest = _ref.prepareSendMessagesRequest;
_class_call_check(this, DefaultTaskTransport);
_define_property(this, "api", void 0);
_define_property(this, "credentials", void 0);
_define_property(this, "headers", void 0);
_define_property(this, "body", void 0);
_define_property(this, "fetch", void 0);
_define_property(this, "prepareSendMessagesRequest", void 0);
this.api = api;
this.credentials = credentials;
this.headers = headers;
this.body = body;
this.fetch = customFetch;
this.prepareSendMessagesRequest = prepareSendMessagesRequest;
}
_create_class(DefaultTaskTransport, [
{
key: "sendTask",
value: function sendTask(param) {
var task = param.task, kind = param.kind, input = param.input, stream = param.stream, onData = param.onData;
return this.sendTaskRequest({
task: task,
kind: kind,
input: input,
stream: stream,
onData: onData ? function(data) {
return onData(unwrap(data));
} : undefined
}).then(unwrap);
}
},
{
/** @internal */ key: "sendTaskRequest",
value: function sendTaskRequest(param) {
var _this = this;
var task = param.task, kind = param.kind, input = param.input, stream = param.stream, onData = param.onData;
var _this_fetch;
var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
return Promise.all([
resolveValue(this.credentials),
resolveValue(this.headers),
resolveValue(this.body)
]).then(function(param) {
var _param = _sliced_to_array(param, 3), resolvedCredentials = _param[0], resolvedHeaders = _param[1], resolvedBody = _param[2];
var api = _this.api;
var credentials = resolvedCredentials;
var headers = withJsonContentType(resolvedHeaders);
var body = _object_spread(_object_spread_props(_object_spread({}, task === undefined ? {} : {
task: task
}, kind === undefined ? {} : {
kind: kind
}), {
input: input
}), resolvedBody);
var preparedBody = resolvedBody ? _object_spread({}, resolvedBody) : undefined;
var preparePromise = _this.prepareSendMessagesRequest ? Promise.resolve(_this.prepareSendMessagesRequest(createTaskPreparationContext({
task: task,
kind: kind,
input: input,
stream: stream,
body: preparedBody,
credentials: resolvedCredentials,
headers: resolvedHeaders,
api: _this.api
}))) : Promise.resolve(null);
return preparePromise.then(function(prepared) {
if (prepared) {
body = prepared.body;
if (prepared.api) {
api = prepared.api;
}
if (prepared.credentials) {
credentials = prepared.credentials;
}
if (prepared.headers) {
headers = withJsonContentType(prepared.headers);
}
}
var request = {
method: 'POST',
headers: headers,
body: JSON.stringify(body)
};
if (credentials !== undefined) {
request.credentials = credentials;
}
return fetchFn(stream ? withStreamParam(api) : api, request).then(function(response) {
var _response_headers_get, _response_headers;
if (!response.ok) {
throw new Error("HTTP error ".concat(response.status));
}
var contentType = ((_response_headers = response.headers) === null || _response_headers === void 0 ? void 0 : (_response_headers_get = _response_headers.get) === null || _response_headers_get === void 0 ? void 0 : _response_headers_get.call(_response_headers, 'content-type')) || '';
if (stream && contentType.includes('text/plain')) {
if (!response.body) {
throw new Error('Response body is empty');
}
return consumeTaskTextStream(response.body, onData);
}
return response.json();
});
});
});
}
}
]);
return DefaultTaskTransport;
}();
function buildEndpoint(param) {
var appId = param.appId, agentId = param.agentId;
return "https://".concat(appId, ".algolia.net/agent-studio/1/agents/").concat(agentId, "/tasks");
}
function isHeaders(headers) {
return !Array.isArray(headers) && 'entries' in headers && typeof headers.entries === 'function';
}
function headersToRecord(headers) {
if (!headers) {
return {};
}
if (isHeaders(headers)) {
return Object.fromEntries(headers.entries());
}
if (Array.isArray(headers)) {
return Object.fromEntries(headers);
}
return _object_spread({}, headers);
}
function mergeProtectedHeaders(headers, protectedHeaders) {
var merged = headersToRecord(headers);
Object.entries(protectedHeaders).forEach(function(param) {
var _param = _sliced_to_array(param, 2), protectedName = _param[0], value = _param[1];
Object.keys(merged).forEach(function(name) {
if (name.toLowerCase() === protectedName.toLowerCase()) {
delete merged[name];
}
});
merged[protectedName] = value;
});
return merged;
}
/** @internal */ function createTaskTransport(param) {
var _param_transport = param.transport, transport = _param_transport === void 0 ? {} : _param_transport, appId = param.appId, apiKey = param.apiKey, agentId = param.agentId, algoliaAgent = param.algoliaAgent;
var _transport_api;
if (!agentId) {
return new DefaultTaskTransport(transport);
}
if (!appId || !apiKey) {
throw new Error('[tasks] `appId` and `apiKey` are required when `agentId` is provided.');
}
var protectedHeaders = {
'x-algolia-application-id': appId,
'x-algolia-api-key': apiKey
};
if (algoliaAgent) {
protectedHeaders['x-algolia-agent'] = "".concat(algoliaAgent, "; tasks");
}
var originalPrepare = transport.prepareSendMessagesRequest;
var prepareSendMessagesRequest = originalPrepare ? function(request) {
return Promise.resolve(originalPrepare(request)).then(function(prepared) {
return _object_spread_props(_object_spread({}, prepared), {
headers: prepared.headers ? mergeProtectedHeaders(prepared.headers, protectedHeaders) : undefined
});
});
} : undefined;
return new DefaultTaskTransport(_object_spread_props(_object_spread({}, transport), {
api: (_transport_api = transport.api) !== null && _transport_api !== void 0 ? _transport_api : buildEndpoint({
appId: appId,
agentId: agentId
}),
headers: function headers() {
return Promise.resolve(resolveValue(transport.headers)).then(function(headers) {
return mergeProtectedHeaders(headers, protectedHeaders);
});
},
prepareSendMessagesRequest: prepareSendMessagesRequest
}));
}
function createTaskRunner(options) {
var task = options.task, kind = options.kind, _options_stream = options.stream, stream = _options_stream === void 0 ? true : _options_stream;
var transport;
if (options.transport !== undefined) {
transport = options.transport;
} else {
var prepareRequest = options.prepareRequest;
transport = new DefaultTaskTransport({
api: options.endpoint,
headers: options.headers,
fetch: options.fetch,
prepareSendMessagesRequest: prepareRequest ? function(param) {
var requestTask = param.task, requestKind = param.kind, input = param.input;
return prepareRequest(_object_spread_props(_object_spread({}, requestTask === undefined ? {} : {
task: requestTask
}, requestKind === undefined ? {} : {
kind: requestKind
}), {
input: input
}));
} : undefined
});
}
return {
submit: function submit(input) {
var onData = (arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}).onData;
return transport.sendTask({
task: task,
kind: kind,
input: input,
stream: stream,
onData: onData
});
}
};
}
var withUsage$p = createDocumentationMessageGenerator({
name: 'tasks',
connector: true
});
var connectTasks = function connectTasks(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$p());
return function(widgetParams) {
var agentId = widgetParams.agentId, transport = widgetParams.transport, task = widgetParams.task, kind = widgetParams.kind, _widgetParams_stream = widgetParams.stream, stream = _widgetParams_stream === void 0 ? true : _widgetParams_stream;
if (!agentId && !transport) {
throw new Error(withUsage$p('The `agentId` option is required unless a custom `transport` is provided.'));
}
if (!task && !kind) {
throw new Error(withUsage$p('Either the `task` or `kind` option is required.'));
}
var runner;
var output;
var isLoading = false;
var error;
var disposed = false;
var triggerRender = noop;
var requestId = 0;
var submit = function submit(variables) {
if (disposed) return Promise.resolve(undefined);
var currentRequestId = requestId += 1;
var isStale = function isStale() {
return disposed || currentRequestId !== requestId;
};
// Clear the previous output so consumers can show a loading state
// rather than stale data while the new request is in flight.
output = undefined;
error = undefined;
isLoading = true;
triggerRender();
return Promise.resolve().then(function() {
return runner.submit(variables, {
onData: stream ? function(partial) {
if (isStale()) return;
output = partial;
triggerRender();
} : undefined
});
}).then(function(next) {
var result = next;
if (!isStale()) {
output = result;
}
return result;
}).catch(function(err) {
if (!isStale()) {
output = undefined;
error = _instanceof(err, Error) ? err : new Error(String(err));
}
return undefined;
}).finally(function() {
if (isStale()) return;
isLoading = false;
triggerRender();
});
};
var invalidate = function invalidate() {
if (disposed) return;
// Bump the request id so any in-flight request's callbacks see
// `isStale()` and are ignored. The fetch itself is left to complete.
requestId += 1;
output = undefined;
error = undefined;
isLoading = false;
triggerRender();
};
var getWidgetRenderState = function getWidgetRenderState() {
return {
output: output,
isLoading: isLoading,
error: error,
submit: submit,
invalidate: invalidate,
widgetParams: widgetParams
};
};
return {
$$type: 'ais.tasks',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
if (agentId) {
var _getAppIdAndApiKey = _sliced_to_array(getAppIdAndApiKey(instantSearchInstance.client), 2), appId = _getAppIdAndApiKey[0], apiKey = _getAppIdAndApiKey[1];
if (!appId || !apiKey) {
throw new Error(withUsage$p('Could not extract Algolia credentials from the search client.'));
}
var taskTransport = createTaskTransport({
transport: transport,
appId: appId,
apiKey: apiKey,
agentId: agentId,
algoliaAgent: getAlgoliaAgent(instantSearchInstance.client)
});
runner = createTaskRunner({
transport: taskTransport,
task: task,
kind: kind,
stream: stream
});
} else {
runner = createTaskRunner({
transport: createTaskTransport({
transport: transport
}),
task: task,
kind: kind,
stream: stream
});
}
triggerRender = function triggerRender() {
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState()), {
instantSearchInstance: instantSearchInstance
}), false);
};
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState()), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState()), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
dispose: function dispose() {
disposed = true;
unmountFn();
}
};
};
};
var withUsage$o = createDocumentationMessageGenerator({
name: 'prompt-suggestions',
connector: true
});
var RENDER_STATE_KEY = 'promptSuggestions';
var CHAT_RENDER_STATE_KEY = 'chat';
var PROMPT_SUGGESTIONS_TASK_KIND = 'prompt_suggestions';
var DEBOUNCE_MS = 300;
function parseSuggestions(data) {
var suggestions = data === null || data === void 0 ? void 0 : data.suggestions;
if (!Array.isArray(suggestions)) {
return [];
}
return suggestions.filter(function(s) {
return typeof s === 'string';
});
}
// Key order is not significant to the request, so a plain `JSON.stringify` would
// report two identical payloads as different.
function stableKey(value) {
if (value === null || (typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object') {
var _JSON_stringify;
return (_JSON_stringify = JSON.stringify(value)) !== null && _JSON_stringify !== void 0 ? _JSON_stringify : 'null';
}
if (Array.isArray(value)) {
return "[".concat(value.map(stableKey).join(','), "]");
}
var record = value;
return "{".concat(Object.keys(record).sort().map(function(key) {
return "".concat(JSON.stringify(key), ":").concat(stableKey(record[key]));
}).join(','), "}");
}
/**
* Comparable identity of a task payload, or `null` when it cannot be compared.
*/ function taskPayloadKey(payload) {
try {
// Round-trip first so the comparison sees what the request will actually
// carry: `JSON.stringify` applies `toJSON` (a `Date` becomes its ISO string)
// and drops the values the wire drops. Walking the raw object instead would
// read a `Date` as a key-less object and call two different instants equal.
return stableKey(JSON.parse(JSON.stringify(payload)));
} catch (unused) {
// Circular or otherwise unserializable. Never claim a match on a payload we
// could not read; let the request go out and fail where it does today.
return null;
}
}
function stripInternalHitMetadata(hit) {
var clean = {};
Object.keys(hit).forEach(function(key) {
// Strip internal metadata, which is `_`-prefixed
// (`_highlightResult`, `_rankingInfo`, `__position`, …).
if (!key.startsWith('_')) {
clean[key] = hit[key];
}
});
return clean;
}
var DEFAULT_TRANSFORM_HITS = function DEFAULT_TRANSFORM_HITS(hits) {
return hits.slice(0, 5).map(stripInternalHitMetadata);
};
function buildFilters(results) {
var state = results._state;
if (!state) {
return undefined;
}
var groups = [];
var disjunctiveGroups = {};
getRefinements(results, state).forEach(function(refinement) {
if (refinement.type === 'numeric') {
groups.push([
"".concat(refinement.attribute).concat(refinement.operator).concat(refinement.numericValue)
]);
return;
}
var value = refinement.type === 'exclude' ? "".concat(refinement.attribute, ":-").concat(refinement.name) : "".concat(refinement.attribute, ":").concat(refinement.name);
if (refinement.type === 'disjunctive') {
var group = disjunctiveGroups[refinement.attribute];
if (group) {
group.push(value);
} else {
var newGroup = [
value
];
disjunctiveGroups[refinement.attribute] = newGroup;
groups.push(newGroup);
}
return;
}
groups.push([
value
]);
});
return groups.length > 0 ? groups : undefined;
}
var connectPromptSuggestions = function connectPromptSuggestions(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$o());
return function(widgetParams) {
var agentId = widgetParams.agentId, configurationId = widgetParams.configurationId, _widgetParams_transformHits = widgetParams.transformHits, transformHits = _widgetParams_transformHits === void 0 ? DEFAULT_TRANSFORM_HITS : _widgetParams_transformHits, context = widgetParams.context, _widgetParams_transformItems = widgetParams.transformItems, transformItems = _widgetParams_transformItems === void 0 ? function(items) {
return items;
} : _widgetParams_transformItems, transport = widgetParams.transport;
if (!agentId && !transport) {
throw new Error(withUsage$o('The `agentId` option is required unless a custom `transport` is provided.'));
}
var tasksState;
var suggestions = [];
var isLoading = false;
var error;
var debounceTimer;
var lastStateSignature = null;
// The payload of the last request that was actually sent. The automatic
// trigger keys on the search state, which is only a proxy for the payload,
// so this is what decides whether a request would ask anything new.
var lastSubmittedPayload = null;
var latestRenderOptions = null;
// Set in `dispose()`. A debounced or in-flight `fetch()` can resolve after
// the widget is unmounted; this guard stops those late callbacks from
// calling `renderFn` into a torn-down container.
var disposed = false;
// Whether the "is a chat widget mounted on this index?" question has been
// settled — see `validateChat`.
var hasValidatedChat = false;
// True between a state-signature change and the debounced refetch that
// follows it. While pending, the search state has already moved on, so a
// still-in-flight request from the previous state must not paint its
// suggestions, its inner render is ignored until the new `submit` starts.
var refetchPending = false;
// True when `refetchPending` made an inner render be dropped. The fetch
// that dropped it was expected to render in its place; if that fetch turns
// out to send nothing, it has to reconcile the dropped state instead.
var droppedInnerRender = false;
var getStateSignature = function getStateSignature(results) {
var _buildFilters;
if (results.queryID) {
return results.queryID;
}
var query = results.query || '';
var filters = JSON.stringify((_buildFilters = buildFilters(results)) !== null && _buildFilters !== void 0 ? _buildFilters : []);
var hitIds = (results.hits || []).map(function(hit) {
return hit.objectID;
}).join(',');
return "".concat(query, "|").concat(filters, "|").concat(hitIds);
};
var getChatRenderState = function getChatRenderState(renderOptions) {
var _instantSearchInstance_renderState;
var instantSearchInstance = renderOptions.instantSearchInstance, parent = renderOptions.parent;
var indexId = parent ? parent.getIndexId() : '';
if (!indexId || !((_instantSearchInstance_renderState = instantSearchInstance.renderState) === null || _instantSearchInstance_renderState === void 0 ? void 0 : _instantSearchInstance_renderState[indexId])) {
return undefined;
}
return instantSearchInstance.renderState[indexId][CHAT_RENDER_STATE_KEY];
};
var sendToChat = function sendToChat(renderOptions) {
return function(prompt) {
var _ref, _getLatestResults;
var chatRenderState = getChatRenderState(renderOptions);
if (!chatRenderState || !chatRenderState.sendMessage) {
return false;
}
var results = (_ref = (_getLatestResults = getLatestResults()) !== null && _getLatestResults !== void 0 ? _getLatestResults : 'results' in renderOptions ? renderOptions.results : null) !== null && _ref !== void 0 ? _ref : null;
return openChat(chatRenderState, {
message: prompt,
referer: 'prompt-suggestions-widget',
turnContext: buildTurnContext(results)
});
};
};
// `context` may be a function, so the option alone says nothing about what
// a given fetch actually has to send. Resolve it once per fetch and let
// callers read the value rather than the option.
var resolveContext = function resolveContext() {
return typeof context === 'function' ? context() : context;
};
var buildPageContext = function buildPageContext(resolvedContext, results) {
// Explicit context replaces auto-extraction; otherwise derive it from
// the current search state. The task's server-owned instructions decide
// how to interpret the shape — the client doesn't label it.
if (resolvedContext) {
return _object_spread({}, resolvedContext);
}
if (!results) {
return undefined;
}
var filters = buildFilters(results);
return _object_spread_props(_object_spread({
query: results.query || ''
}, filters ? {
filters: filters
} : {}), {
hitsSample: transformHits(results.hits)
});
};
// The same page context, flattened for the chat handoff: `turnContext` is
// a flat `Record<string, string>` per the Agent Studio contract, so
// non-string values (e.g. `hitsSample`) are serialized.
var buildTurnContext = function buildTurnContext(results) {
var pageContext = buildPageContext(resolveContext(), results);
if (!pageContext) {
return undefined;
}
var entries = Object.entries(pageContext).map(function(param) {
var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
return [
key,
typeof value === 'string' ? value : JSON.stringify(value)
];
}).filter(function(param) {
var _param = _sliced_to_array(param, 2), value = _param[1];
return value.trim() !== '';
});
return entries.length > 0 ? Object.fromEntries(entries) : undefined;
};
// `latestRenderOptions` may be the `init()` options, which carry no
// `results` key at all, so the read has to be narrowed rather than
// optional-chained.
var getLatestResults = function getLatestResults() {
var _latestRenderOptions_results;
if (!latestRenderOptions || !('results' in latestRenderOptions)) {
return null;
}
return (_latestRenderOptions_results = latestRenderOptions.results) !== null && _latestRenderOptions_results !== void 0 ? _latestRenderOptions_results : null;
};
var renderOutward = function renderOutward(renderOptions) {
if (disposed) return;
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(renderOptions)), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
};
// Copies an inner render's state into this widget's and re-renders on the
// client.
var adoptInnerState = function adoptInnerState(renderState) {
error = renderState.error;
if (renderState.error) {
// A failed task (including a mid-stream `error` event) must not leave
// any streamed partial visible.
suggestions = [];
} else if (renderState.isLoading || renderState.output !== undefined) {
// Only adopt the inner output once a request is loading or has
// produced one, so the initial no-op render doesn't clobber pills.
suggestions = parseSuggestions(renderState.output);
}
isLoading = renderState.isLoading;
if (!latestRenderOptions) return;
renderOutward(latestRenderOptions);
};
var fetchAndRender = function fetchAndRender(results, renderOptions) {
var _ref = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, _ref_force = _ref.force, force = _ref_force === void 0 ? false : _ref_force;
var _buildPageContext;
var _results_hits;
if (disposed || !tasksState) return;
var hadDroppedInnerRender = droppedInnerRender;
refetchPending = false;
droppedInnerRender = false;
var resolvedContext = resolveContext();
var input = (_buildPageContext = buildPageContext(resolvedContext, results)) !== null && _buildPageContext !== void 0 ? _buildPageContext : {};
// Two ways there is nothing worth sending: no context for this fetch and
// no hits to derive one from, or a context that resolved to something
// empty. The first reads the resolved value rather than the option, so
// `context: () => undefined` is gated exactly like an omitted `context`.
// Sending an empty input spends a model call on no information.
if (resolvedContext === undefined && !(results === null || results === void 0 ? void 0 : (_results_hits = results.hits) === null || _results_hits === void 0 ? void 0 : _results_hits.length) || Object.keys(input).length === 0) {
tasksState.invalidate();
suggestions = [];
isLoading = false;
// The output is gone, so the same payload must be allowed to rebuild it.
lastSubmittedPayload = null;
renderOutward(renderOptions);
return;
}
var payload = taskPayloadKey(input);
// A moved search state does not always mean a different question: with an
// explicit `context` the payload ignores the results entirely, so a new
// `queryID` or a new hit order produces a byte-identical request. Sending
// it again spends a model call on an answer already on screen. Leave the
// current suggestions alone and send nothing. `force` is the explicit
// path (`refresh()`), which must always reach the network.
if (!force && payload !== null && payload === lastSubmittedPayload) {
// Nothing goes out, so nothing will render — but the state change that
// scheduled this fetch also made `handleInnerRender` drop the render
// that was carrying the previous request's result. Reconcile it here or
// the widget keeps that request's `isLoading: true` with no
// suggestions, and nothing later clears it: `refresh()` is blocked by
// its own `isLoading` guard and an unchanged payload keeps skipping.
if (hadDroppedInnerRender) {
adoptInnerState(tasksState);
}
return;
}
lastSubmittedPayload = payload;
tasksState.submit(input);
};
var refresh = function refresh() {
if (isLoading) return;
if (!latestRenderOptions) return;
var results = getLatestResults();
clearTimeout(debounceTimer);
// Only meaningful with results: without them there is no signature for a
// later automatic fetch to compare against.
if (results) {
lastStateSignature = getStateSignature(results);
}
fetchAndRender(results, latestRenderOptions, {
force: true
});
};
var getWidgetRenderState = function getWidgetRenderState(renderOptions) {
var results = 'results' in renderOptions ? renderOptions.results : undefined;
var transformed = transformItems(suggestions, {
query: (results === null || results === void 0 ? void 0 : results.query) || '',
results: results || null
});
var chatRenderState = getChatRenderState(renderOptions);
var isChatBusy$1 = chatRenderState ? !chatRenderState.sendMessage || isChatBusy(chatRenderState) : false;
var send = sendToChat(renderOptions);
// `sendToChat` is withheld only once the mount window has closed: a chat
// widget further down a React tree is added after this widget's `init`,
// so until `validateChat` runs its absence is not yet conclusive and
// withholding the handler would make a valid setup look broken.
var canSendToChat = Boolean(chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.sendMessage) || !hasValidatedChat;
return {
suggestions: transformed,
isLoading: isLoading,
error: error,
onSuggestionClick: canSendToChat ? send : noop,
sendToChat: canSendToChat ? send : undefined,
refresh: refresh,
isChatBusy: isChatBusy$1,
widgetParams: widgetParams
};
};
// Mirrors each inner render (submit start → skeleton, stream partials,
// resolve/error) into this widget's state and re-renders on the client.
var handleInnerRender = function handleInnerRender(renderState) {
tasksState = renderState;
if (renderState.error) {
// Keep a failed payload retryable: without this the next automatic
// attempt with the same payload would be skipped as a duplicate and
// the error would have no way to clear. Set before the `refetchPending`
// return so a failure that lands mid-refetch is not swallowed.
lastSubmittedPayload = null;
}
if (refetchPending) {
droppedInnerRender = true;
return;
}
adoptInnerState(renderState);
};
// Deferred because a chat widget can be registered after this one: React
// adds widgets in mount order, so a `chat` further down the tree only
// lands after this widget's `init` has run. Until this closes the window,
// `sendToChat` is handed out optimistically.
var validateChat = defer(function(renderOptions) {
var _getChatRenderState;
if (hasValidatedChat) return;
hasValidatedChat = true;
if ((_getChatRenderState = getChatRenderState(renderOptions)) === null || _getChatRenderState === void 0 ? void 0 : _getChatRenderState.sendMessage) return;
// A render may already have gone out with the optimistic `sendToChat`;
// re-render so the widget layer sees the settled answer. The `init()`
// options don't count: nothing has painted yet, so the next render
// carries it — and a mount that never renders results shows no pills
// to mislead anyone.
if (latestRenderOptions && 'results' in latestRenderOptions) {
renderOutward(latestRenderOptions);
}
});
var tasksParams;
if (agentId) {
tasksParams = {
agentId: agentId,
transport: transport,
task: configurationId,
kind: PROMPT_SUGGESTIONS_TASK_KIND,
stream: true
};
} else if (transport) {
tasksParams = {
transport: transport,
task: configurationId,
kind: PROMPT_SUGGESTIONS_TASK_KIND,
stream: true
};
} else {
throw new Error(withUsage$o('The `agentId` option is required unless a custom `transport` is provided.'));
}
var tasksWidget = connectTasks(handleInnerRender, noop)(tasksParams);
return {
$$type: 'ais.promptSuggestions',
// Clicking a suggestion opens the chat, so this widget counts as an
// entry point for `connectChat`'s trigger validation.
opensChat: true,
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
tasksWidget.init(initOptions);
// Set after the inner init so its initial no-op render is still
// ignored, and before the first outward render so `refresh()` has a
// render target even on a mount where `render()` never sees results.
latestRenderOptions = initOptions;
validateChat(initOptions);
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
// With an explicit `context` the payload never reads the results, so
// waiting for a search is waiting on something the request does not
// use — and a page that triggers no search (a `searchFunction` query
// gate, or a mount made only for the widgets) would wait forever.
// Fetch here instead, after the first render so the `isFirstRender`
// one still arrives first.
//
// There are no results yet by definition, so "is there anything to
// send" reduces to "did the context resolve to something". Checking it
// here rather than letting `fetchAndRender` reject the call keeps init
// out of the "nothing to send" branch, whose `invalidate()` would add
// two outward renders to every mount that has no context — leaving the
// auto-extracted path, the one that does need results, untouched.
var initialContext = resolveContext();
if (initialContext && Object.keys(initialContext).length > 0) {
fetchAndRender(null, initOptions);
}
},
render: function render(renderOptions) {
var results = renderOptions.results, instantSearchInstance = renderOptions.instantSearchInstance;
latestRenderOptions = renderOptions;
if (!results) {
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
return;
}
var stateSignature = getStateSignature(results);
if (stateSignature !== lastStateSignature) {
lastStateSignature = stateSignature;
refetchPending = true;
error = undefined;
clearTimeout(debounceTimer);
debounceTimer = setTimeout(function() {
var latestResults = getLatestResults();
if (latestResults && latestRenderOptions) {
fetchAndRender(latestResults, latestRenderOptions);
}
}, DEBOUNCE_MS);
}
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose(disposeOptions) {
disposed = true;
clearTimeout(debounceTimer);
validateChat.cancel();
tasksWidget.dispose(disposeOptions);
unmountFn();
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), _define_property({}, RENDER_STATE_KEY, this.getWidgetRenderState(renderOptions)));
},
getWidgetRenderState: function getWidgetRenderState1(renderOptions) {
return getWidgetRenderState(renderOptions);
}
};
};
};
function usePromptSuggestions(props, additionalWidgetProperties) {
return useConnector(connectPromptSuggestions, props, additionalWidgetProperties);
}
var withUsage$n = createDocumentationMessageGenerator({
name: 'chatTrigger',
connector: true
});
// Reads the sibling chat widget's render state from the live cross-index
// `instantSearchInstance.renderState` map. We resolve at call time so that
// `toggleOpen` always sees the latest `open`/`setOpen` values.
function getChatRenderState(options) {
var _options_parent, _options_instantSearchInstance_renderState_indexId;
var indexId = (_options_parent = options.parent) === null || _options_parent === void 0 ? void 0 : _options_parent.getIndexId();
if (!indexId) return undefined;
return (_options_instantSearchInstance_renderState_indexId = options.instantSearchInstance.renderState[indexId]) === null || _options_instantSearchInstance_renderState_indexId === void 0 ? void 0 : _options_instantSearchInstance_renderState_indexId.chat;
}
var connectChatTrigger = function connectChatTrigger(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$n());
return function(widgetParams) {
var params = widgetParams !== null && widgetParams !== void 0 ? widgetParams : {};
var lastOptions = null;
function openChatFromTrigger(options) {
if (!lastOptions) return false;
return openChat(getChatRenderState(lastOptions), options);
}
function toggleOpen() {
if (!lastOptions) return;
var chatState = getChatRenderState(lastOptions);
if (!chatState) return;
if (chatState.open) {
var _chatState_setOpen;
(_chatState_setOpen = chatState.setOpen) === null || _chatState_setOpen === void 0 ? void 0 : _chatState_setOpen.call(chatState, false);
} else {
openChat(chatState);
}
}
return {
$$type: 'ais.chatTrigger',
opensChat: true,
dependsOn: 'none',
init: function init(initOptions) {
lastOptions = initOptions;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
lastOptions = renderOptions;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
dispose: function dispose() {
unmountFn();
},
getWidgetRenderState: function getWidgetRenderState(renderOptions) {
var _ref;
var chatState = getChatRenderState(renderOptions);
return {
open: (_ref = chatState === null || chatState === void 0 ? void 0 : chatState.open) !== null && _ref !== void 0 ? _ref : false,
toggleOpen: toggleOpen,
openChat: openChatFromTrigger,
isChatBusy: chatState ? !chatState.sendMessage || isChatBusy(chatState) : false,
widgetParams: params
};
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
chatTrigger: this.getWidgetRenderState(renderOptions)
});
},
shouldRender: function shouldRender() {
return true;
}
};
};
};
function useChatTrigger() {
var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, additionalWidgetProperties = arguments.length > 1 ? arguments[1] : void 0;
return useConnector(connectChatTrigger, props, additionalWidgetProperties);
}
var withUsage$m = createDocumentationMessageGenerator({
name: 'clear-refinements',
connector: true
});
var connectClearRefinements = function connectClearRefinements(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$m());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_includedAttributes = _ref.includedAttributes, includedAttributes = _ref_includedAttributes === void 0 ? [] : _ref_includedAttributes, _ref_excludedAttributes = _ref.excludedAttributes, excludedAttributes = _ref_excludedAttributes === void 0 ? [
'query'
] : _ref_excludedAttributes, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
if (widgetParams && widgetParams.includedAttributes && widgetParams.excludedAttributes) {
throw new Error(withUsage$m('The options `includedAttributes` and `excludedAttributes` cannot be used together.'));
}
var connectorState = {
refine: noop,
createURL: function createURL() {
return '';
},
attributesToClear: []
};
var cachedRefine = function cachedRefine() {
return connectorState.refine();
};
var cachedCreateURL = function cachedCreateURL() {
return connectorState.createURL();
};
return {
$$type: 'ais.clearRefinements',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose() {
unmountFn();
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
clearRefinements: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var createURL = param.createURL, scopedResults = param.scopedResults, results = param.results;
connectorState.attributesToClear = scopedResults.reduce(function(attributesToClear, scopedResult) {
return attributesToClear.concat(getAttributesToClear({
scopedResult: scopedResult,
includedAttributes: includedAttributes,
excludedAttributes: excludedAttributes,
transformItems: transformItems,
results: results
}));
}, []);
connectorState.refine = function() {
connectorState.attributesToClear.forEach(function(param) {
var indexHelper = param.helper, items = param.items;
indexHelper.setState(clearRefinements({
helper: indexHelper,
attributesToClear: items
})).search();
});
};
connectorState.createURL = function() {
return createURL(mergeSearchParameters.apply(void 0, _to_consumable_array(connectorState.attributesToClear.map(function(param) {
var indexHelper = param.helper, items = param.items;
return clearRefinements({
helper: indexHelper,
attributesToClear: items
});
}))));
};
var canRefine = connectorState.attributesToClear.some(function(attributeToClear) {
return attributeToClear.items.length > 0;
});
return {
canRefine: canRefine,
hasRefinements: canRefine,
refine: cachedRefine,
createURL: cachedCreateURL,
widgetParams: widgetParams
};
}
};
};
};
function getAttributesToClear(param) {
var scopedResult = param.scopedResult, includedAttributes = param.includedAttributes, excludedAttributes = param.excludedAttributes, transformItems = param.transformItems, results = param.results;
var includesQuery = includedAttributes.indexOf('query') !== -1 || excludedAttributes.indexOf('query') === -1;
return {
helper: scopedResult.helper,
items: transformItems(uniq(getRefinements(scopedResult.results, scopedResult.helper.state, includesQuery).map(function(refinement) {
return refinement.attribute;
}).filter(function(attribute) {
return includedAttributes.length === 0 || // Otherwise, only add the specified attributes
includedAttributes.indexOf(attribute) !== -1;
}).filter(function(attribute) {
return attribute === 'query' && includesQuery || // Otherwise, ignore the excluded attributes
excludedAttributes.indexOf(attribute) === -1;
})), {
results: results
})
};
}
function useClearRefinements(props, additionalWidgetProperties) {
return useConnector(connectClearRefinements, props, additionalWidgetProperties);
}
var withUsage$l = createDocumentationMessageGenerator({
name: 'current-refinements',
connector: true
});
var connectCurrentRefinements = function connectCurrentRefinements(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$l());
return function(widgetParams) {
if ((widgetParams || {}).includedAttributes && (widgetParams || {}).excludedAttributes) {
throw new Error(withUsage$l('The options `includedAttributes` and `excludedAttributes` cannot be used together.'));
}
var _ref = widgetParams || {}, includedAttributes = _ref.includedAttributes, _ref_excludedAttributes = _ref.excludedAttributes, excludedAttributes = _ref_excludedAttributes === void 0 ? [
'query'
] : _ref_excludedAttributes, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
return {
$$type: 'ais.currentRefinements',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose() {
unmountFn();
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
currentRefinements: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, scopedResults = param.scopedResults, createURL = param.createURL, helper = param.helper;
function getItems() {
if (!results) {
return transformItems(getRefinementsItems({
results: null,
helper: helper,
indexId: helper.state.index,
includedAttributes: includedAttributes,
excludedAttributes: excludedAttributes
}), {
results: results
});
}
return scopedResults.reduce(function(accResults, scopedResult) {
return accResults.concat(transformItems(getRefinementsItems({
results: scopedResult.results,
helper: scopedResult.helper,
indexId: scopedResult.indexId,
includedAttributes: includedAttributes,
excludedAttributes: excludedAttributes
}), {
results: results
}));
}, []);
}
var items = getItems();
return {
items: items,
canRefine: items.length > 0,
refine: function refine(refinement) {
return clearRefinement(helper, refinement);
},
createURL: function createURL1(refinement) {
return createURL(clearRefinementFromState(helper.state, refinement));
},
widgetParams: widgetParams
};
}
};
};
};
function getRefinementsItems(param) {
var results = param.results, helper = param.helper, indexId = param.indexId, includedAttributes = param.includedAttributes, excludedAttributes = param.excludedAttributes;
var includesQuery = (includedAttributes || []).indexOf('query') !== -1 || (excludedAttributes || []).indexOf('query') === -1;
var filterFunction = includedAttributes ? function(item) {
return includedAttributes.indexOf(item.attribute) !== -1;
} : function(item) {
return excludedAttributes.indexOf(item.attribute) === -1;
};
var items = getRefinements(results, helper.state, includesQuery).map(normalizeRefinement).filter(filterFunction);
return items.reduce(function(allItems, currentItem) {
return _to_consumable_array(allItems.filter(function(item) {
return item.attribute !== currentItem.attribute;
})).concat([
{
indexName: helper.state.index,
indexId: indexId,
attribute: currentItem.attribute,
label: currentItem.attribute,
refinements: items.filter(function(result) {
return result.attribute === currentItem.attribute;
}) // We want to keep the order of refinements except the numeric ones.
.sort(function(a, b) {
return a.type === 'numeric' ? a.value - b.value : 0;
}),
refine: function refine(refinement) {
return clearRefinement(helper, refinement);
}
}
]);
}, []);
}
function clearRefinementFromState(state, refinement) {
state = state.resetPage();
switch(refinement.type){
case 'facet':
return state.removeFacetRefinement(refinement.attribute, String(refinement.value));
case 'disjunctive':
return state.removeDisjunctiveFacetRefinement(refinement.attribute, String(refinement.value));
case 'hierarchical':
return state.removeHierarchicalFacetRefinement(refinement.attribute);
case 'exclude':
return state.removeExcludeRefinement(refinement.attribute, String(refinement.value));
case 'numeric':
return state.removeNumericRefinement(refinement.attribute, refinement.operator, String(refinement.value));
case 'tag':
return state.removeTagRefinement(String(refinement.value));
case 'query':
return state.setQueryParameter('query', '');
default:
return state;
}
}
function clearRefinement(helper, refinement) {
helper.setState(clearRefinementFromState(helper.state, refinement)).search();
}
function getOperatorSymbol(operator) {
switch(operator){
case '>=':
return '≥';
case '<=':
return '≤';
default:
return operator;
}
}
function normalizeRefinement(refinement) {
var value = getValue(refinement);
var label = refinement.operator ? "".concat(getOperatorSymbol(refinement.operator), " ").concat(refinement.name) : refinement.name;
var normalizedRefinement = {
attribute: refinement.attribute,
type: refinement.type,
value: value,
label: label
};
if (refinement.operator !== undefined) {
normalizedRefinement.operator = refinement.operator;
}
if (refinement.count !== undefined) {
normalizedRefinement.count = refinement.count;
}
if (refinement.exhaustive !== undefined) {
normalizedRefinement.exhaustive = refinement.exhaustive;
}
return normalizedRefinement;
}
function getValue(refinement) {
if (refinement.type === 'numeric') {
return Number(refinement.name);
}
if ('escapedValue' in refinement) {
return refinement.escapedValue;
}
return refinement.name;
}
function useCurrentRefinements(props, additionalWidgetProperties) {
return useConnector(connectCurrentRefinements, props, additionalWidgetProperties);
}
var withUsage$k = createDocumentationMessageGenerator({
name: 'frequently-bought-together',
connector: true
});
var connectFrequentlyBoughtTogether = function connectFrequentlyBoughtTogether(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$k());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_escapeHTML = _ref.escapeHTML, escapeHTML = _ref_escapeHTML === void 0 ? true : _ref_escapeHTML, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems, objectIDs = _ref.objectIDs, limit = _ref.limit, threshold = _ref.threshold, fallbackParameters = _ref.fallbackParameters, queryParameters = _ref.queryParameters;
if (!objectIDs || objectIDs.length === 0) {
throw new Error(withUsage$k('The `objectIDs` option is required.'));
}
var sendEvent;
return {
dependsOn: 'recommend',
$$type: 'ais.frequentlyBoughtTogether',
init: function init(initOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var renderState = this.getWidgetRenderState(renderOptions);
renderFn(_object_spread_props(_object_spread({}, renderState), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
getRenderState: function getRenderState(renderState) {
return renderState;
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, helper = param.helper, instantSearchInstance = param.instantSearchInstance;
if (!sendEvent) {
sendEvent = createSendEventForHits({
instantSearchInstance: instantSearchInstance,
helper: helper,
widgetType: this.$$type
});
}
if (results === null || results === undefined) {
return {
items: [],
widgetParams: widgetParams,
sendEvent: sendEvent
};
}
if (escapeHTML && results.hits.length > 0) {
results.hits = escapeHits(results.hits);
}
var itemsWithAbsolutePosition = addAbsolutePosition$1(results.hits, 0, 1);
var itemsWithAbsolutePositionAndQueryID = addQueryID$1(itemsWithAbsolutePosition, results.queryID);
var transformedItems = transformItems(itemsWithAbsolutePositionAndQueryID, {
results: results
});
return {
items: transformedItems,
widgetParams: widgetParams,
sendEvent: sendEvent
};
},
dispose: function dispose(param) {
var recommendState = param.recommendState;
unmountFn();
return recommendState.removeParams(this.$$id);
},
getWidgetParameters: function getWidgetParameters(state) {
var _this = this;
return objectIDs.reduce(function(acc, objectID) {
return acc.addFrequentlyBoughtTogether({
objectID: objectID,
maxRecommendations: limit,
threshold: threshold,
// @ts-expect-error until @algolia/recommend types are updated
fallbackParameters: fallbackParameters ? _object_spread({}, fallbackParameters, escapeHTML ? TAG_PLACEHOLDER : {}) : undefined,
queryParameters: _object_spread({}, queryParameters, escapeHTML ? TAG_PLACEHOLDER : {}),
$$id: _this.$$id
});
}, state.removeParams(this.$$id));
}
};
};
};
function useFrequentlyBoughtTogether(props, additionalWidgetProperties) {
return useConnector(connectFrequentlyBoughtTogether, props, additionalWidgetProperties);
}
var withUsage$j = createDocumentationMessageGenerator({
name: 'geo-search',
connector: true
});
// in this connector, we assume insideBoundingBox is only a string,
// even though in the helper it's defined as number[][] alone.
// This can be done, since the connector assumes "control" of the parameter
function getBoundingBoxAsString(state) {
return state.insideBoundingBox || '';
}
function setBoundingBoxAsString(state, value) {
return state.setQueryParameter('insideBoundingBox', value);
}
var $$type$3 = 'ais.geoSearch';
/**
* The **GeoSearch** connector provides the logic to build a widget that will display the results on a map. It also provides a way to search for results based on their position. The connector provides functions to manage the search experience (search on map interaction or control the interaction for example).
*
* @requirements
*
* Note that the GeoSearch connector uses the [geosearch](https://www.algolia.com/doc/guides/searching/geo-search) capabilities of Algolia. Your hits **must** have a `_geoloc` attribute in order to be passed to the rendering function.
*
* Currently, the feature is not compatible with multiple values in the _geoloc attribute.
*/ var connectGeoSearch = function connectGeoSearch(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$j());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_enableRefineOnMapMove = _ref.enableRefineOnMapMove, enableRefineOnMapMove = _ref_enableRefineOnMapMove === void 0 ? true : _ref_enableRefineOnMapMove, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
var widgetState = {
isRefineOnMapMove: enableRefineOnMapMove,
// @MAJOR hasMapMoveSinceLastRefine -> hasMapMovedSinceLastRefine
hasMapMoveSinceLastRefine: false,
lastRefinePosition: '',
lastRefineBoundingBox: '',
internalToggleRefineOnMapMove: noop,
internalSetMapMoveSinceLastRefine: noop
};
var getPositionFromState = function getPositionFromState(state) {
return state.aroundLatLng ? aroundLatLngToPosition(state.aroundLatLng) : undefined;
};
var getCurrentRefinementFromState = function getCurrentRefinementFromState(state) {
return state.insideBoundingBox && insideBoundingBoxToBoundingBox(state.insideBoundingBox);
};
var refine = function refine(helper) {
return function(param) {
var ne = param.northEast, sw = param.southWest;
var boundingBox = [
ne.lat,
ne.lng,
sw.lat,
sw.lng
].join();
helper.setState(setBoundingBoxAsString(helper.state, boundingBox).resetPage()).search();
widgetState.hasMapMoveSinceLastRefine = false;
widgetState.lastRefineBoundingBox = boundingBox;
};
};
var clearMapRefinement = function clearMapRefinement(helper) {
return function() {
helper.setQueryParameter('insideBoundingBox', undefined).search();
};
};
var isRefinedWithMap = function isRefinedWithMap(state) {
return function() {
return Boolean(state.insideBoundingBox);
};
};
var toggleRefineOnMapMove = function toggleRefineOnMapMove() {
return widgetState.internalToggleRefineOnMapMove();
};
var createInternalToggleRefinementOnMapMove = function createInternalToggleRefinementOnMapMove(renderOptions, // eslint-disable-next-line no-shadow
render) {
return function() {
widgetState.isRefineOnMapMove = !widgetState.isRefineOnMapMove;
render(renderOptions);
};
};
var isRefineOnMapMove = function isRefineOnMapMove() {
return widgetState.isRefineOnMapMove;
};
var setMapMoveSinceLastRefine = function setMapMoveSinceLastRefine() {
return widgetState.internalSetMapMoveSinceLastRefine();
};
var createInternalSetMapMoveSinceLastRefine = function createInternalSetMapMoveSinceLastRefine(renderOptions, // eslint-disable-next-line no-shadow
render) {
return function() {
var shouldTriggerRender = widgetState.hasMapMoveSinceLastRefine !== true;
widgetState.hasMapMoveSinceLastRefine = true;
if (shouldTriggerRender) {
render(renderOptions);
}
};
};
var hasMapMoveSinceLastRefine = function hasMapMoveSinceLastRefine() {
return widgetState.hasMapMoveSinceLastRefine;
};
var sendEvent;
return {
$$type: $$type$3,
init: function init(initArgs) {
var instantSearchInstance = initArgs.instantSearchInstance;
var isFirstRendering = true;
widgetState.internalToggleRefineOnMapMove = createInternalToggleRefinementOnMapMove(initArgs, noop);
widgetState.internalSetMapMoveSinceLastRefine = createInternalSetMapMoveSinceLastRefine(initArgs, noop);
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initArgs)), {
instantSearchInstance: instantSearchInstance
}), isFirstRendering);
},
render: function render(renderArgs) {
var helper = renderArgs.helper, instantSearchInstance = renderArgs.instantSearchInstance;
var isFirstRendering = false;
// We don't use the state provided by the render function because we need
// to be sure that the state is the latest one for the following condition
var state = helper.state;
var positionChangedSinceLastRefine = Boolean(state.aroundLatLng) && Boolean(widgetState.lastRefinePosition) && state.aroundLatLng !== widgetState.lastRefinePosition;
var boundingBoxChangedSinceLastRefine = !state.insideBoundingBox && Boolean(widgetState.lastRefineBoundingBox) && state.insideBoundingBox !== widgetState.lastRefineBoundingBox;
if (positionChangedSinceLastRefine || boundingBoxChangedSinceLastRefine) {
widgetState.hasMapMoveSinceLastRefine = false;
}
widgetState.lastRefinePosition = state.aroundLatLng || '';
widgetState.lastRefineBoundingBox = getBoundingBoxAsString(state);
widgetState.internalToggleRefineOnMapMove = createInternalToggleRefinementOnMapMove(renderArgs, this.render.bind(this));
widgetState.internalSetMapMoveSinceLastRefine = createInternalSetMapMoveSinceLastRefine(renderArgs, this.render.bind(this));
var widgetRenderState = this.getWidgetRenderState(renderArgs);
sendEvent('view:internal', widgetRenderState.items);
renderFn(_object_spread_props(_object_spread({}, widgetRenderState), {
instantSearchInstance: instantSearchInstance
}), isFirstRendering);
},
getWidgetRenderState: function getWidgetRenderState(renderOptions) {
var helper = renderOptions.helper, results = renderOptions.results, instantSearchInstance = renderOptions.instantSearchInstance;
var state = helper.state;
var items = results ? transformItems(results.hits.filter(function(hit) {
return hit._geoloc;
}), {
results: results
}) : [];
if (!sendEvent) {
sendEvent = createSendEventForHits({
instantSearchInstance: instantSearchInstance,
helper: helper,
widgetType: $$type$3
});
}
return {
items: items,
position: getPositionFromState(state),
currentRefinement: getCurrentRefinementFromState(state),
refine: refine(helper),
sendEvent: sendEvent,
clearMapRefinement: clearMapRefinement(helper),
isRefinedWithMap: isRefinedWithMap(state),
toggleRefineOnMapMove: toggleRefineOnMapMove,
isRefineOnMapMove: isRefineOnMapMove,
setMapMoveSinceLastRefine: setMapMoveSinceLastRefine,
hasMapMoveSinceLastRefine: hasMapMoveSinceLastRefine,
widgetParams: widgetParams
};
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
geoSearch: this.getWidgetRenderState(renderOptions)
});
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
return state.setQueryParameter('insideBoundingBox', undefined);
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var boundingBox = getBoundingBoxAsString(searchParameters);
if (!boundingBox || uiState && uiState.geoSearch && uiState.geoSearch.boundingBox === boundingBox) {
return uiState;
}
return _object_spread_props(_object_spread({}, uiState), {
geoSearch: {
boundingBox: boundingBox
}
});
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
if (!uiState || !uiState.geoSearch) {
return searchParameters.setQueryParameter('insideBoundingBox', undefined);
}
return setBoundingBoxAsString(searchParameters, uiState.geoSearch.boundingBox);
}
};
};
};
function useGeoSearch(props, additionalWidgetProperties) {
return useConnector(connectGeoSearch, props, additionalWidgetProperties);
}
var withUsage$i = createDocumentationMessageGenerator({
name: 'hierarchical-menu',
connector: true
});
var DEFAULT_SORT$2 = [
'name:asc'
];
/**
* **HierarchicalMenu** connector provides the logic to build a custom widget
* that will give the user the ability to explore facets in a tree-like structure.
*
* This is commonly used for multi-level categorization of products on e-commerce
* websites. From a UX point of view, we suggest not displaying more than two
* levels deep.
*
* @type {Connector}
* @param {function(HierarchicalMenuRenderingOptions, boolean)} renderFn Rendering function for the custom **HierarchicalMenu** widget.
* @param {function} unmountFn Unmount function called when the widget is disposed.
* @return {function(CustomHierarchicalMenuWidgetParams)} Re-usable widget factory for a custom **HierarchicalMenu** widget.
*/ var connectHierarchicalMenu = function connectHierarchicalMenu(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$i());
return function(widgetParams) {
var _ref = widgetParams || {}, attributes = _ref.attributes, _ref_separator = _ref.separator, separator = _ref_separator === void 0 ? ' > ' : _ref_separator, _ref_rootPath = _ref.rootPath, rootPath = _ref_rootPath === void 0 ? null : _ref_rootPath, _ref_showParentLevel = _ref.showParentLevel, showParentLevel = _ref_showParentLevel === void 0 ? true : _ref_showParentLevel, _ref_limit = _ref.limit, limit = _ref_limit === void 0 ? 10 : _ref_limit, _ref_showMore = _ref.showMore, showMore = _ref_showMore === void 0 ? false : _ref_showMore, _ref_showMoreLimit = _ref.showMoreLimit, showMoreLimit = _ref_showMoreLimit === void 0 ? 20 : _ref_showMoreLimit, _ref_sortBy = _ref.sortBy, sortBy = _ref_sortBy === void 0 ? DEFAULT_SORT$2 : _ref_sortBy, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
if (!attributes || !Array.isArray(attributes) || attributes.length === 0) {
throw new Error(withUsage$i('The `attributes` option expects an array of strings.'));
}
if (showMore === true && showMoreLimit <= limit) {
throw new Error(withUsage$i('The `showMoreLimit` option must be greater than `limit`.'));
}
// we need to provide a hierarchicalFacet name for the search state
// so that we can always map $hierarchicalFacetName => real attributes
// we use the first attribute name
var _attributes = _sliced_to_array(attributes, 1), hierarchicalFacetName = _attributes[0];
var sendEvent;
// Provide the same function to the `renderFn` so that way the user
// has to only bind it once when `isFirstRendering` for instance
var toggleShowMore = function toggleShowMore() {};
function cachedToggleShowMore() {
toggleShowMore();
}
var _refine;
var isShowingMore = false;
function createToggleShowMore(renderOptions, widget) {
return function() {
isShowingMore = !isShowingMore;
widget.render(renderOptions);
};
}
function getLimit() {
return isShowingMore ? showMoreLimit : limit;
}
function _prepareFacetValues(facetValues) {
return facetValues.slice(0, getLimit()).map(function(_0) {
var label = _0.name, value = _0.escapedValue, data = _0.data;
_0.path;
var subValue = _object_without_properties(_0, [
"name",
"escapedValue",
"data",
"path"
]);
var item = _object_spread_props(_object_spread({}, subValue), {
value: value,
label: label,
data: null
});
if (Array.isArray(data)) {
item.data = _prepareFacetValues(data);
}
return item;
});
}
function _hasMoreItems(facetValues, maxValuesPerFacet) {
var currentLimit = getLimit();
return(// If the limit is the max number of facet retrieved it is impossible to know
// if the facets are exhaustive. The only moment we are sure it is exhaustive
// is when it is strictly under the number requested unless we know that another
// widget has requested more values (maxValuesPerFacet > getLimit()).
!(maxValuesPerFacet > currentLimit ? facetValues.length <= currentLimit : facetValues.length < currentLimit) || // Check if any of the children are not exhaustive.
facetValues.slice(0, limit).some(function(item) {
return Array.isArray(item.data) && item.data.length > 0 && _hasMoreItems(item.data, maxValuesPerFacet);
}));
}
return {
$$type: 'ais.hierarchicalMenu',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
toggleShowMore = createToggleShowMore(renderOptions, this);
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
return state.removeHierarchicalFacet(hierarchicalFacetName).setQueryParameter('maxValuesPerFacet', undefined);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
hierarchicalMenu: _object_spread_props(_object_spread({}, renderState.hierarchicalMenu), _define_property({}, hierarchicalFacetName, this.getWidgetRenderState(renderOptions)))
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var _this = this;
var results = param.results, state = param.state, createURL = param.createURL, instantSearchInstance = param.instantSearchInstance, helper = param.helper;
var items = [];
var canToggleShowMore = false;
// Bind createURL to this specific attribute
var _createURL = function _createURL(facetValue) {
return createURL(function(uiState) {
return _this.getWidgetUiState(uiState, {
searchParameters: state.resetPage().toggleFacetRefinement(hierarchicalFacetName, facetValue),
helper: helper
});
});
};
if (!sendEvent) {
sendEvent = createSendEventForFacet({
instantSearchInstance: instantSearchInstance,
helper: helper,
attribute: function attribute(facetValue) {
var index = facetValue.split(separator).length - 1;
return attributes[index];
},
widgetType: this.$$type
});
}
if (!_refine) {
_refine = function _refine(facetValue) {
sendEvent('click:internal', facetValue);
helper.toggleFacetRefinement(hierarchicalFacetName, facetValue).search();
};
}
if (results) {
var facetValues = results.getFacetValues(hierarchicalFacetName, {
sortBy: sortBy,
facetOrdering: sortBy === DEFAULT_SORT$2
});
var facetItems = facetValues && !Array.isArray(facetValues) && facetValues.data ? facetValues.data : [];
// Check if there are more items to show at any level
// This checks both the exhaustiveness of items retrieved from the API
// and whether there are hidden items at any visible child level
var hasMoreItems = _hasMoreItems(facetItems, state.maxValuesPerFacet || 0);
canToggleShowMore = showMore && (isShowingMore || hasMoreItems);
items = transformItems(_prepareFacetValues(facetItems), {
results: results
});
}
return {
items: items,
refine: _refine,
canRefine: items.length > 0,
createURL: _createURL,
sendEvent: sendEvent,
widgetParams: widgetParams,
isShowingMore: isShowingMore,
toggleShowMore: cachedToggleShowMore,
canToggleShowMore: canToggleShowMore
};
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var path = searchParameters.getHierarchicalFacetBreadcrumb(hierarchicalFacetName);
return removeEmptyRefinementsFromUiState$3(_object_spread_props(_object_spread({}, uiState), {
hierarchicalMenu: _object_spread_props(_object_spread({}, uiState.hierarchicalMenu), _define_property({}, hierarchicalFacetName, path))
}), hierarchicalFacetName);
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
var values = uiState.hierarchicalMenu && uiState.hierarchicalMenu[hierarchicalFacetName];
if (searchParameters.isConjunctiveFacet(hierarchicalFacetName) || searchParameters.isDisjunctiveFacet(hierarchicalFacetName)) {
return searchParameters;
}
if (searchParameters.isHierarchicalFacet(hierarchicalFacetName)) {
searchParameters.getHierarchicalFacetByName(hierarchicalFacetName);
}
var withFacetConfiguration = searchParameters.removeHierarchicalFacet(hierarchicalFacetName).addHierarchicalFacet({
name: hierarchicalFacetName,
attributes: attributes,
separator: separator,
rootPath: rootPath,
showParentLevel: showParentLevel
});
var currentMaxValuesPerFacet = withFacetConfiguration.maxValuesPerFacet || 0;
var nextMaxValuesPerFacet = Math.max(currentMaxValuesPerFacet, showMore ? showMoreLimit : limit);
var withMaxValuesPerFacet = withFacetConfiguration.setQueryParameter('maxValuesPerFacet', nextMaxValuesPerFacet);
if (!values) {
return withMaxValuesPerFacet.setQueryParameters({
hierarchicalFacetsRefinements: _object_spread_props(_object_spread({}, withMaxValuesPerFacet.hierarchicalFacetsRefinements), _define_property({}, hierarchicalFacetName, []))
});
}
return withMaxValuesPerFacet.addHierarchicalFacetRefinement(hierarchicalFacetName, values.join(separator));
}
};
};
};
function removeEmptyRefinementsFromUiState$3(indexUiState, attribute) {
if (!indexUiState.hierarchicalMenu) {
return indexUiState;
}
if (!indexUiState.hierarchicalMenu[attribute] || indexUiState.hierarchicalMenu[attribute].length === 0) {
delete indexUiState.hierarchicalMenu[attribute];
}
if (Object.keys(indexUiState.hierarchicalMenu).length === 0) {
delete indexUiState.hierarchicalMenu;
}
return indexUiState;
}
function useHierarchicalMenu(props, additionalWidgetProperties) {
return useConnector(connectHierarchicalMenu, props, additionalWidgetProperties);
}
var withUsage$h = createDocumentationMessageGenerator({
name: 'hits',
connector: true
});
var connectHits = function connectHits(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$h());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_escapeHTML = _ref.escapeHTML, escapeHTML = _ref_escapeHTML === void 0 ? true : _ref_escapeHTML, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
var sendEvent;
var bindEvent;
return {
$$type: 'ais.hits',
init: function init(initOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var renderState = this.getWidgetRenderState(renderOptions);
renderFn(_object_spread_props(_object_spread({}, renderState), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
renderState.sendEvent('view:internal', renderState.items);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
hits: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, helper = param.helper, instantSearchInstance = param.instantSearchInstance;
var _results_renderingContent_widgets_banners, _results_renderingContent_widgets, _results_renderingContent;
if (!sendEvent) {
sendEvent = createSendEventForHits({
instantSearchInstance: instantSearchInstance,
helper: helper,
widgetType: this.$$type
});
}
if (!bindEvent) {
bindEvent = createBindEventForHits({
helper: helper,
widgetType: this.$$type,
instantSearchInstance: instantSearchInstance
});
}
if (!results) {
return {
hits: [],
items: [],
results: undefined,
banner: undefined,
sendEvent: sendEvent,
bindEvent: bindEvent,
widgetParams: widgetParams
};
}
if (escapeHTML && results.hits.length > 0) {
results.hits = escapeHits(results.hits);
}
var hitsWithAbsolutePosition = addAbsolutePosition$1(results.hits, results.page, results.hitsPerPage);
var hitsWithAbsolutePositionAndQueryID = addQueryID$1(hitsWithAbsolutePosition, results.queryID);
var items = transformItems(hitsWithAbsolutePositionAndQueryID, {
results: results
});
var banner = (_results_renderingContent = results.renderingContent) === null || _results_renderingContent === void 0 ? void 0 : (_results_renderingContent_widgets = _results_renderingContent.widgets) === null || _results_renderingContent_widgets === void 0 ? void 0 : (_results_renderingContent_widgets_banners = _results_renderingContent_widgets.banners) === null || _results_renderingContent_widgets_banners === void 0 ? void 0 : _results_renderingContent_widgets_banners[0];
return {
hits: items,
items: items,
results: results,
banner: banner,
sendEvent: sendEvent,
bindEvent: bindEvent,
widgetParams: widgetParams
};
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
if (!escapeHTML) {
return state;
}
return state.setQueryParameters(Object.keys(TAG_PLACEHOLDER).reduce(function(acc, key) {
return _object_spread_props(_object_spread({}, acc), _define_property({}, key, undefined));
}, {}));
},
getWidgetSearchParameters: function getWidgetSearchParameters(state, _uiState) {
if (!escapeHTML) {
return state;
}
// @MAJOR: set this globally, not in the Hits widget to allow Hits to be conditionally used
return state.setQueryParameters(TAG_PLACEHOLDER);
}
};
};
};
function useHits(props, additionalWidgetProperties) {
return useConnector(connectHits, props, additionalWidgetProperties);
}
var withUsage$g = createDocumentationMessageGenerator({
name: 'hits-per-page',
connector: true
});
var connectHitsPerPage = function connectHitsPerPage(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$g());
return function(widgetParams) {
var _ref = widgetParams || {}, userItems = _ref.items, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
if (!Array.isArray(userItems)) {
throw new Error(withUsage$g('The `items` option expects an array of objects.'));
}
var items = userItems;
var defaultItems = items.filter(function(item) {
return item.default === true;
});
if (defaultItems.length === 0) {
throw new Error(withUsage$g("A default value must be specified in `items`."));
}
if (defaultItems.length > 1) {
throw new Error(withUsage$g('More than one default value is specified in `items`.'));
}
var defaultItem = defaultItems[0];
var normalizeItems = function normalizeItems(param) {
var hitsPerPage = param.hitsPerPage;
return items.map(function(item) {
return _object_spread_props(_object_spread({}, item), {
isRefined: Number(item.value) === Number(hitsPerPage)
});
});
};
var connectorState = {
getRefine: function getRefine(helper) {
return function(value) {
return !value && value !== 0 ? helper.setQueryParameter('hitsPerPage', undefined).search() : helper.setQueryParameter('hitsPerPage', value).search();
};
},
createURLFactory: function createURLFactory(param) {
var state = param.state, createURL = param.createURL, getWidgetUiState = param.getWidgetUiState, helper = param.helper;
return function(value) {
return createURL(function(uiState) {
return getWidgetUiState(uiState, {
searchParameters: state.resetPage().setQueryParameter('hitsPerPage', !value && value !== 0 ? undefined : value),
helper: helper
});
});
};
}
};
return {
$$type: 'ais.hitsPerPage',
init: function init(initOptions) {
var state = initOptions.state, instantSearchInstance = initOptions.instantSearchInstance;
var isCurrentInOptions = items.some(function(item) {
return Number(state.hitsPerPage) === Number(item.value);
});
if (!isCurrentInOptions) {
items = [
// The helper will convert the empty string to `undefined`.
{
value: '',
label: ''
}
].concat(_to_consumable_array(items));
}
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
return state.setQueryParameter('hitsPerPage', undefined);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
hitsPerPage: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var state = param.state, results = param.results, createURL = param.createURL, helper = param.helper;
var canRefine = results ? results.nbHits > 0 : false;
return {
items: transformItems(normalizeItems(state), {
results: results
}),
refine: connectorState.getRefine(helper),
createURL: connectorState.createURLFactory({
state: state,
createURL: createURL,
getWidgetUiState: this.getWidgetUiState,
helper: helper
}),
hasNoResults: !canRefine,
canRefine: canRefine,
widgetParams: widgetParams
};
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var hitsPerPage = searchParameters.hitsPerPage;
if (hitsPerPage === undefined || hitsPerPage === defaultItem.value) {
return uiState;
}
return _object_spread_props(_object_spread({}, uiState), {
hitsPerPage: hitsPerPage
});
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
return searchParameters.setQueryParameters({
hitsPerPage: uiState.hitsPerPage || defaultItem.value
});
}
};
};
};
function useHitsPerPage(props, additionalWidgetProperties) {
return useConnector(connectHitsPerPage, props, additionalWidgetProperties);
}
var withUsage$f = createDocumentationMessageGenerator({
name: 'infinite-hits',
connector: true
});
function getStateWithoutPage(state) {
var _ref = state || {};
_ref.page;
var rest = _object_without_properties(_ref, [
"page"
]);
return rest;
}
function normalizeState(state) {
var _ref = state || {};
_ref.clickAnalytics;
_ref.userToken;
var rest = _object_without_properties(_ref, [
"clickAnalytics",
"userToken"
]);
return rest;
}
function getInMemoryCache() {
var cachedHits = null;
var cachedState = null;
return {
read: function read(param) {
var state = param.state;
return isEqual(cachedState, getStateWithoutPage(state)) ? cachedHits : null;
},
write: function write(param) {
var state = param.state, hits = param.hits;
cachedState = getStateWithoutPage(state);
cachedHits = hits;
}
};
}
function extractHitsFromCachedHits(cachedHits) {
return Object.keys(cachedHits).map(Number).sort(function(a, b) {
return a - b;
}).reduce(function(acc, page) {
return acc.concat(cachedHits[page]);
}, []);
}
var connectInfiniteHits = function connectInfiniteHits(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$f());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_escapeHTML = _ref.escapeHTML, escapeHTML = _ref_escapeHTML === void 0 ? true : _ref_escapeHTML, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems, _ref_cache = _ref.cache, cache = _ref_cache === void 0 ? getInMemoryCache() : _ref_cache;
var showPrevious;
var showMore;
var sendEvent;
var bindEvent;
var getFirstReceivedPage = function getFirstReceivedPage(state, cachedHits) {
var _state_page = state.page, page = _state_page === void 0 ? 0 : _state_page;
var pages = Object.keys(cachedHits).map(Number);
if (pages.length === 0) {
return page;
} else {
var _Math;
return (_Math = Math).min.apply(_Math, [
page
].concat(_to_consumable_array(pages)));
}
};
var getLastReceivedPage = function getLastReceivedPage(state, cachedHits) {
var _state_page = state.page, page = _state_page === void 0 ? 0 : _state_page;
var pages = Object.keys(cachedHits).map(Number);
if (pages.length === 0) {
return page;
} else {
var _Math;
return (_Math = Math).max.apply(_Math, [
page
].concat(_to_consumable_array(pages)));
}
};
var getShowPrevious = function getShowPrevious(helper, getCachedHits) {
return function() {
var cachedHits = getCachedHits();
// Using the helper's `overrideStateWithoutTriggeringChangeEvent` method
// avoid updating the browser URL when the user displays the previous page.
helper.overrideStateWithoutTriggeringChangeEvent(_object_spread_props(_object_spread({}, helper.state), {
page: getFirstReceivedPage(helper.state, cachedHits) - 1
})).searchWithoutTriggeringOnStateChange();
};
};
var getShowMore = function getShowMore(helper, getCachedHits) {
return function() {
var cachedHits = getCachedHits();
helper.setPage(getLastReceivedPage(helper.state, cachedHits) + 1).search();
};
};
return {
$$type: 'ais.infiniteHits',
init: function init(initOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
var widgetRenderState = this.getWidgetRenderState(renderOptions);
renderFn(_object_spread_props(_object_spread({}, widgetRenderState), {
instantSearchInstance: instantSearchInstance
}), false);
sendEvent('view:internal', widgetRenderState.currentPageHits);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
infiniteHits: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, helper = param.helper, parent = param.parent, existingState = param.state, instantSearchInstance = param.instantSearchInstance;
var _results_renderingContent_widgets_banners, _results_renderingContent_widgets, _results_renderingContent;
var getCacheHits = function getCacheHits() {
var state = parent.getPreviousState() || existingState;
return cache.read({
state: normalizeState(state)
}) || {};
};
var isFirstPage;
var currentPageHits = [];
/**
* We bail out of optimistic UI here, as the cache is based on search
* parameters, and we don't want to invalidate the cache when the search
* is loading.
*/ var state = parent.getPreviousState() || existingState;
var cachedHits = getCacheHits();
var banner = results === null || results === void 0 ? void 0 : (_results_renderingContent = results.renderingContent) === null || _results_renderingContent === void 0 ? void 0 : (_results_renderingContent_widgets = _results_renderingContent.widgets) === null || _results_renderingContent_widgets === void 0 ? void 0 : (_results_renderingContent_widgets_banners = _results_renderingContent_widgets.banners) === null || _results_renderingContent_widgets_banners === void 0 ? void 0 : _results_renderingContent_widgets_banners[0];
if (!showPrevious) {
showPrevious = function showPrevious() {
return getShowPrevious(helper, getCacheHits)();
};
showMore = function showMore() {
return getShowMore(helper, getCacheHits)();
};
}
if (!sendEvent) {
sendEvent = createSendEventForHits({
instantSearchInstance: instantSearchInstance,
helper: helper,
widgetType: this.$$type
});
bindEvent = createBindEventForHits({
helper: helper,
widgetType: this.$$type,
instantSearchInstance: instantSearchInstance
});
}
if (!results) {
isFirstPage = state.page === undefined || getFirstReceivedPage(state, cachedHits) === 0;
} else {
var _state_disjunctiveFacets, _state_hierarchicalFacets;
var _state_page = state.page, page = _state_page === void 0 ? 0 : _state_page;
if (escapeHTML && results.hits.length > 0) {
results.hits = escapeHits(results.hits);
}
var hitsWithAbsolutePosition = addAbsolutePosition$1(results.hits, results.page, results.hitsPerPage);
var hitsWithAbsolutePositionAndQueryID = addQueryID$1(hitsWithAbsolutePosition, results.queryID);
var transformedHits = transformItems(hitsWithAbsolutePositionAndQueryID, {
results: results
});
/*
With dynamic widgets, facets are not included in the state before their relevant widgets are mounted. Until then, we need to bail out of writing this incomplete state representation in cache.
*/ var hasTwoPassWidgets = false;
walkIndex(instantSearchInstance.mainIndex, function(indexWidget) {
if (!hasTwoPassWidgets && indexWidget.getWidgets().some(isTwoPassWidget)) {
hasTwoPassWidgets = true;
}
});
var hasNoFacets = !((_state_disjunctiveFacets = state.disjunctiveFacets) === null || _state_disjunctiveFacets === void 0 ? void 0 : _state_disjunctiveFacets.length) && !(state.facets || []).filter(function(f) {
return f !== '*';
}).length && !((_state_hierarchicalFacets = state.hierarchicalFacets) === null || _state_hierarchicalFacets === void 0 ? void 0 : _state_hierarchicalFacets.length);
if (cachedHits[page] === undefined && !results.__isArtificial && instantSearchInstance.status === 'idle' && !(hasTwoPassWidgets && hasNoFacets)) {
cachedHits[page] = transformedHits;
cache.write({
state: normalizeState(state),
hits: cachedHits
});
}
currentPageHits = transformedHits;
isFirstPage = getFirstReceivedPage(state, cachedHits) === 0;
}
var items = extractHitsFromCachedHits(cachedHits);
var isLastPage = results ? results.nbPages <= getLastReceivedPage(state, cachedHits) + 1 : true;
return {
hits: items,
items: items,
currentPageHits: currentPageHits,
sendEvent: sendEvent,
bindEvent: bindEvent,
banner: banner,
results: results || undefined,
showPrevious: showPrevious,
showMore: showMore,
isFirstPage: isFirstPage,
isLastPage: isLastPage,
widgetParams: widgetParams
};
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
var stateWithoutPage = state.setQueryParameter('page', undefined);
if (!escapeHTML) {
return stateWithoutPage;
}
return stateWithoutPage.setQueryParameters(Object.keys(TAG_PLACEHOLDER).reduce(function(acc, key) {
return _object_spread_props(_object_spread({}, acc), _define_property({}, key, undefined));
}, {}));
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var page = searchParameters.page || 0;
if (!page) {
// return without adding `page` to uiState
// because we don't want `page=1` in the URL
return uiState;
}
return _object_spread_props(_object_spread({}, uiState), {
// The page in the UI state is incremented by one
// to expose the user value (not `0`).
page: page + 1
});
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
var widgetSearchParameters = searchParameters;
if (escapeHTML) {
// @MAJOR: set this globally, not in the InfiniteHits widget to allow InfiniteHits to be conditionally used
widgetSearchParameters = searchParameters.setQueryParameters(TAG_PLACEHOLDER);
}
// The page in the search parameters is decremented by one
// to get to the actual parameter value from the UI state.
var page = uiState.page ? uiState.page - 1 : 0;
return widgetSearchParameters.setQueryParameter('page', page);
}
};
};
};
function useInfiniteHits(props, additionalWidgetProperties) {
return useConnector(connectInfiniteHits, props, additionalWidgetProperties);
}
var withUsage$e = createDocumentationMessageGenerator({
name: 'menu',
connector: true
});
var DEFAULT_SORT$1 = [
'isRefined',
'name:asc'
];
/**
* **Menu** connector provides the logic to build a widget that will give the user the ability to choose a single value for a specific facet. The typical usage of menu is for navigation in categories.
*
* This connector provides a `toggleShowMore()` function to display more or less items and a `refine()`
* function to select an item. While selecting a new element, the `refine` will also unselect the
* one that is currently selected.
*
* **Requirement:** the attribute passed as `attribute` must be present in "attributes for faceting" on the Algolia dashboard or configured as attributesForFaceting via a set settings call to the Algolia API.
*/ var connectMenu = function connectMenu(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$e());
return function(widgetParams) {
var _ref = widgetParams || {}, attribute = _ref.attribute, _ref_limit = _ref.limit, limit = _ref_limit === void 0 ? 10 : _ref_limit, _ref_showMore = _ref.showMore, showMore = _ref_showMore === void 0 ? false : _ref_showMore, _ref_showMoreLimit = _ref.showMoreLimit, showMoreLimit = _ref_showMoreLimit === void 0 ? 20 : _ref_showMoreLimit, _ref_sortBy = _ref.sortBy, sortBy = _ref_sortBy === void 0 ? DEFAULT_SORT$1 : _ref_sortBy, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
if (!attribute) {
throw new Error(withUsage$e('The `attribute` option is required.'));
}
if (showMore === true && showMoreLimit <= limit) {
throw new Error(withUsage$e('The `showMoreLimit` option must be greater than `limit`.'));
}
var sendEvent;
var _createURL;
var _refine;
// Provide the same function to the `renderFn` so that way the user
// has to only bind it once when `isFirstRendering` for instance
var isShowingMore = false;
var toggleShowMore = function toggleShowMore() {};
function createToggleShowMore(renderOptions, widget) {
return function() {
isShowingMore = !isShowingMore;
widget.render(renderOptions);
};
}
function cachedToggleShowMore() {
toggleShowMore();
}
function getLimit() {
return isShowingMore ? showMoreLimit : limit;
}
return {
$$type: 'ais.menu',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
return state.removeHierarchicalFacet(attribute).setQueryParameter('maxValuesPerFacet', undefined);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
menu: _object_spread_props(_object_spread({}, renderState.menu), _define_property({}, attribute, this.getWidgetRenderState(renderOptions)))
});
},
getWidgetRenderState: function getWidgetRenderState(renderOptions) {
var _this = this;
var results = renderOptions.results, createURL = renderOptions.createURL, instantSearchInstance = renderOptions.instantSearchInstance, helper = renderOptions.helper;
var items = [];
var canToggleShowMore = false;
if (!sendEvent) {
sendEvent = createSendEventForFacet({
instantSearchInstance: instantSearchInstance,
helper: helper,
attribute: attribute,
widgetType: this.$$type
});
}
if (!_createURL) {
_createURL = function _createURL(facetValue) {
return createURL(function(uiState) {
return _this.getWidgetUiState(uiState, {
searchParameters: helper.state.resetPage().toggleFacetRefinement(attribute, facetValue),
helper: helper
});
});
};
}
if (!_refine) {
_refine = function _refine(facetValue) {
var _helper_getHierarchicalFacetBreadcrumb = _sliced_to_array(helper.getHierarchicalFacetBreadcrumb(attribute), 1), refinedItem = _helper_getHierarchicalFacetBreadcrumb[0];
sendEvent('click:internal', facetValue ? facetValue : refinedItem);
helper.toggleFacetRefinement(attribute, facetValue ? facetValue : refinedItem).search();
};
}
if (renderOptions.results) {
toggleShowMore = createToggleShowMore(renderOptions, this);
}
if (results) {
var facetValues = results.getFacetValues(attribute, {
sortBy: sortBy,
facetOrdering: sortBy === DEFAULT_SORT$1
});
var facetItems = facetValues && !Array.isArray(facetValues) && facetValues.data ? facetValues.data : [];
canToggleShowMore = showMore && (isShowingMore || facetItems.length > getLimit());
items = transformItems(facetItems.slice(0, getLimit()).map(function(_0) {
var label = _0.name, value = _0.escapedValue;
_0.path;
var item = _object_without_properties(_0, [
"name",
"escapedValue",
"path"
]);
return _object_spread_props(_object_spread({}, item), {
label: label,
value: value
});
}), {
results: results
});
}
return {
items: items,
createURL: _createURL,
refine: _refine,
sendEvent: sendEvent,
canRefine: items.length > 0,
widgetParams: widgetParams,
isShowingMore: isShowingMore,
toggleShowMore: cachedToggleShowMore,
canToggleShowMore: canToggleShowMore
};
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var _searchParameters_getHierarchicalFacetBreadcrumb = _sliced_to_array(searchParameters.getHierarchicalFacetBreadcrumb(attribute), 1), value = _searchParameters_getHierarchicalFacetBreadcrumb[0];
return removeEmptyRefinementsFromUiState$2(_object_spread_props(_object_spread({}, uiState), {
menu: _object_spread_props(_object_spread({}, uiState.menu), _define_property({}, attribute, value))
}), attribute);
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
var value = uiState.menu && uiState.menu[attribute];
if (searchParameters.isConjunctiveFacet(attribute) || searchParameters.isDisjunctiveFacet(attribute)) {
return searchParameters;
}
var withFacetConfiguration = searchParameters.removeHierarchicalFacet(attribute).addHierarchicalFacet({
name: attribute,
attributes: [
attribute
]
});
var currentMaxValuesPerFacet = withFacetConfiguration.maxValuesPerFacet || 0;
var nextMaxValuesPerFacet = Math.max(currentMaxValuesPerFacet, showMore ? showMoreLimit : limit);
var withMaxValuesPerFacet = withFacetConfiguration.setQueryParameter('maxValuesPerFacet', nextMaxValuesPerFacet);
if (!value) {
return withMaxValuesPerFacet.setQueryParameters({
hierarchicalFacetsRefinements: _object_spread_props(_object_spread({}, withMaxValuesPerFacet.hierarchicalFacetsRefinements), _define_property({}, attribute, []))
});
}
return withMaxValuesPerFacet.addHierarchicalFacetRefinement(attribute, value);
}
};
};
};
function removeEmptyRefinementsFromUiState$2(indexUiState, attribute) {
if (!indexUiState.menu) {
return indexUiState;
}
if (indexUiState.menu[attribute] === undefined) {
delete indexUiState.menu[attribute];
}
if (Object.keys(indexUiState.menu).length === 0) {
delete indexUiState.menu;
}
return indexUiState;
}
function useMenu(props, additionalWidgetProperties) {
return useConnector(connectMenu, props, additionalWidgetProperties);
}
var withUsage$d = createDocumentationMessageGenerator({
name: 'numeric-menu',
connector: true
});
var $$type$2 = 'ais.numericMenu';
var createSendEvent$1 = function createSendEvent(param) {
var instantSearchInstance = param.instantSearchInstance;
return function() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
if (args.length === 1) {
instantSearchInstance.sendEventToInsights(args[0]);
return;
}
};
};
var connectNumericMenu = function connectNumericMenu(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$d());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_attribute = _ref.attribute, attribute = _ref_attribute === void 0 ? '' : _ref_attribute, _ref_items = _ref.items, items = _ref_items === void 0 ? [] : _ref_items, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(item) {
return item;
} : _ref_transformItems;
if (attribute === '') {
throw new Error(withUsage$d('The `attribute` option is required.'));
}
if (!items || items.length === 0) {
throw new Error(withUsage$d('The `items` option expects an array of objects.'));
}
var prepareItems = function prepareItems(state) {
return items.map(function(param) {
var start = param.start, end = param.end, label = param.label;
return {
label: label,
value: encodeURI(JSON.stringify({
start: start,
end: end
})),
isRefined: isRefined(state, attribute, {
start: start,
end: end,
label: label
})
};
});
};
var connectorState = {};
return {
$$type: $$type$2,
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
return state.removeNumericRefinement(attribute);
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var values = searchParameters.getNumericRefinements(attribute);
var equal = values['='] && values['='][0];
if (equal || equal === 0) {
return _object_spread_props(_object_spread({}, uiState), {
numericMenu: _object_spread_props(_object_spread({}, uiState.numericMenu), _define_property({}, attribute, "".concat(values['='])))
});
}
var min = values['>='] && values['>='][0] || '';
var max = values['<='] && values['<='][0] || '';
return removeEmptyRefinementsFromUiState$1(_object_spread_props(_object_spread({}, uiState), {
numericMenu: _object_spread_props(_object_spread({}, uiState.numericMenu), _define_property({}, attribute, "".concat(min, ":").concat(max)))
}), attribute);
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
var value = uiState.numericMenu && uiState.numericMenu[attribute];
var withoutRefinements = searchParameters.setQueryParameters({
numericRefinements: _object_spread_props(_object_spread({}, searchParameters.numericRefinements), _define_property({}, attribute, {}))
});
if (!value) {
return withoutRefinements;
}
var isExact = value.indexOf(':') === -1;
if (isExact) {
return withoutRefinements.addNumericRefinement(attribute, '=', Number(value));
}
var _value_split_map = _sliced_to_array(value.split(':').map(parseFloat), 2), min = _value_split_map[0], max = _value_split_map[1];
var withMinRefinement = isFiniteNumber(min) ? withoutRefinements.addNumericRefinement(attribute, '>=', min) : withoutRefinements;
var withMaxRefinement = isFiniteNumber(max) ? withMinRefinement.addNumericRefinement(attribute, '<=', max) : withMinRefinement;
return withMaxRefinement;
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
numericMenu: _object_spread_props(_object_spread({}, renderState.numericMenu), _define_property({}, attribute, this.getWidgetRenderState(renderOptions)))
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var _this = this;
var results = param.results, state = param.state, instantSearchInstance = param.instantSearchInstance, helper = param.helper, createURL = param.createURL;
if (!connectorState.refine) {
connectorState.refine = function(facetValue) {
var refinedState = getRefinedState(helper.state, attribute, facetValue);
connectorState.sendEvent('click:internal', facetValue);
helper.setState(refinedState).search();
};
}
if (!connectorState.createURL) {
connectorState.createURL = function(newState) {
return function(facetValue) {
return createURL(function(uiState) {
return _this.getWidgetUiState(uiState, {
searchParameters: getRefinedState(newState, attribute, facetValue),
helper: helper
});
});
};
};
}
if (!connectorState.sendEvent) {
connectorState.sendEvent = createSendEvent$1({
instantSearchInstance: instantSearchInstance
});
}
var hasNoResults = results ? results.nbHits === 0 : true;
var preparedItems = prepareItems(state);
var allIsSelected = true;
var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
try {
// @TODO avoid for..of for polyfill reasons
// eslint-disable-next-line instantsearch/no-for-of
for(var _iterator = preparedItems[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
var item = _step.value;
if (item.isRefined && decodeURI(item.value) !== '{}') {
allIsSelected = false;
break;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally{
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally{
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return {
createURL: connectorState.createURL(state),
items: transformItems(preparedItems, {
results: results
}),
hasNoResults: hasNoResults,
canRefine: !(hasNoResults && allIsSelected),
refine: connectorState.refine,
sendEvent: connectorState.sendEvent,
widgetParams: widgetParams
};
}
};
};
};
function isRefined(state, attribute, option) {
// @TODO: same as another spot, why is this mixing arrays & elements?
var currentRefinements = state.getNumericRefinements(attribute);
if (option.start !== undefined && option.end !== undefined) {
if (option.start === option.end) {
return hasNumericRefinement(currentRefinements, '=', option.start);
} else {
return hasNumericRefinement(currentRefinements, '>=', option.start) && hasNumericRefinement(currentRefinements, '<=', option.end);
}
}
if (option.start !== undefined) {
return hasNumericRefinement(currentRefinements, '>=', option.start);
}
if (option.end !== undefined) {
return hasNumericRefinement(currentRefinements, '<=', option.end);
}
if (option.start === undefined && option.end === undefined) {
return Object.keys(currentRefinements).every(function(operator) {
return (currentRefinements[operator] || []).length === 0;
});
}
return false;
}
function getRefinedState(state, attribute, facetValue) {
var resolvedState = state;
var refinedOption = JSON.parse(decodeURI(facetValue));
// @TODO: why is array / element mixed here & hasRefinements; seems wrong?
var currentRefinements = resolvedState.getNumericRefinements(attribute);
if (refinedOption.start === undefined && refinedOption.end === undefined) {
return resolvedState.removeNumericRefinement(attribute);
}
if (!isRefined(resolvedState, attribute, refinedOption)) {
resolvedState = resolvedState.removeNumericRefinement(attribute);
}
if (refinedOption.start !== undefined && refinedOption.end !== undefined) {
if (refinedOption.start > refinedOption.end) {
throw new Error('option.start should be > to option.end');
}
if (refinedOption.start === refinedOption.end) {
if (hasNumericRefinement(currentRefinements, '=', refinedOption.start)) {
resolvedState = resolvedState.removeNumericRefinement(attribute, '=', refinedOption.start);
} else {
resolvedState = resolvedState.addNumericRefinement(attribute, '=', refinedOption.start);
}
return resolvedState;
}
}
if (refinedOption.start !== undefined) {
if (hasNumericRefinement(currentRefinements, '>=', refinedOption.start)) {
resolvedState = resolvedState.removeNumericRefinement(attribute, '>=', refinedOption.start);
}
resolvedState = resolvedState.addNumericRefinement(attribute, '>=', refinedOption.start);
}
if (refinedOption.end !== undefined) {
if (hasNumericRefinement(currentRefinements, '<=', refinedOption.end)) {
resolvedState = resolvedState.removeNumericRefinement(attribute, '<=', refinedOption.end);
}
resolvedState = resolvedState.addNumericRefinement(attribute, '<=', refinedOption.end);
}
if (typeof resolvedState.page === 'number') {
resolvedState.page = 0;
}
return resolvedState;
}
function hasNumericRefinement(currentRefinements, operator, value) {
var refinements = currentRefinements[operator];
return refinements !== undefined && refinements.includes(value);
}
function removeEmptyRefinementsFromUiState$1(indexUiState, attribute) {
if (!indexUiState.numericMenu) {
return indexUiState;
}
if (indexUiState.numericMenu[attribute] === ':') {
delete indexUiState.numericMenu[attribute];
}
if (Object.keys(indexUiState.numericMenu).length === 0) {
delete indexUiState.numericMenu;
}
return indexUiState;
}
function useNumericMenu(props, additionalWidgetProperties) {
return useConnector(connectNumericMenu, props, additionalWidgetProperties);
}
var Paginator = /*#__PURE__*/ function() {
function Paginator(params) {
_class_call_check(this, Paginator);
_define_property(this, "currentPage", void 0);
_define_property(this, "total", void 0);
_define_property(this, "padding", void 0);
this.currentPage = params.currentPage;
this.total = params.total;
this.padding = params.padding;
}
_create_class(Paginator, [
{
key: "pages",
value: function pages() {
var _this = this, total = _this.total, currentPage = _this.currentPage, padding = _this.padding;
if (total === 0) return [
0
];
var totalDisplayedPages = this.nbPagesDisplayed(padding, total);
if (totalDisplayedPages === total) {
return range({
end: total
});
}
var paddingLeft = this.calculatePaddingLeft(currentPage, padding, total, totalDisplayedPages);
var paddingRight = totalDisplayedPages - paddingLeft;
var first = currentPage - paddingLeft;
var last = currentPage + paddingRight;
return range({
start: first,
end: last
});
}
},
{
key: "nbPagesDisplayed",
value: function nbPagesDisplayed(padding, total) {
return Math.min(2 * padding + 1, total);
}
},
{
key: "calculatePaddingLeft",
value: function calculatePaddingLeft(current, padding, total, totalDisplayedPages) {
if (current <= padding) {
return current;
}
if (current >= total - padding) {
return totalDisplayedPages - (total - current);
}
return padding;
}
},
{
key: "isLastPage",
value: function isLastPage() {
return this.currentPage >= this.total - 1;
}
},
{
key: "isFirstPage",
value: function isFirstPage() {
return this.currentPage <= 0;
}
}
]);
return Paginator;
}();
var withUsage$c = createDocumentationMessageGenerator({
name: 'pagination',
connector: true
});
/**
* **Pagination** connector provides the logic to build a widget that will let the user
* choose the current page of the results.
*
* When using the pagination with Algolia, you should be aware that the engine won't provide you pages
* beyond the 1000th hits by default. You can find more information on the [Algolia documentation](https://www.algolia.com/doc/guides/searching/pagination/#pagination-limitations).
*/ var connectPagination = function connectPagination(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$c());
return function(widgetParams) {
var _ref = widgetParams || {}, totalPages = _ref.totalPages, _ref_padding = _ref.padding, padding = _ref_padding === void 0 ? 3 : _ref_padding;
var pager = new Paginator({
currentPage: 0,
total: 0,
padding: padding
});
var connectorState = {};
function getMaxPage(param) {
var nbPages = param.nbPages;
return totalPages !== undefined ? Math.min(totalPages, nbPages) : nbPages;
}
return {
$$type: 'ais.pagination',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
return state.setQueryParameter('page', undefined);
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var page = searchParameters.page || 0;
if (!page) {
return uiState;
}
return _object_spread_props(_object_spread({}, uiState), {
page: page + 1
});
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
var page = uiState.page ? uiState.page - 1 : 0;
return searchParameters.setQueryParameter('page', page);
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, helper = param.helper, state = param.state, createURL = param.createURL;
if (!connectorState.refine) {
connectorState.refine = function(page) {
helper.setPage(page);
helper.search();
};
}
if (!connectorState.createURL) {
connectorState.createURL = function(page) {
return createURL(function(uiState) {
return _object_spread_props(_object_spread({}, uiState), {
page: page + 1
});
});
};
}
var page = state.page || 0;
var nbPages = getMaxPage(results || {
nbPages: 0
});
pager.currentPage = page;
pager.total = nbPages;
return {
createURL: connectorState.createURL,
refine: connectorState.refine,
canRefine: nbPages > 1,
currentRefinement: page,
nbHits: (results === null || results === void 0 ? void 0 : results.nbHits) || 0,
nbPages: nbPages,
pages: results ? pager.pages() : [],
isFirstPage: pager.isFirstPage(),
isLastPage: pager.isLastPage(),
widgetParams: widgetParams
};
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
pagination: this.getWidgetRenderState(renderOptions)
});
}
};
};
};
function usePagination(props, additionalWidgetProperties) {
return useConnector(connectPagination, props, additionalWidgetProperties);
}
function usePoweredBy() {
var hostname = safelyRunOnBrowser(function(param) {
var window = param.window;
var _window_location;
return ((_window_location = window.location) === null || _window_location === void 0 ? void 0 : _window_location.hostname) || '';
}, {
fallback: function fallback() {
return '';
}
});
return {
url: "https://www.algolia.com/?utm_source=react-instantsearch&utm_medium=website&utm_content=".concat(hostname, "&utm_campaign=poweredby")
};
}
var withUsage$b = createDocumentationMessageGenerator({
name: 'query-rules',
connector: true
});
function hasStateRefinements(state) {
return [
state.disjunctiveFacetsRefinements,
state.facetsRefinements,
state.hierarchicalFacetsRefinements,
state.numericRefinements
].some(function(refinement) {
return Boolean(refinement && Object.keys(refinement).length > 0);
});
}
// A context rule must consist only of alphanumeric characters, hyphens, and underscores.
// See https://www.algolia.com/doc/guides/managing-results/refine-results/merchandising-and-promoting/in-depth/implementing-query-rules/#context
function escapeRuleContext(ruleName) {
return ruleName.replace(/[^a-z0-9-_]+/gi, '_');
}
function getRuleContextsFromTrackedFilters(param) {
var helper = param.helper, sharedHelperState = param.sharedHelperState, trackedFilters = param.trackedFilters;
var ruleContexts = Object.keys(trackedFilters).reduce(function(facets, facetName) {
var facetRefinements = getRefinements(helper.lastResults || {}, sharedHelperState, true).filter(function(refinement) {
return refinement.attribute === facetName;
}).map(function(refinement) {
return refinement.numericValue || refinement.name;
});
var getTrackedFacetValues = trackedFilters[facetName];
var trackedFacetValues = getTrackedFacetValues(facetRefinements);
return _to_consumable_array(facets).concat(_to_consumable_array(facetRefinements.filter(function(facetRefinement) {
return trackedFacetValues.includes(facetRefinement);
}).map(function(facetValue) {
return escapeRuleContext("ais-".concat(facetName, "-").concat(facetValue));
})));
}, []);
return ruleContexts;
}
function applyRuleContexts(event) {
var _this = this, helper = _this.helper, initialRuleContexts = _this.initialRuleContexts, trackedFilters = _this.trackedFilters, transformRuleContexts = _this.transformRuleContexts;
var sharedHelperState = event.state;
var previousRuleContexts = sharedHelperState.ruleContexts || [];
var newRuleContexts = getRuleContextsFromTrackedFilters({
helper: helper,
sharedHelperState: sharedHelperState,
trackedFilters: trackedFilters
});
var nextRuleContexts = _to_consumable_array(initialRuleContexts).concat(_to_consumable_array(newRuleContexts));
var ruleContexts = transformRuleContexts(nextRuleContexts).slice(0, 10);
if (!isEqual(previousRuleContexts, ruleContexts)) {
helper.overrideStateWithoutTriggeringChangeEvent(_object_spread_props(_object_spread({}, sharedHelperState), {
ruleContexts: ruleContexts
}));
}
}
var connectQueryRules = function connectQueryRules(render) {
var unmount = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(render, withUsage$b());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_trackedFilters = _ref.trackedFilters, trackedFilters = _ref_trackedFilters === void 0 ? {} : _ref_trackedFilters, _ref_transformRuleContexts = _ref.transformRuleContexts, transformRuleContexts = _ref_transformRuleContexts === void 0 ? function(rules) {
return rules;
} : _ref_transformRuleContexts, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
Object.keys(trackedFilters).forEach(function(facetName) {
if (typeof trackedFilters[facetName] !== 'function') {
throw new Error(withUsage$b("'The \"".concat(facetName, '" filter value in the `trackedFilters` option expects a function.')));
}
});
var hasTrackedFilters = Object.keys(trackedFilters).length > 0;
// We store the initial rule contexts applied before creating the widget
// so that we do not override them with the rules created from `trackedFilters`.
var initialRuleContexts = [];
var onHelperChange;
return {
$$type: 'ais.queryRules',
init: function init(initOptions) {
var helper = initOptions.helper, state = initOptions.state, instantSearchInstance = initOptions.instantSearchInstance;
initialRuleContexts = state.ruleContexts || [];
onHelperChange = applyRuleContexts.bind({
helper: helper,
initialRuleContexts: initialRuleContexts,
trackedFilters: trackedFilters,
transformRuleContexts: transformRuleContexts
});
if (hasTrackedFilters) {
// We need to apply the `ruleContexts` based on the `trackedFilters`
// before the helper changes state in some cases:
// - Some filters are applied on the first load (e.g. using `configure`)
// - The `transformRuleContexts` option sets initial `ruleContexts`.
if (hasStateRefinements(state) || Boolean(widgetParams.transformRuleContexts)) {
onHelperChange({
state: state
});
}
// We track every change in the helper to override its state and add
// any `ruleContexts` needed based on the `trackedFilters`.
helper.on('change', onHelperChange);
}
render(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render1(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
render(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results;
var _ref = results || {}, _ref_userData = _ref.userData, userData = _ref_userData === void 0 ? [] : _ref_userData;
var items = transformItems(userData, {
results: results
});
return {
items: items,
widgetParams: widgetParams
};
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
queryRules: this.getWidgetRenderState(renderOptions)
});
},
dispose: function dispose(param) {
var helper = param.helper, state = param.state;
unmount();
if (hasTrackedFilters) {
helper.removeListener('change', onHelperChange);
return state.setQueryParameter('ruleContexts', initialRuleContexts);
}
return state;
}
};
};
};
function useQueryRules(props, additionalWidgetProperties) {
return useConnector(connectQueryRules, props, additionalWidgetProperties);
}
var withUsage$a = createDocumentationMessageGenerator({
name: 'range-input',
connector: true
}, {
name: 'range-slider',
connector: true
});
var $$type$1 = 'ais.range';
function toPrecision(param) {
var min = param.min, max = param.max, precision = param.precision;
var pow = Math.pow(10, precision);
return {
min: min ? Math.floor(min * pow) / pow : min,
max: max ? Math.ceil(max * pow) / pow : max
};
}
/**
* **Range** connector provides the logic to create custom widget that will let
* the user refine results using a numeric range.
*
* This connectors provides a `refine()` function that accepts bounds. It will also provide
* information about the min and max bounds for the current result set.
*/ var connectRange = function connectRange(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$a());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_attribute = _ref.attribute, attribute = _ref_attribute === void 0 ? '' : _ref_attribute, minBound = _ref.min, maxBound = _ref.max, _ref_precision = _ref.precision, precision = _ref_precision === void 0 ? 0 : _ref_precision;
if (!attribute) {
throw new Error(withUsage$a('The `attribute` option is required.'));
}
if (isFiniteNumber(minBound) && isFiniteNumber(maxBound) && minBound > maxBound) {
throw new Error(withUsage$a("The `max` option can't be lower than `min`."));
}
var formatToNumber = function formatToNumber(v) {
return Number(Number(v).toFixed(precision));
};
var rangeFormatter = {
from: function from(v) {
return v.toLocaleString();
},
to: function to(v) {
return formatToNumber(v).toLocaleString();
}
};
// eslint-disable-next-line complexity
var getRefinedState = function getRefinedState(helper, currentRange, nextMin, nextMax) {
var resolvedState = helper.state;
var currentRangeMin = currentRange.min, currentRangeMax = currentRange.max;
var _ref = _sliced_to_array(resolvedState.getNumericRefinement(attribute, '>=') || [], 1), min = _ref[0];
var _ref1 = _sliced_to_array(resolvedState.getNumericRefinement(attribute, '<=') || [], 1), max = _ref1[0];
var isResetMin = nextMin === undefined || nextMin === '';
var isResetMax = nextMax === undefined || nextMax === '';
var _toPrecision = toPrecision({
min: !isResetMin ? parseFloat(nextMin) : undefined,
max: !isResetMax ? parseFloat(nextMax) : undefined,
precision: precision
}), nextMinAsNumber = _toPrecision.min, nextMaxAsNumber = _toPrecision.max;
var newNextMin;
if (!isFiniteNumber(minBound) && currentRangeMin === nextMinAsNumber) {
newNextMin = undefined;
} else if (isFiniteNumber(minBound) && isResetMin) {
newNextMin = minBound;
} else {
newNextMin = nextMinAsNumber;
}
var newNextMax;
if (!isFiniteNumber(maxBound) && currentRangeMax === nextMaxAsNumber) {
newNextMax = undefined;
} else if (isFiniteNumber(maxBound) && isResetMax) {
newNextMax = maxBound;
} else {
newNextMax = nextMaxAsNumber;
}
var isResetNewNextMin = newNextMin === undefined;
var isGreaterThanCurrentRange = isFiniteNumber(currentRangeMin) && currentRangeMin <= newNextMin;
var isMinValid = isResetNewNextMin || isFiniteNumber(newNextMin) && (!isFiniteNumber(currentRangeMin) || isGreaterThanCurrentRange);
var isResetNewNextMax = newNextMax === undefined;
var isLowerThanRange = isFiniteNumber(newNextMax) && currentRangeMax >= newNextMax;
var isMaxValid = isResetNewNextMax || isFiniteNumber(newNextMax) && (!isFiniteNumber(currentRangeMax) || isLowerThanRange);
var hasMinChange = min !== newNextMin;
var hasMaxChange = max !== newNextMax;
if ((hasMinChange || hasMaxChange) && isMinValid && isMaxValid) {
resolvedState = resolvedState.removeNumericRefinement(attribute);
if (isFiniteNumber(newNextMin)) {
resolvedState = resolvedState.addNumericRefinement(attribute, '>=', newNextMin);
}
if (isFiniteNumber(newNextMax)) {
resolvedState = resolvedState.addNumericRefinement(attribute, '<=', newNextMax);
}
return resolvedState.resetPage();
}
return null;
};
var createSendEvent = function createSendEvent(instantSearchInstance) {
return function() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
if (args.length === 1) {
instantSearchInstance.sendEventToInsights(args[0]);
return;
}
};
};
function _getCurrentRange(stats) {
var min;
if (isFiniteNumber(minBound)) {
min = minBound;
} else if (isFiniteNumber(stats.min)) {
min = stats.min;
} else {
min = 0;
}
var max;
if (isFiniteNumber(maxBound)) {
max = maxBound;
} else if (isFiniteNumber(stats.max)) {
max = stats.max;
} else {
max = 0;
}
return toPrecision({
min: min,
max: max,
precision: precision
});
}
function _getCurrentRefinement(helper) {
var _ref = _sliced_to_array(helper.getNumericRefinement(attribute, '>=') || [], 1), minValue = _ref[0];
var _ref1 = _sliced_to_array(helper.getNumericRefinement(attribute, '<=') || [], 1), maxValue = _ref1[0];
var min = isFiniteNumber(minValue) ? minValue : -Infinity;
var max = isFiniteNumber(maxValue) ? maxValue : Infinity;
return [
min,
max
];
}
function _refine(helper, currentRange) {
return function() {
var _ref = _sliced_to_array(arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [
undefined,
undefined
], 2), nextMin = _ref[0], nextMax = _ref[1];
var refinedState = getRefinedState(helper, currentRange, nextMin, nextMax);
if (refinedState) {
helper.setState(refinedState).search();
}
};
}
return {
$$type: $$type$1,
init: function init(initOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
range: _object_spread_props(_object_spread({}, renderState.range), _define_property({}, attribute, this.getWidgetRenderState(renderOptions)))
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, helper = param.helper, instantSearchInstance = param.instantSearchInstance;
var facetsFromResults = results && results.disjunctiveFacets || [];
var facet = find$1(facetsFromResults, function(facetResult) {
return facetResult.name === attribute;
});
var stats = facet && facet.stats || {
min: undefined,
max: undefined
};
var currentRange = _getCurrentRange(stats);
var start = _getCurrentRefinement(helper);
var refine;
if (!results) {
// On first render pass an empty range
// to be able to bypass the validation
// related to it
refine = _refine(helper, {
min: undefined,
max: undefined
});
} else {
refine = _refine(helper, currentRange);
}
return {
refine: refine,
canRefine: currentRange.min !== currentRange.max,
format: rangeFormatter,
range: currentRange,
sendEvent: createSendEvent(instantSearchInstance),
widgetParams: _object_spread_props(_object_spread({}, widgetParams), {
precision: precision
}),
start: start
};
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
return state.removeDisjunctiveFacet(attribute).removeNumericRefinement(attribute);
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var _searchParameters_getNumericRefinements = searchParameters.getNumericRefinements(attribute), tmp = _searchParameters_getNumericRefinements['>='], min = tmp === void 0 ? [] : tmp, tmp1 = _searchParameters_getNumericRefinements['<='], max = tmp1 === void 0 ? [] : tmp1;
if (min.length === 0 && max.length === 0) {
return uiState;
}
return _object_spread_props(_object_spread({}, uiState), {
range: _object_spread_props(_object_spread({}, uiState.range), _define_property({}, attribute, "".concat(min, ":").concat(max)))
});
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
var widgetSearchParameters = searchParameters.addDisjunctiveFacet(attribute).setQueryParameters({
numericRefinements: _object_spread_props(_object_spread({}, searchParameters.numericRefinements), _define_property({}, attribute, {}))
});
if (isFiniteNumber(minBound)) {
widgetSearchParameters = widgetSearchParameters.addNumericRefinement(attribute, '>=', minBound);
}
if (isFiniteNumber(maxBound)) {
widgetSearchParameters = widgetSearchParameters.addNumericRefinement(attribute, '<=', maxBound);
}
var value = uiState.range && uiState.range[attribute];
if (!value || value.indexOf(':') === -1) {
return widgetSearchParameters;
}
var _value_split_map = _sliced_to_array(value.split(':').map(parseFloat), 2), lowerBound = _value_split_map[0], upperBound = _value_split_map[1];
if (isFiniteNumber(lowerBound) && (!isFiniteNumber(minBound) || minBound < lowerBound)) {
widgetSearchParameters = widgetSearchParameters.removeNumericRefinement(attribute, '>=');
widgetSearchParameters = widgetSearchParameters.addNumericRefinement(attribute, '>=', lowerBound);
}
if (isFiniteNumber(upperBound) && (!isFiniteNumber(maxBound) || upperBound < maxBound)) {
widgetSearchParameters = widgetSearchParameters.removeNumericRefinement(attribute, '<=');
widgetSearchParameters = widgetSearchParameters.addNumericRefinement(attribute, '<=', upperBound);
}
return widgetSearchParameters;
}
};
};
};
function useRange(props, additionalWidgetProperties) {
return useConnector(connectRange, props, additionalWidgetProperties);
}
var withUsage$9 = createDocumentationMessageGenerator({
name: 'refinement-list',
connector: true
});
var DEFAULT_SORT = [
'isRefined',
'count:desc',
'name:asc'
];
/**
* **RefinementList** connector provides the logic to build a custom widget that
* will let the user filter the results based on the values of a specific facet.
*
* **Requirement:** the attribute passed as `attribute` must be present in
* attributesForFaceting of the searched index.
*
* This connector provides:
* - a `refine()` function to select an item.
* - a `toggleShowMore()` function to display more or less items
* - a `searchForItems()` function to search within the items.
*/ var connectRefinementList = function connectRefinementList(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$9());
return function(widgetParams) {
var _ref = widgetParams || {}, attribute = _ref.attribute, _ref_operator = _ref.operator, operator = _ref_operator === void 0 ? 'or' : _ref_operator, _ref_limit = _ref.limit, limit = _ref_limit === void 0 ? 10 : _ref_limit, _ref_showMore = _ref.showMore, showMore = _ref_showMore === void 0 ? false : _ref_showMore, _ref_showMoreLimit = _ref.showMoreLimit, showMoreLimit = _ref_showMoreLimit === void 0 ? 20 : _ref_showMoreLimit, _ref_sortBy = _ref.sortBy, sortBy = _ref_sortBy === void 0 ? DEFAULT_SORT : _ref_sortBy, _ref_escapeFacetValues = _ref.escapeFacetValues, escapeFacetValues = _ref_escapeFacetValues === void 0 ? true : _ref_escapeFacetValues, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
if (!attribute) {
throw new Error(withUsage$9('The `attribute` option is required.'));
}
if (!/^(and|or)$/.test(operator)) {
throw new Error(withUsage$9('The `operator` must one of: `"and"`, `"or"` (got "'.concat(operator, '").')));
}
if (showMore === true && showMoreLimit <= limit) {
throw new Error(withUsage$9('`showMoreLimit` should be greater than `limit`.'));
}
var formatItems = function formatItems(_0) {
var label = _0.name, value = _0.escapedValue, item = _object_without_properties(_0, [
"name",
"escapedValue"
]);
return _object_spread_props(_object_spread({}, item), {
value: value,
label: label,
highlighted: label
});
};
var lastResultsFromMainSearch;
var lastItemsFromMainSearch = [];
var hasExhaustiveItems = true;
var triggerRefine;
var sendEvent;
var isShowingMore = false;
// Provide the same function to the `renderFn` so that way the user
// has to only bind it once when `isFirstRendering` for instance
var toggleShowMore = function toggleShowMore() {};
function cachedToggleShowMore() {
toggleShowMore();
}
function createToggleShowMore(renderOptions, widget) {
return function() {
isShowingMore = !isShowingMore;
widget.render(renderOptions);
};
}
function getLimit() {
return isShowingMore ? showMoreLimit : limit;
}
var searchForFacetValues = function searchForFacetValues() {
return function() {};
};
var createSearchForFacetValues = function createSearchForFacetValues(helper, widget) {
return function(renderOptions) {
return function(query) {
var instantSearchInstance = renderOptions.instantSearchInstance, searchResults = renderOptions.results;
if (query === '' && lastItemsFromMainSearch) {
// render with previous data from the helper.
renderFn(_object_spread_props(_object_spread({}, widget.getWidgetRenderState(_object_spread_props(_object_spread({}, renderOptions), {
results: lastResultsFromMainSearch
}))), {
instantSearchInstance: instantSearchInstance
}), false);
} else {
var tags = {
highlightPreTag: escapeFacetValues ? TAG_PLACEHOLDER.highlightPreTag : TAG_REPLACEMENT.highlightPreTag,
highlightPostTag: escapeFacetValues ? TAG_PLACEHOLDER.highlightPostTag : TAG_REPLACEMENT.highlightPostTag
};
helper.searchForFacetValues(attribute, query, // doesn't support a greater number.
// See https://www.algolia.com/doc/api-reference/api-parameters/maxFacetHits/
Math.min(getLimit(), 100), tags).then(function(results) {
var facetValues = escapeFacetValues ? escapeFacets(results.facetHits) : results.facetHits;
var normalizedFacetValues = transformItems(facetValues.map(function(_0) {
var escapedValue = _0.escapedValue, value = _0.value, item = _object_without_properties(_0, [
"escapedValue",
"value"
]);
return _object_spread_props(_object_spread({}, item), {
value: escapedValue,
label: value
});
}), {
results: searchResults
});
renderFn(_object_spread_props(_object_spread({}, widget.getWidgetRenderState(_object_spread_props(_object_spread({}, renderOptions), {
results: lastResultsFromMainSearch
}))), {
items: normalizedFacetValues,
canToggleShowMore: false,
canRefine: true,
isFromSearch: true,
instantSearchInstance: instantSearchInstance
}), false);
});
}
};
};
};
return {
$$type: 'ais.refinementList',
init: function init(initOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
refinementList: _object_spread_props(_object_spread({}, renderState.refinementList), _define_property({}, attribute, this.getWidgetRenderState(renderOptions)))
});
},
getWidgetRenderState: function getWidgetRenderState(renderOptions) {
var _this = this;
var results = renderOptions.results, state = renderOptions.state, createURL = renderOptions.createURL, instantSearchInstance = renderOptions.instantSearchInstance, helper = renderOptions.helper;
var items = [];
var facetValues = [];
if (!sendEvent || !triggerRefine || !searchForFacetValues) {
sendEvent = createSendEventForFacet({
instantSearchInstance: instantSearchInstance,
helper: helper,
attribute: attribute,
widgetType: this.$$type
});
triggerRefine = function triggerRefine(facetValue) {
sendEvent('click:internal', facetValue);
helper.toggleFacetRefinement(attribute, facetValue).search();
};
searchForFacetValues = createSearchForFacetValues(helper, this);
}
if (results) {
var values = results.getFacetValues(attribute, {
sortBy: sortBy,
facetOrdering: sortBy === DEFAULT_SORT
});
facetValues = values && Array.isArray(values) ? values : [];
items = transformItems(facetValues.slice(0, getLimit()).map(formatItems), {
results: results
});
var maxValuesPerFacetConfig = state.maxValuesPerFacet;
var currentLimit = getLimit();
// If the limit is the max number of facet retrieved it is impossible to know
// if the facets are exhaustive. The only moment we are sure it is exhaustive
// is when it is strictly under the number requested unless we know that another
// widget has requested more values (maxValuesPerFacet > getLimit()).
// Because this is used for making the search of facets unable or not, it is important
// to be conservative here.
hasExhaustiveItems = maxValuesPerFacetConfig > currentLimit ? facetValues.length <= currentLimit : facetValues.length < currentLimit;
lastResultsFromMainSearch = results;
lastItemsFromMainSearch = items;
if (renderOptions.results) {
toggleShowMore = createToggleShowMore(renderOptions, this);
}
}
// Do not mistake searchForFacetValues and searchFacetValues which is the actual search
// function
var searchFacetValues = searchForFacetValues && searchForFacetValues(renderOptions);
var canShowLess = isShowingMore && lastItemsFromMainSearch.length > limit;
var canShowMore = showMore && !hasExhaustiveItems;
var canToggleShowMore = canShowLess || canShowMore;
return {
createURL: function createURL1(facetValue) {
return createURL(function(uiState) {
return _this.getWidgetUiState(uiState, {
searchParameters: state.resetPage().toggleFacetRefinement(attribute, facetValue),
helper: helper
});
});
},
items: items,
refine: triggerRefine,
searchForItems: searchFacetValues,
isFromSearch: false,
canRefine: items.length > 0,
widgetParams: widgetParams,
isShowingMore: isShowingMore,
canToggleShowMore: canToggleShowMore,
toggleShowMore: cachedToggleShowMore,
sendEvent: sendEvent,
hasExhaustiveItems: hasExhaustiveItems
};
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
var withoutMaxValuesPerFacet = state.setQueryParameter('maxValuesPerFacet', undefined);
if (operator === 'and') {
return withoutMaxValuesPerFacet.removeFacet(attribute);
}
return withoutMaxValuesPerFacet.removeDisjunctiveFacet(attribute);
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var values = operator === 'or' ? searchParameters.getDisjunctiveRefinements(attribute) : searchParameters.getConjunctiveRefinements(attribute);
return removeEmptyRefinementsFromUiState(_object_spread_props(_object_spread({}, uiState), {
refinementList: _object_spread_props(_object_spread({}, uiState.refinementList), _define_property({}, attribute, values))
}), attribute);
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
var isDisjunctive = operator === 'or';
if (searchParameters.isHierarchicalFacet(attribute)) {
return searchParameters;
}
if (isDisjunctive && searchParameters.isConjunctiveFacet(attribute) || !isDisjunctive && searchParameters.isDisjunctiveFacet(attribute)) {
return searchParameters;
}
var values = uiState.refinementList && uiState.refinementList[attribute];
var withFacetConfiguration = isDisjunctive ? searchParameters.addDisjunctiveFacet(attribute).removeDisjunctiveFacetRefinement(attribute) : searchParameters.addFacet(attribute).removeFacetRefinement(attribute);
var currentMaxValuesPerFacet = withFacetConfiguration.maxValuesPerFacet || 0;
var nextMaxValuesPerFacet = Math.max(currentMaxValuesPerFacet, showMore ? showMoreLimit : limit);
var withMaxValuesPerFacet = withFacetConfiguration.setQueryParameter('maxValuesPerFacet', nextMaxValuesPerFacet);
if (!values) {
var key = isDisjunctive ? 'disjunctiveFacetsRefinements' : 'facetsRefinements';
return withMaxValuesPerFacet.setQueryParameters(_define_property({}, key, _object_spread_props(_object_spread({}, withMaxValuesPerFacet[key]), _define_property({}, attribute, []))));
}
return values.reduce(function(parameters, value) {
return isDisjunctive ? parameters.addDisjunctiveFacetRefinement(attribute, value) : parameters.addFacetRefinement(attribute, value);
}, withMaxValuesPerFacet);
}
};
};
};
function removeEmptyRefinementsFromUiState(indexUiState, attribute) {
if (!indexUiState.refinementList) {
return indexUiState;
}
if (!indexUiState.refinementList[attribute] || indexUiState.refinementList[attribute].length === 0) {
delete indexUiState.refinementList[attribute];
}
if (Object.keys(indexUiState.refinementList).length === 0) {
delete indexUiState.refinementList;
}
return indexUiState;
}
function useRefinementList(props, additionalWidgetProperties) {
return useConnector(connectRefinementList, props, additionalWidgetProperties);
}
var withUsage$8 = createDocumentationMessageGenerator({
name: 'related-products',
connector: true
});
var connectRelatedProducts = function connectRelatedProducts(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$8());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_escapeHTML = _ref.escapeHTML, escapeHTML = _ref_escapeHTML === void 0 ? true : _ref_escapeHTML, objectIDs = _ref.objectIDs, limit = _ref.limit, threshold = _ref.threshold, fallbackParameters = _ref.fallbackParameters, queryParameters = _ref.queryParameters, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
if (!objectIDs || objectIDs.length === 0) {
throw new Error(withUsage$8('The `objectIDs` option is required.'));
}
var sendEvent;
return {
dependsOn: 'recommend',
$$type: 'ais.relatedProducts',
init: function init(initOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var renderState = this.getWidgetRenderState(renderOptions);
renderFn(_object_spread_props(_object_spread({}, renderState), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
getRenderState: function getRenderState(renderState) {
return renderState;
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, helper = param.helper, instantSearchInstance = param.instantSearchInstance;
if (!sendEvent) {
sendEvent = createSendEventForHits({
instantSearchInstance: instantSearchInstance,
helper: helper,
widgetType: this.$$type
});
}
if (results === null || results === undefined) {
return {
items: [],
widgetParams: widgetParams,
sendEvent: sendEvent
};
}
if (escapeHTML && results.hits.length > 0) {
results.hits = escapeHits(results.hits);
}
var itemsWithAbsolutePosition = addAbsolutePosition$1(results.hits, 0, 1);
var itemsWithAbsolutePositionAndQueryID = addQueryID$1(itemsWithAbsolutePosition, results.queryID);
var transformedItems = transformItems(itemsWithAbsolutePositionAndQueryID, {
results: results
});
return {
items: transformedItems,
widgetParams: widgetParams,
sendEvent: sendEvent
};
},
dispose: function dispose(param) {
var recommendState = param.recommendState;
unmountFn();
return recommendState.removeParams(this.$$id);
},
getWidgetParameters: function getWidgetParameters(state) {
var _this = this;
return objectIDs.reduce(function(acc, objectID) {
return acc.addRelatedProducts({
objectID: objectID,
maxRecommendations: limit,
threshold: threshold,
fallbackParameters: fallbackParameters ? _object_spread({}, fallbackParameters, escapeHTML ? TAG_PLACEHOLDER : {}) : undefined,
queryParameters: _object_spread({}, queryParameters, escapeHTML ? TAG_PLACEHOLDER : {}),
$$id: _this.$$id
});
}, state.removeParams(this.$$id));
}
};
};
};
function useRelatedProducts(props, additionalWidgetProperties) {
return useConnector(connectRelatedProducts, props, additionalWidgetProperties);
}
var withUsage$7 = createDocumentationMessageGenerator({
name: 'search-box',
connector: true
});
var defaultQueryHook = function defaultQueryHook(query, hook) {
return hook(query);
};
/**
* **SearchBox** connector provides the logic to build a widget that will let the user search for a query.
*
* The connector provides to the rendering: `refine()` to set the query. The behaviour of this function
* may be impacted by the `queryHook` widget parameter.
*/ var connectSearchBox = function connectSearchBox(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$7());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_queryHook = _ref.queryHook, queryHook = _ref_queryHook === void 0 ? defaultQueryHook : _ref_queryHook;
var _refine;
var _clear;
return {
$$type: 'ais.searchBox',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
return state.setQueryParameter('query', undefined);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
searchBox: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var helper = param.helper, instantSearchInstance = param.instantSearchInstance, state = param.state;
if (!_refine) {
_refine = function _refine(query) {
queryHook(query, function(q) {
return helper.setQuery(q).search();
});
};
_clear = function _clear() {
helper.setQuery('').search();
};
}
return {
query: state.query || '',
refine: _refine,
clear: _clear,
widgetParams: widgetParams,
isSearchStalled: instantSearchInstance.status === 'stalled'
};
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var query = searchParameters.query || '';
if (query === '' || uiState && uiState.query === query) {
return uiState;
}
return _object_spread_props(_object_spread({}, uiState), {
query: query
});
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
return searchParameters.setQueryParameter('query', uiState.query || '');
}
};
};
};
function useSearchBox(props, additionalWidgetProperties) {
return useConnector(connectSearchBox, props, additionalWidgetProperties);
}
var withUsage$6 = createDocumentationMessageGenerator({
name: 'sort-by',
connector: true
});
function isStrategyItem(item) {
return 'strategy' in item && item.strategy !== undefined;
}
function getItemValue(item) {
if (isStrategyItem(item)) {
return item.strategy;
}
return item.value;
}
function isValidStrategy(itemsLookup, value) {
if (!value) return false;
var item = itemsLookup[value];
return item !== undefined && isStrategyItem(item);
}
var connectSortBy = function connectSortBy(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$6());
var connectorState = {};
return function(widgetParams) {
var _ref = widgetParams || {}, items = _ref.items, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(x) {
return x;
} : _ref_transformItems;
if (!Array.isArray(items)) {
throw new Error(withUsage$6('The `items` option expects an array of objects.'));
}
var itemsLookup = {};
items.forEach(function(item, index) {
var hasValue = 'value' in item && item.value !== undefined;
var hasStrategy = 'strategy' in item && item.strategy !== undefined;
// Validate mutual exclusivity
if (hasValue && hasStrategy) {
throw new Error(withUsage$6("Item at index ".concat(index, ' cannot have both "value" and "strategy" properties.')));
}
if (!hasValue && !hasStrategy) {
throw new Error(withUsage$6("Item at index ".concat(index, ' must have either a "value" or "strategy" property.')));
}
var itemValue = getItemValue(item);
itemsLookup[itemValue] = item;
});
connectorState.itemsLookup = itemsLookup;
return {
$$type: 'ais.sortBy',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
// Check if strategies are used outside composition mode
var hasStrategyItems = items.some(function(item) {
return 'strategy' in item && item.strategy;
});
if (hasStrategyItems && !instantSearchInstance.compositionID) {
throw new Error(withUsage$6('Sorting strategies can only be used in composition mode. Please provide a "compositionID" to your InstantSearch instance.'));
}
var widgetRenderState = this.getWidgetRenderState(initOptions);
var currentIndex = widgetRenderState.currentRefinement;
find$1(items, function(item) {
return getItemValue(item) === currentIndex;
});
renderFn(_object_spread_props(_object_spread({}, widgetRenderState), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
// Clear sortBy parameter if it was set
if (connectorState.isUsingComposition && state.sortBy) {
state = state.setQueryParameter('sortBy', undefined);
}
// Restore initial index if changed
if (connectorState.initialValue && state.index !== connectorState.initialValue) {
return state.setIndex(connectorState.initialValue);
}
return state;
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
sortBy: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, helper = param.helper, state = param.state, parent = param.parent, instantSearchInstance = param.instantSearchInstance;
// Capture initial value (composition ID or main index)
if (!connectorState.initialValue && parent) {
connectorState.initialValue = parent.getIndexName();
}
// Create refine function if not exists
if (!connectorState.refine) {
// Cache composition mode status for lifecycle methods that don't have access to instantSearchInstance
connectorState.isUsingComposition = Boolean(instantSearchInstance === null || instantSearchInstance === void 0 ? void 0 : instantSearchInstance.compositionID);
connectorState.refine = function(value) {
// O(1) lookup using the items lookup table
var item = connectorState.itemsLookup[value];
if (item && isStrategyItem(item)) {
// Strategy-based: set sortBy parameter for composition API
// The composition backend will interpret this and apply the sorting strategy
helper.setQueryParameter('sortBy', item.strategy).search();
} else {
// Index-based: clear any existing sortBy parameter and switch to the new index
// Clearing sortBy is critical when transitioning from strategy to index-based sorting
helper.setQueryParameter('sortBy', undefined).setIndex(value).search();
}
};
}
// Transform items first (on original structure)
var transformedItems = transformItems(items, {
results: results
});
// Normalize items: all get a 'value' property for the render state
var normalizedItems = transformedItems.map(function(item) {
return {
label: item.label,
value: getItemValue(item)
};
});
// Determine current refinement
// In composition mode, prefer sortBy parameter if it corresponds to a valid strategy item
// Otherwise use the index (for index-based items or when no valid strategy is active)
var currentRefinement = connectorState.isUsingComposition && isValidStrategy(connectorState.itemsLookup, state.sortBy) ? state.sortBy : state.index;
var hasNoResults = results ? results.nbHits === 0 : true;
return {
currentRefinement: currentRefinement,
options: normalizedItems,
refine: connectorState.refine,
hasNoResults: hasNoResults,
canRefine: !hasNoResults && items.length > 0,
widgetParams: widgetParams
};
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
// In composition mode with an active strategy, use sortBy parameter
// Otherwise use index-based behavior (traditional mode)
var currentValue = connectorState.isUsingComposition && isValidStrategy(connectorState.itemsLookup, searchParameters.sortBy) ? searchParameters.sortBy : searchParameters.index;
return _object_spread_props(_object_spread({}, uiState), {
sortBy: currentValue !== connectorState.initialValue ? currentValue : undefined
});
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
var isUiStateSortByInItems = !uiState.sortBy || Object.prototype.hasOwnProperty.call(connectorState.itemsLookup, uiState.sortBy);
var sortByValue = (isUiStateSortByInItems ? uiState.sortBy : undefined) || connectorState.initialValue || searchParameters.index;
if (isValidStrategy(connectorState.itemsLookup, sortByValue)) {
var item = connectorState.itemsLookup[sortByValue];
// Strategy-based: set the sortBy parameter for composition API
// The index remains as the compositionID
return searchParameters.setQueryParameter('sortBy', item.strategy);
}
// Index-based: set the index parameter (traditional behavior)
return searchParameters.setQueryParameter('index', sortByValue);
}
};
};
};
function useSortBy(props, additionalWidgetProperties) {
return useConnector(connectSortBy, props, additionalWidgetProperties);
}
var withUsage$5 = createDocumentationMessageGenerator({
name: 'stats',
connector: true
});
var connectStats = function connectStats(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$5());
return function(widgetParams) {
return {
$$type: 'ais.stats',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose() {
unmountFn();
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
stats: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, state = param.state;
if (!results) {
return {
hitsPerPage: state.hitsPerPage,
nbHits: 0,
nbSortedHits: undefined,
areHitsSorted: false,
nbPages: 0,
page: state.page || 0,
processingTimeMS: -1,
query: state.query || '',
widgetParams: widgetParams
};
}
return {
hitsPerPage: results.hitsPerPage,
nbHits: results.nbHits,
nbSortedHits: results.nbSortedHits,
areHitsSorted: typeof results.appliedRelevancyStrictness !== 'undefined' && results.appliedRelevancyStrictness > 0 && results.nbSortedHits !== results.nbHits,
nbPages: results.nbPages,
page: results.page,
processingTimeMS: results.processingTimeMS,
query: results.query,
widgetParams: widgetParams
};
}
};
};
};
function useStats(props, additionalWidgetProperties) {
return useConnector(connectStats, props, additionalWidgetProperties);
}
var withUsage$4 = createDocumentationMessageGenerator({
name: 'toggle-refinement',
connector: true
});
var $$type = 'ais.toggleRefinement';
var createSendEvent = function createSendEvent(param) {
var instantSearchInstance = param.instantSearchInstance, helper = param.helper, attribute = param.attribute, on = param.on;
var sendEventForToggle = function sendEventForToggle() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
if (args.length === 1) {
instantSearchInstance.sendEventToInsights(args[0]);
return;
}
var _args = _sliced_to_array(args, 3), isRefined = _args[1], tmp = _args[2], eventName = tmp === void 0 ? 'Filter Applied' : tmp;
var _args__split = _sliced_to_array(args[0].split(':'), 2), eventType = _args__split[0], eventModifier = _args__split[1];
if (eventType !== 'click' || on === undefined) {
return;
}
// only send an event when the refinement gets applied,
// not when it gets removed
if (!isRefined) {
var _helper_lastResults;
instantSearchInstance.sendEventToInsights({
insightsMethod: 'clickedFilters',
widgetType: $$type,
eventType: eventType,
eventModifier: eventModifier,
payload: {
eventName: eventName,
index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
filters: on.map(function(value) {
return "".concat(attribute, ":").concat(value);
})
},
attribute: attribute
});
}
};
return sendEventForToggle;
};
/**
* **Toggle** connector provides the logic to build a custom widget that will provide
* an on/off filtering feature based on an attribute value or values.
*
* Two modes are implemented in the custom widget:
* - with or without the value filtered
* - switch between two values.
*/ var connectToggleRefinement = function connectToggleRefinement(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$4());
return function(widgetParams) {
var _ref = widgetParams || {}, attribute = _ref.attribute, tmp = _ref.on, userOn = tmp === void 0 ? true : tmp, userOff = _ref.off;
if (!attribute) {
throw new Error(withUsage$4('The `attribute` option is required.'));
}
var hasAnOffValue = userOff !== undefined;
// even though facet values can be numbers and boolean,
// the helper methods only accept string in the type
var on = toArray(userOn).map(escapeFacetValue);
var off = hasAnOffValue ? toArray(userOff).map(escapeFacetValue) : undefined;
var sendEvent;
var toggleRefinementFactory = function toggleRefinementFactory(helper) {
return function() {
var isRefined = (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
isRefined: false
}).isRefined;
if (!isRefined) {
sendEvent('click:internal', isRefined);
if (hasAnOffValue) {
off.forEach(function(v) {
return helper.removeDisjunctiveFacetRefinement(attribute, v);
});
}
on.forEach(function(v) {
return helper.addDisjunctiveFacetRefinement(attribute, v);
});
} else {
on.forEach(function(v) {
return helper.removeDisjunctiveFacetRefinement(attribute, v);
});
if (hasAnOffValue) {
off.forEach(function(v) {
return helper.addDisjunctiveFacetRefinement(attribute, v);
});
}
}
helper.search();
};
};
var connectorState = {
createURLFactory: function createURLFactory(isRefined, param) {
var state = param.state, createURL = param.createURL, getWidgetUiState = param.getWidgetUiState, helper = param.helper;
return function() {
state = state.resetPage();
var valuesToRemove = isRefined ? on : off;
if (valuesToRemove) {
valuesToRemove.forEach(function(v) {
state = state.removeDisjunctiveFacetRefinement(attribute, v);
});
}
var valuesToAdd = isRefined ? off : on;
if (valuesToAdd) {
valuesToAdd.forEach(function(v) {
state = state.addDisjunctiveFacetRefinement(attribute, v);
});
}
return createURL(function(uiState) {
return getWidgetUiState(uiState, {
searchParameters: state,
helper: helper
});
});
};
}
};
return {
$$type: $$type,
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var instantSearchInstance = renderOptions.instantSearchInstance;
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose(param) {
var state = param.state;
unmountFn();
return state.removeDisjunctiveFacet(attribute);
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
toggleRefinement: _object_spread_props(_object_spread({}, renderState.toggleRefinement), _define_property({}, attribute, this.getWidgetRenderState(renderOptions)))
});
},
getWidgetRenderState: function getWidgetRenderState(param) {
var state = param.state, helper = param.helper, results = param.results, createURL = param.createURL, instantSearchInstance = param.instantSearchInstance;
var isRefined = results ? on.every(function(v) {
return state.isDisjunctiveFacetRefined(attribute, v);
}) : on.every(function(v) {
return state.isDisjunctiveFacetRefined(attribute, v);
});
var onFacetValue = {
isRefined: isRefined,
count: 0
};
var offFacetValue = {
isRefined: hasAnOffValue && !isRefined,
count: 0
};
if (results) {
var offValue = toArray(off || false);
var allFacetValues = results.getFacetValues(attribute, {}) || [];
var onData = on.map(function(v) {
return find$1(allFacetValues, function(param) {
var escapedValue = param.escapedValue;
return escapedValue === escapeFacetValue(String(v));
});
}).filter(function(v) {
return v !== undefined;
});
var offData = hasAnOffValue ? offValue.map(function(v) {
return find$1(allFacetValues, function(param) {
var escapedValue = param.escapedValue;
return escapedValue === escapeFacetValue(String(v));
});
}).filter(function(v) {
return v !== undefined;
}) : [];
onFacetValue = {
isRefined: onData.length ? onData.every(function(v) {
return v.isRefined;
}) : false,
count: onData.reduce(function(acc, v) {
return acc + v.count;
}, 0) || null
};
offFacetValue = {
isRefined: offData.length ? offData.every(function(v) {
return v.isRefined;
}) : false,
count: offData.reduce(function(acc, v) {
return acc + v.count;
}, 0) || allFacetValues.reduce(function(total, param) {
var count = param.count;
return total + count;
}, 0)
};
}
if (!sendEvent) {
sendEvent = createSendEvent({
instantSearchInstance: instantSearchInstance,
attribute: attribute,
on: on,
helper: helper
});
}
var nextRefinement = isRefined ? offFacetValue : onFacetValue;
return {
value: {
name: attribute,
isRefined: isRefined,
count: results ? nextRefinement.count : null,
onFacetValue: onFacetValue,
offFacetValue: offFacetValue
},
createURL: connectorState.createURLFactory(isRefined, {
state: state,
createURL: createURL,
helper: helper,
getWidgetUiState: this.getWidgetUiState
}),
sendEvent: sendEvent,
canRefine: Boolean(results ? nextRefinement.count : null),
refine: toggleRefinementFactory(helper),
widgetParams: widgetParams
};
},
getWidgetUiState: function getWidgetUiState(uiState, param) {
var searchParameters = param.searchParameters;
var isRefined = on && on.every(function(v) {
return searchParameters.isDisjunctiveFacetRefined(attribute, v);
});
if (!isRefined) {
var _uiState_toggle;
// This needs to be done in the case `uiState` comes from `createURL`
(_uiState_toggle = uiState.toggle) === null || _uiState_toggle === void 0 ? true : delete _uiState_toggle[attribute];
return uiState;
}
return _object_spread_props(_object_spread({}, uiState), {
toggle: _object_spread_props(_object_spread({}, uiState.toggle), _define_property({}, attribute, isRefined))
});
},
getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
var uiState = param.uiState;
if (searchParameters.isHierarchicalFacet(attribute) || searchParameters.isConjunctiveFacet(attribute)) {
return searchParameters;
}
var withFacetConfiguration = searchParameters.addDisjunctiveFacet(attribute).removeDisjunctiveFacetRefinement(attribute);
var isRefined = Boolean(uiState.toggle && uiState.toggle[attribute]);
if (isRefined) {
if (on) {
on.forEach(function(v) {
withFacetConfiguration = withFacetConfiguration.addDisjunctiveFacetRefinement(attribute, v);
});
}
return withFacetConfiguration;
}
// It's not refined with an `off` value
if (hasAnOffValue) {
if (off) {
off.forEach(function(v) {
withFacetConfiguration = withFacetConfiguration.addDisjunctiveFacetRefinement(attribute, v);
});
}
return withFacetConfiguration;
}
// It's not refined without an `off` value
return withFacetConfiguration.setQueryParameters({
disjunctiveFacetsRefinements: _object_spread_props(_object_spread({}, searchParameters.disjunctiveFacetsRefinements), _define_property({}, attribute, []))
});
}
};
};
};
function useToggleRefinement(props, additionalWidgetProperties) {
return useConnector(connectToggleRefinement, props, additionalWidgetProperties);
}
var withUsage$3 = createDocumentationMessageGenerator({
name: 'trending-items',
connector: true
});
var connectTrendingItems = function connectTrendingItems(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$3());
return function(widgetParams) {
var _ref = widgetParams || {}, facetName = _ref.facetName, facetValue = _ref.facetValue, limit = _ref.limit, threshold = _ref.threshold, fallbackParameters = _ref.fallbackParameters, queryParameters = _ref.queryParameters, _ref_escapeHTML = _ref.escapeHTML, escapeHTML = _ref_escapeHTML === void 0 ? true : _ref_escapeHTML, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
if (facetName && !facetValue || !facetName && facetValue) {
throw new Error(withUsage$3("When you provide facetName (received type ".concat(getObjectType(facetName), "), you must also provide facetValue (received type ").concat(getObjectType(facetValue), ").")));
}
var sendEvent;
return {
dependsOn: 'recommend',
$$type: 'ais.trendingItems',
init: function init(initOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var renderState = this.getWidgetRenderState(renderOptions);
renderFn(_object_spread_props(_object_spread({}, renderState), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
getRenderState: function getRenderState(renderState) {
return renderState;
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, helper = param.helper, instantSearchInstance = param.instantSearchInstance;
if (!sendEvent) {
sendEvent = createSendEventForHits({
instantSearchInstance: instantSearchInstance,
helper: helper,
widgetType: this.$$type
});
}
if (results === null || results === undefined) {
return {
items: [],
widgetParams: widgetParams,
sendEvent: sendEvent
};
}
if (escapeHTML && results.hits.length > 0) {
results.hits = escapeHits(results.hits);
}
var itemsWithAbsolutePosition = addAbsolutePosition$1(results.hits, 0, 1);
var itemsWithAbsolutePositionAndQueryID = addQueryID$1(itemsWithAbsolutePosition, results.queryID);
var transformedItems = transformItems(itemsWithAbsolutePositionAndQueryID, {
results: results
});
return {
items: transformedItems,
widgetParams: widgetParams,
sendEvent: sendEvent
};
},
dispose: function dispose(param) {
var recommendState = param.recommendState;
unmountFn();
return recommendState.removeParams(this.$$id);
},
getWidgetParameters: function getWidgetParameters(state) {
return state.removeParams(this.$$id).addTrendingItems({
facetName: facetName,
facetValue: facetValue,
maxRecommendations: limit,
threshold: threshold,
fallbackParameters: fallbackParameters ? _object_spread({}, fallbackParameters, escapeHTML ? TAG_PLACEHOLDER : {}) : undefined,
queryParameters: _object_spread({}, queryParameters, escapeHTML ? TAG_PLACEHOLDER : {}),
$$id: this.$$id
});
}
};
};
};
function useTrendingItems(props, additionalWidgetProperties) {
return useConnector(connectTrendingItems, props, additionalWidgetProperties);
}
var withUsage$2 = createDocumentationMessageGenerator({
name: 'trending-facets',
connector: true
});
var connectTrendingFacets = function connectTrendingFacets(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$2());
return function(widgetParams) {
var _ref = widgetParams || {}, facetName = _ref.facetName, limit = _ref.limit, threshold = _ref.threshold, fallbackParameters = _ref.fallbackParameters, _ref_escapeHTML = _ref.escapeHTML, escapeHTML = _ref_escapeHTML === void 0 ? true : _ref_escapeHTML, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
if (!facetName) {
throw new Error(withUsage$2('The `facetName` option is required.'));
}
return {
dependsOn: 'recommend',
$$type: 'ais.trendingFacets',
init: function init(initOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var renderState = this.getWidgetRenderState(renderOptions);
renderFn(_object_spread_props(_object_spread({}, renderState), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
getRenderState: function getRenderState(renderState) {
return renderState;
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results;
param.helper;
param.instantSearchInstance;
if (results === null || results === undefined) {
return {
items: [],
widgetParams: widgetParams
};
}
var items = (results.hits || []).map(function(hit) {
return {
facetName: hit.facetName,
facetValue: hit.facetValue,
_score: hit._score
};
});
if (escapeHTML) {
items = items.map(function(item) {
return _object_spread_props(_object_spread({}, item), {
facetValue: escape$1(item.facetValue)
});
});
}
items = transformItems(items, {
results: results
});
return {
items: items,
widgetParams: widgetParams
};
},
dispose: function dispose(param) {
var recommendState = param.recommendState;
unmountFn();
return recommendState.removeParams(this.$$id);
},
getWidgetParameters: function getWidgetParameters(state) {
// v4 TrendingFacetsQuery doesn't include queryParameters or
// fallbackParameters, but the v5 API and the helper support them.
return state.removeParams(this.$$id).addTrendingFacets({
facetName: facetName,
maxRecommendations: limit,
threshold: threshold,
fallbackParameters: fallbackParameters ? _object_spread({}, fallbackParameters, escapeHTML ? TAG_PLACEHOLDER : {}) : undefined,
$$id: this.$$id
});
}
};
};
};
function useTrendingFacets(props, additionalWidgetProperties) {
return useConnector(connectTrendingFacets, props, additionalWidgetProperties);
}
var withUsage$1 = createDocumentationMessageGenerator({
name: 'looking-similar',
connector: true
});
var connectLookingSimilar = function connectLookingSimilar(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage$1());
return function(widgetParams) {
var _ref = widgetParams || {}, _ref_escapeHTML = _ref.escapeHTML, escapeHTML = _ref_escapeHTML === void 0 ? true : _ref_escapeHTML, objectIDs = _ref.objectIDs, limit = _ref.limit, threshold = _ref.threshold, fallbackParameters = _ref.fallbackParameters, queryParameters = _ref.queryParameters, _ref_transformItems = _ref.transformItems, transformItems = _ref_transformItems === void 0 ? function(items) {
return items;
} : _ref_transformItems;
if (!objectIDs || objectIDs.length === 0) {
throw new Error(withUsage$1('The `objectIDs` option is required.'));
}
var sendEvent;
return {
dependsOn: 'recommend',
$$type: 'ais.lookingSimilar',
init: function init(initOptions) {
renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
instantSearchInstance: initOptions.instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var renderState = this.getWidgetRenderState(renderOptions);
renderFn(_object_spread_props(_object_spread({}, renderState), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
},
getRenderState: function getRenderState(renderState) {
return renderState;
},
getWidgetRenderState: function getWidgetRenderState(param) {
var results = param.results, helper = param.helper, instantSearchInstance = param.instantSearchInstance;
if (!sendEvent) {
sendEvent = createSendEventForHits({
instantSearchInstance: instantSearchInstance,
helper: helper,
widgetType: this.$$type
});
}
if (results === null || results === undefined) {
return {
items: [],
widgetParams: widgetParams,
sendEvent: sendEvent
};
}
if (escapeHTML && results.hits.length > 0) {
results.hits = escapeHits(results.hits);
}
var itemsWithAbsolutePosition = addAbsolutePosition$1(results.hits, 0, 1);
var itemsWithAbsolutePositionAndQueryID = addQueryID$1(itemsWithAbsolutePosition, results.queryID);
var transformedItems = transformItems(itemsWithAbsolutePositionAndQueryID, {
results: results
});
return {
items: transformedItems,
widgetParams: widgetParams,
sendEvent: sendEvent
};
},
dispose: function dispose(param) {
var recommendState = param.recommendState;
unmountFn();
return recommendState.removeParams(this.$$id);
},
getWidgetParameters: function getWidgetParameters(state) {
var _this = this;
return objectIDs.reduce(function(acc, objectID) {
return acc.addLookingSimilar({
objectID: objectID,
maxRecommendations: limit,
threshold: threshold,
fallbackParameters: fallbackParameters ? _object_spread({}, fallbackParameters, escapeHTML ? TAG_PLACEHOLDER : {}) : undefined,
queryParameters: _object_spread({}, queryParameters, escapeHTML ? TAG_PLACEHOLDER : {}),
$$id: _this.$$id
});
}, state.removeParams(this.$$id));
}
};
};
};
function useLookingSimilar(props, additionalWidgetProperties) {
return useConnector(connectLookingSimilar, props, additionalWidgetProperties);
}
var withUsage = createDocumentationMessageGenerator({
name: 'filter-suggestions',
connector: true
});
/**
* @deprecated Filter suggestions are deprecated and will be removed in a future major version.
*/ var connectFilterSuggestions = function connectFilterSuggestions(renderFn) {
var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
checkRendering(renderFn, withUsage());
return function(widgetParams) {
var agentId = widgetParams.agentId, attributes = widgetParams.attributes, _widgetParams_maxSuggestions = widgetParams.maxSuggestions, maxSuggestions = _widgetParams_maxSuggestions === void 0 ? 3 : _widgetParams_maxSuggestions, _widgetParams_debounceMs = widgetParams.debounceMs, debounceMs = _widgetParams_debounceMs === void 0 ? 300 : _widgetParams_debounceMs, _widgetParams_hitsToSample = widgetParams.hitsToSample, hitsToSample = _widgetParams_hitsToSample === void 0 ? 5 : _widgetParams_hitsToSample, _widgetParams_transformItems = widgetParams.transformItems, transformItems = _widgetParams_transformItems === void 0 ? function(items) {
return items;
} : _widgetParams_transformItems, transport = widgetParams.transport;
if (!agentId && !transport) {
throw new Error(withUsage('The `agentId` option is required unless a custom `transport` is provided.'));
}
var endpoint;
var headers;
var suggestions = [];
var isLoading = false;
var debounceTimer;
var lastStateSignature = null; // null means never fetched
var refine;
var searchHelper = null;
var latestRenderOptions = null;
// Create a signature of the current search state (query + refinements)
var getStateSignature = function getStateSignature(results) {
var query = results.query || '';
var refinements = searchHelper ? JSON.stringify(searchHelper.state.facetsRefinements) + JSON.stringify(searchHelper.state.disjunctiveFacetsRefinements) + JSON.stringify(searchHelper.state.hierarchicalFacetsRefinements) : '';
return "".concat(query, "|").concat(refinements);
};
var getWidgetRenderState = function getWidgetRenderState(renderOptions) {
var results = 'results' in renderOptions ? renderOptions.results : undefined;
var transformedSuggestions = transformItems(suggestions, {
results: results
});
return {
suggestions: transformedSuggestions,
isLoading: isLoading,
refine: refine,
widgetParams: widgetParams
};
};
// Minimum duration to show skeleton to avoid flash when results are cached
var MIN_SKELETON_DURATION_MS = 300;
var fetchSuggestions = function fetchSuggestions(results, renderOptions) {
var _results_hits, _rawResults_;
if (!(results === null || results === void 0 ? void 0 : (_results_hits = results.hits) === null || _results_hits === void 0 ? void 0 : _results_hits.length)) {
suggestions = [];
isLoading = false;
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(renderOptions)), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
return;
}
var loadingStartTime = Date.now();
isLoading = true;
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(renderOptions)), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
// Get facets from raw results (results.facets is processed differently)
var rawResults = results._rawResults;
var rawFacets = (rawResults === null || rawResults === void 0 ? void 0 : (_rawResults_ = rawResults[0]) === null || _rawResults_ === void 0 ? void 0 : _rawResults_.facets) || {};
var facetsToSend = attributes ? Object.fromEntries(Object.entries(rawFacets).filter(function(param) {
var _param = _sliced_to_array(param, 1), key = _param[0];
return attributes.includes(key);
})) : rawFacets;
// Collect current refinements to exclude from suggestions
var currentRefinements = searchHelper ? getRefinements(results, searchHelper.state).map(function(refinement) {
return {
attribute: refinement.attribute,
value: refinement.name
};
}) : [];
var messageText = JSON.stringify({
query: results.query,
facets: facetsToSend,
hitsSample: results.hits.slice(0, hitsToSample),
currentRefinements: currentRefinements,
maxSuggestions: maxSuggestions
});
var payload = {
messages: [
{
id: "sr-".concat(Date.now()),
createdAt: new Date().toISOString(),
role: 'user',
parts: [
{
type: 'text',
text: messageText
}
]
}
]
};
// Apply custom body transformation if provided
var finalPayload = (transport === null || transport === void 0 ? void 0 : transport.prepareSendMessagesRequest) ? transport.prepareSendMessagesRequest(payload).body : payload;
fetch(endpoint, {
method: 'POST',
headers: _object_spread_props(_object_spread({}, headers), {
'Content-Type': 'application/json'
}),
body: JSON.stringify(finalPayload)
}).then(function(response) {
if (!response.ok) {
throw new Error("HTTP error ".concat(response.status));
}
return response.json();
}).then(function(data) {
var parsedSuggestions = JSON.parse(data.parts[1].text);
var validSuggestions = (Array.isArray(parsedSuggestions) ? parsedSuggestions : []).filter(function(suggestion) {
if (!(suggestion === null || suggestion === void 0 ? void 0 : suggestion.attribute) || !(suggestion === null || suggestion === void 0 ? void 0 : suggestion.value) || !(suggestion === null || suggestion === void 0 ? void 0 : suggestion.label)) {
return false;
}
// If attributes filter is specified, only allow suggestions for those attributes
if (attributes && !attributes.includes(suggestion.attribute)) {
return false;
}
return true;
}).slice(0, maxSuggestions);
suggestions = validSuggestions;
}).catch(function() {
suggestions = [];
}).finally(function() {
var elapsed = Date.now() - loadingStartTime;
var remainingDelay = Math.max(0, MIN_SKELETON_DURATION_MS - elapsed);
var finishLoading = function finishLoading() {
isLoading = false;
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(renderOptions)), {
instantSearchInstance: renderOptions.instantSearchInstance
}), false);
};
if (remainingDelay > 0) {
setTimeout(finishLoading, remainingDelay);
} else {
finishLoading();
}
});
};
return {
$$type: 'ais.filterSuggestions',
init: function init(initOptions) {
var instantSearchInstance = initOptions.instantSearchInstance, helper = initOptions.helper;
searchHelper = helper;
if (transport) {
// Use custom transport configuration
endpoint = transport.api;
headers = transport.headers || {};
} else {
// Use default Algolia agent endpoint
var _getAppIdAndApiKey = _sliced_to_array(getAppIdAndApiKey(instantSearchInstance.client), 2), appId = _getAppIdAndApiKey[0], apiKey = _getAppIdAndApiKey[1];
if (!appId || !apiKey) {
throw new Error(withUsage('Could not extract Algolia credentials from the search client.'));
}
endpoint = "https://".concat(appId, ".algolia.net/agent-studio/1/agents/").concat(agentId, "/completions?compatibilityMode=ai-sdk-5&stream=false");
headers = {
'x-algolia-application-id': appId,
'x-algolia-api-key': apiKey,
'x-algolia-agent': getAlgoliaAgent(instantSearchInstance.client)
};
}
refine = function refine(attribute, value) {
var _helper_state_hierarchicalFacets_find;
// Check if the attribute belongs to a hierarchical facet
// by finding a hierarchical facet that includes this attribute
var attr = ((_helper_state_hierarchicalFacets_find = helper.state.hierarchicalFacets.find(function(facet) {
return facet.attributes.includes(attribute);
})) === null || _helper_state_hierarchicalFacets_find === void 0 ? void 0 : _helper_state_hierarchicalFacets_find.name) || attribute;
helper.toggleFacetRefinement(attr, value);
helper.search();
};
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(initOptions)), {
instantSearchInstance: instantSearchInstance
}), true);
},
render: function render(renderOptions) {
var results = renderOptions.results, instantSearchInstance = renderOptions.instantSearchInstance;
// Always store the latest render options
latestRenderOptions = renderOptions;
if (!results) {
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
return;
}
// Debounce: only fetch if search state changed (query or refinements) and after delay
var stateSignature = getStateSignature(results);
if (stateSignature !== lastStateSignature) {
lastStateSignature = stateSignature;
clearTimeout(debounceTimer);
debounceTimer = setTimeout(function() {
// Use the latest render options when the timeout fires
if (latestRenderOptions === null || latestRenderOptions === void 0 ? void 0 : latestRenderOptions.results) {
fetchSuggestions(latestRenderOptions.results, latestRenderOptions);
}
}, debounceMs);
}
renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(renderOptions)), {
instantSearchInstance: instantSearchInstance
}), false);
},
dispose: function dispose() {
clearTimeout(debounceTimer);
unmountFn();
},
getRenderState: function getRenderState(renderState, renderOptions) {
return _object_spread_props(_object_spread({}, renderState), {
filterSuggestions: this.getWidgetRenderState(renderOptions)
});
},
getWidgetRenderState: function getWidgetRenderState1(renderOptions) {
return getWidgetRenderState(renderOptions);
}
};
};
};
/**
* @deprecated Filter suggestions are deprecated and will be removed in a future major version.
*/ function useFilterSuggestions(props, additionalWidgetProperties) {
return useConnector(connectFilterSuggestions, props, additionalWidgetProperties);
}
function useSearchResults() {
var search = useInstantSearchContext();
var searchIndex = useIndexContext();
var _useState = _sliced_to_array(React.useState(function() {
var indexSearchResults = getIndexSearchResults(searchIndex);
// We do this not to leak `recommendResults` in the API.
return {
results: indexSearchResults.results,
scopedResults: indexSearchResults.scopedResults
};
}), 2), searchResults = _useState[0], setSearchResults = _useState[1];
React.useEffect(function() {
function handleRender() {
var results = searchIndex.getResults();
// Results can be `null` when the first search is stalled.
// In this case, we skip the update.
// See: https://github.com/algolia/instantsearch/blob/20996c7a159988c58e00ff24d2d2dc98af8b980f/src/widgets/index/index.ts#L652-L657
if (results !== null) {
setSearchResults({
results: results,
scopedResults: searchIndex.getScopedResults()
});
} else if (search.mainIndex.getIndexName().length === 0) {
// If the main index has no name, we get the scoped results from
// the first child index instead.
var childIndex = search.mainIndex.getWidgets().find(isIndexWidget);
childIndex && setSearchResults({
results: getIndexSearchResults(searchIndex).results,
scopedResults: childIndex.getScopedResults()
});
}
}
search.addListener('render', handleRender);
// Force setting results to mitigate potential race conditions where
// render listener is added after search results have been returned.
// This edge case is currently not covered by the tests.
handleRender();
return function() {
search.removeListener('render', handleRender);
};
}, [
search,
searchIndex
]);
return searchResults;
}
function useSearchState() {
var search = useInstantSearchContext();
var searchIndex = useIndexContext();
var indexId = searchIndex.getIndexId();
var _useState = _sliced_to_array(React.useState(function() {
return search.getUiState();
}), 2), uiState = _useState[0], setLocalUiState = _useState[1];
var indexUiState = uiState[indexId];
var _useState1 = _sliced_to_array(React.useState(function() {
return search.renderState;
}), 2), renderState = _useState1[0], setRenderState = _useState1[1];
var indexRenderState = renderState[indexId] || {};
var setUiState = React.useCallback(function(nextUiState) {
search.setUiState(nextUiState);
}, [
search
]);
var setIndexUiState = React.useCallback(function(nextIndexUiState) {
searchIndex.setIndexUiState(nextIndexUiState);
}, [
searchIndex
]);
React.useEffect(function() {
function handleRender() {
setLocalUiState(search.getUiState());
setRenderState(search.renderState);
}
search.addListener('render', handleRender);
// Force setting state to mitigate potential race conditions where
// render listener is added after search results have been returned.
// This edge case is currently not covered by the tests.
handleRender();
return function() {
search.removeListener('render', handleRender);
};
}, [
search
]);
return {
uiState: uiState,
setUiState: setUiState,
indexUiState: indexUiState,
setIndexUiState: setIndexUiState,
renderState: renderState,
indexRenderState: indexRenderState
};
}
function useInstantSearch() {
var catchError = (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}).catchError;
var search = useInstantSearchContext();
var _useSearchState = useSearchState(), uiState = _useSearchState.uiState, setUiState = _useSearchState.setUiState, indexUiState = _useSearchState.indexUiState, setIndexUiState = _useSearchState.setIndexUiState, renderState = _useSearchState.renderState, indexRenderState = _useSearchState.indexRenderState;
var _useSearchResults = useSearchResults(), results = _useSearchResults.results, scopedResults = _useSearchResults.scopedResults;
var addMiddlewares = React.useCallback(function() {
for(var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++){
middlewares[_key] = arguments[_key];
}
var _search;
(_search = search).use.apply(_search, _to_consumable_array(middlewares));
return function() {
var _search;
(_search = search).unuse.apply(_search, _to_consumable_array(middlewares));
};
}, [
search
]);
var refresh = React.useCallback(function() {
search.refresh();
}, [
search
]);
useIsomorphicLayoutEffect(function() {
if (catchError) {
var onError = function onError() {};
search.addListener('error', onError);
return function() {
return search.removeListener('error', onError);
};
}
return function() {};
}, [
search,
catchError
]);
return {
results: results,
scopedResults: scopedResults,
uiState: uiState,
setUiState: setUiState,
indexUiState: indexUiState,
setIndexUiState: setIndexUiState,
renderState: renderState,
indexRenderState: indexRenderState,
addMiddlewares: addMiddlewares,
refresh: refresh,
status: search.status,
error: search.error
};
}
// This is needed in order to work with RSC Suspense, perhaps they will later provide a wrapper.
function isStatefulPromise(promise) {
return 'status' in promise;
}
function wrapPromiseWithState(promise) {
if (isStatefulPromise(promise)) {
return promise;
}
var pendingPromise = promise;
pendingPromise.status = 'pending';
pendingPromise.then(function(value) {
if (pendingPromise.status === 'pending') {
var fulfilledPromise = pendingPromise;
fulfilledPromise.status = 'fulfilled';
fulfilledPromise.value = value;
}
}, function(reason) {
if (pendingPromise.status === 'pending') {
var rejectedPromise = pendingPromise;
rejectedPromise.status = 'rejected';
rejectedPromise.reason = reason;
}
});
return promise;
}
/**
* Waits for the results from the search instance to coordinate the next steps
* in `getServerState()`.
*/ function waitForResults(search) {
var skipRecommend = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
var helper = search.mainHelper;
// Extract search parameters from the search client to use them
// later during hydration.
var requestParamsList;
var client = helper.getClient();
var waitsForSearch = search._hasSearchWidget;
var waitsForRecommend = !skipRecommend && search._hasRecommendWidget;
if (search.compositionID) {
helper.setClient(_object_spread_props(_object_spread({}, client), {
search: function search(query) {
requestParamsList = [
query.requestBody.params
];
return client.search(query);
}
}));
} else {
helper.setClient(_object_spread_props(_object_spread({}, client), {
search: function search(queries) {
requestParamsList = queries.map(function(param) {
var params = param.params;
return params;
});
return client.search(queries);
}
}));
}
if (waitsForSearch) {
if (search.compositionID) {
helper.searchWithComposition();
} else {
helper.searchOnlyWithDerivedHelpers();
}
}
if (waitsForRecommend) {
helper.recommend();
}
if (!waitsForSearch && !waitsForRecommend) {
return Promise.resolve([]);
}
return new Promise(function(resolve, reject) {
var searchResultsReceived = !waitsForSearch;
var recommendResultsReceived = !waitsForRecommend;
// All derived helpers resolve in the same tick so we're safe only relying
// on the first one.
helper.derivedHelpers[0].on('result', function() {
searchResultsReceived = true;
if (recommendResultsReceived) {
resolve(requestParamsList);
}
});
helper.derivedHelpers[0].on('recommend:result', function() {
recommendResultsReceived = true;
if (searchResultsReceived) {
resolve(requestParamsList);
}
});
// However, we listen to errors that can happen on any derived helper because
// any error is critical.
helper.on('error', function(error) {
reject(error);
});
search.on('error', function(error) {
reject(error);
});
helper.derivedHelpers.forEach(function(derivedHelper) {
return derivedHelper.on('error', function(error) {
reject(error);
});
});
});
}
/**
* Walks the InstantSearch root index to construct the initial results.
*/ function getInitialResults(rootIndex, /**
* Search parameters sent to the search client,
* returned by `waitForResults()`.
*/ requestParamsList) {
var initialResults = {};
var requestParamsIndex = 0;
walkIndex(rootIndex, function(widget) {
var _widget_getHelper;
var currentIndex = widget;
while(currentIndex){
if (currentIndex._isolated) {
return;
}
currentIndex = currentIndex.getParent();
}
var searchResults = widget.getResults();
var recommendResults = (_widget_getHelper = widget.getHelper()) === null || _widget_getHelper === void 0 ? void 0 : _widget_getHelper.lastRecommendResults;
if (searchResults || recommendResults) {
var _searchResults__rawResults, _requestParams_, _requestParams_1;
var resultsCount = (searchResults === null || searchResults === void 0 ? void 0 : (_searchResults__rawResults = searchResults._rawResults) === null || _searchResults__rawResults === void 0 ? void 0 : _searchResults__rawResults.length) || 0;
var requestParams = resultsCount ? requestParamsList === null || requestParamsList === void 0 ? void 0 : requestParamsList.slice(requestParamsIndex, requestParamsIndex + resultsCount) : [];
requestParamsIndex += resultsCount;
initialResults[widget.getIndexId()] = _object_spread({}, searchResults && _object_spread({
state: _object_spread_props(_object_spread({}, searchResults._state), {
clickAnalytics: requestParams === null || requestParams === void 0 ? void 0 : (_requestParams_ = requestParams[0]) === null || _requestParams_ === void 0 ? void 0 : _requestParams_.clickAnalytics,
userToken: requestParams === null || requestParams === void 0 ? void 0 : (_requestParams_1 = requestParams[0]) === null || _requestParams_1 === void 0 ? void 0 : _requestParams_1.userToken
}),
results: searchResults._rawResults
}, searchResults.feeds && searchResults.feeds.length > 0 && {
compositionFeedsResults: searchResults.feeds.map(function(feed) {
return _object_spread_props(_object_spread({}, feed._rawResults[0]), {
feedID: feed.feedID
});
})
}), recommendResults && {
recommendResults: {
// We have to stringify + parse because of some explicitly undefined values.
params: JSON.parse(JSON.stringify(recommendResults._state.params)),
results: recommendResults._rawResults
}
}, requestParams && {
requestParams: requestParams
});
}
});
if (Object.keys(initialResults).length === 0 && (requestParamsList === null || requestParamsList === void 0 ? void 0 : requestParamsList.length) !== 0) {
throw new Error('The root index does not have any results. Make sure you have at least one widget that provides results.');
}
return initialResults;
}
/**
* Returns the InstantSearch server state from a component.
*/ function getServerState(children, param) {
var renderToString = param.renderToString;
var searchRef = {
current: undefined
};
resetWidgetId();
var createNotifyServer = function createNotifyServer() {
var hasBeenNotified = false;
var notifyServer = function notifyServer(param) {
var search = param.search;
if (hasBeenNotified) {
throw new Error('getServerState should be called with a single InstantSearchSSRProvider and a single InstantSearch component.');
}
hasBeenNotified = true;
searchRef.current = search;
};
return notifyServer;
};
return execute({
children: children,
renderToString: renderToString,
searchRef: searchRef,
notifyServer: createNotifyServer()
}).then(function(serverState) {
var shouldRefetch = false;
// Two-pass widgets require another query to discover and mount child widgets.
walkIndex(searchRef.current.mainIndex, function(index) {
var current = index;
while(current){
if (current._isolated) {
return;
}
current = current.getParent();
}
shouldRefetch = shouldRefetch || index.getWidgets().some(isTwoPassWidget);
});
if (shouldRefetch) {
resetWidgetId();
return execute({
children: /*#__PURE__*/ React.createElement(InstantSearchSSRProvider, serverState, children),
renderToString: renderToString,
searchRef: searchRef,
notifyServer: createNotifyServer(),
skipRecommend: true
});
}
return serverState;
});
}
function execute(param) {
var children = param.children, renderToString = param.renderToString, notifyServer = param.notifyServer, searchRef = param.searchRef, skipRecommend = param.skipRecommend;
return Promise.resolve().then(function() {
renderToString(/*#__PURE__*/ React.createElement(InstantSearchServerContext.Provider, {
value: {
notifyServer: notifyServer
}
}, children));
}).then(function() {
return new Promise(function(resolve) {
return setTimeout(resolve, 0);
});
}).then(function() {
// If `notifyServer()` is not called by then, it means that <InstantSearch>
// wasn't within the `children`.
// We decide to go with a strict behavior in that case; throwing. If users have
// some routes that don't mount the <InstantSearch> component, they would need
// to try/catch the `getServerState()` call.
// If this behavior turns out to be too strict for many users, we can decide
// to warn instead of throwing.
if (!searchRef.current) {
throw new Error("Unable to retrieve InstantSearch's server state in `getServerState()`. Did you mount the <InstantSearch> component?");
}
return waitForResults(searchRef.current, skipRecommend);
}).then(function(requestParamsList) {
return {
initialResults: getInitialResults(searchRef.current.mainIndex, requestParamsList)
};
});
}
var AutocompleteSearchComponent = createAutocompleteSearchComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
function AutocompleteSearch(param) {
var inputProps = param.inputProps, clearQuery = param.clearQuery, onQueryChange = param.onQueryChange, query = param.query, isSearchStalled = param.isSearchStalled, onCancel = param.onCancel, isDetached = param.isDetached, submitTitle = param.submitTitle, onAiModeClick = param.onAiModeClick, aiModeButtonDisabled = param.aiModeButtonDisabled, classNames = param.classNames;
return /*#__PURE__*/ React.createElement(AutocompleteSearchComponent, {
inputProps: _object_spread_props(_object_spread({}, inputProps), {
onChange: function onChange(event) {
var value = event.currentTarget.value;
onQueryChange === null || onQueryChange === void 0 ? void 0 : onQueryChange(value);
}
}),
onClear: clearQuery,
query: query,
isSearchStalled: isSearchStalled,
onCancel: onCancel,
isDetached: isDetached,
submitTitle: submitTitle,
onAiModeClick: onAiModeClick,
aiModeButtonDisabled: aiModeButtonDisabled,
classNames: classNames
});
}
var InternalHighlight = createHighlightComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
function Highlight$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, props = _object_without_properties(_0, [
"classNames"
]);
return /*#__PURE__*/ React.createElement(InternalHighlight, _object_spread({
classNames: {
root: cx('ais-Highlight', classNames.root),
highlighted: cx('ais-Highlight-highlighted', classNames.highlighted),
nonHighlighted: cx('ais-Highlight-nonHighlighted', classNames.nonHighlighted),
separator: cx('ais-Highlight-separator', classNames.separator)
}
}, props));
}
function Highlight(_0) {
var hit = _0.hit, attribute = _0.attribute, highlightedTagName = _0.highlightedTagName, nonHighlightedTagName = _0.nonHighlightedTagName, separator = _0.separator, props = _object_without_properties(_0, [
"hit",
"attribute",
"highlightedTagName",
"nonHighlightedTagName",
"separator"
]);
var property = getPropertyByPath(hit._highlightResult, attribute) || [];
var properties = Array.isArray(property) ? property : [
property
];
var parts = properties.map(function(singleValue) {
return getHighlightedParts(unescape$1(singleValue.value || ''));
});
return /*#__PURE__*/ React.createElement(Highlight$1, _object_spread_props(_object_spread({}, props), {
parts: parts,
highlightedTagName: highlightedTagName,
nonHighlightedTagName: nonHighlightedTagName,
separator: separator
}));
}
function ReverseHighlight$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, props = _object_without_properties(_0, [
"classNames"
]);
return /*#__PURE__*/ React.createElement(InternalHighlight, _object_spread({
classNames: {
root: cx('ais-ReverseHighlight', classNames.root),
highlighted: cx('ais-ReverseHighlight-highlighted', classNames.highlighted),
nonHighlighted: cx('ais-ReverseHighlight-nonHighlighted', classNames.nonHighlighted),
separator: cx('ais-ReverseHighlight-separator', classNames.separator)
}
}, props));
}
function ReverseHighlight(_0) {
var hit = _0.hit, attribute = _0.attribute, highlightedTagName = _0.highlightedTagName, nonHighlightedTagName = _0.nonHighlightedTagName, separator = _0.separator, props = _object_without_properties(_0, [
"hit",
"attribute",
"highlightedTagName",
"nonHighlightedTagName",
"separator"
]);
var property = getPropertyByPath(hit._highlightResult, attribute) || [];
var properties = Array.isArray(property) ? property : [
property
];
var parts = properties.map(function(singleValue) {
return getHighlightedParts(unescape$1(singleValue.value || '')).map(function(_0) {
var isHighlighted = _0.isHighlighted, rest = _object_without_properties(_0, [
"isHighlighted"
]);
return _object_spread_props(_object_spread({}, rest), {
isHighlighted: !isHighlighted
});
});
});
return /*#__PURE__*/ React.createElement(ReverseHighlight$1, _object_spread_props(_object_spread({}, props), {
parts: parts,
highlightedTagName: highlightedTagName,
nonHighlightedTagName: nonHighlightedTagName,
separator: separator
}));
}
var AutocompleteUiComponent = createAutocompleteComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var AutocompletePanel = createAutocompletePanelComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var AutocompleteIndex = createAutocompleteIndexComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var AutocompleteSuggestion = createAutocompleteSuggestionComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var AutocompletePromptSuggestion = createAutocompletePromptSuggestionComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var AutocompleteRecentSearch = createAutocompleteRecentSearchComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var AutocompleteDetachedContainer = createAutocompleteDetachedContainerComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var AutocompleteDetachedOverlay = createAutocompleteDetachedOverlayComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var AutocompleteDetachedFormContainer = createAutocompleteDetachedFormContainerComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var AutocompleteDetachedSearchButton = createAutocompleteDetachedSearchButtonComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var id = 0;
// Colons (`:r0:`) preserved so concatenations like `autocomplete:r0:input`
// have a recognisable boundary; callers that need a colon-free variant for
// InstantSearch's `indexId` strip them at the use site.
var useAutocompleteId = React.useId ? function() {
return React.useId();
} : function() {
return React.useState(function() {
return ":a".concat(id++, ":");
})[0];
};
var usePropGetters = createAutocompletePropGetters({
useEffect: React.useEffect,
useId: React.useId || function() {
return React.useState(function() {
return (id++).toString();
});
},
useMemo: React.useMemo,
useRef: React.useRef,
useState: React.useState
});
var useStorage = createAutocompleteStorage({
useEffect: React.useEffect,
useMemo: React.useMemo,
useState: React.useState
});
var DEFAULT_DETACHED_MEDIA_QUERY = '(max-width: 680px)';
var DEFAULT_DETACHED_MODAL_MEDIA_QUERY = '(min-width: 680px)';
var DETACHED_MEDIA_QUERY_CSS_VAR = '--ais-autocomplete-detached-media-query';
var DETACHED_MODAL_MEDIA_QUERY_CSS_VAR = '--ais-autocomplete-detached-modal-media-query';
var DEFAULT_TRANSLATIONS = {
detachedCancelButtonText: 'Cancel',
detachedSearchButtonTitle: 'Search',
detachedClearButtonTitle: 'Clear'
};
function getCssMediaQueryValue(name) {
if (typeof window === 'undefined' || typeof document === 'undefined') {
return '';
}
return getComputedStyle(document.documentElement).getPropertyValue(name).trim();
}
function resolveMediaQuery(value, cssVarName, fallback) {
if (value === '') {
return '';
}
if (value) {
return value;
}
return getCssMediaQueryValue(cssVarName) || fallback;
}
function getMediaQueryList(mediaQuery) {
if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') {
return null;
}
return window.matchMedia(mediaQuery);
}
/**
* Hook to manage detached (mobile) mode state
*/ function useDetachedMode(mediaQuery) {
var resolvedMediaQuery = React.useMemo(function() {
return resolveMediaQuery(mediaQuery, DETACHED_MEDIA_QUERY_CSS_VAR, DEFAULT_DETACHED_MEDIA_QUERY);
}, [
mediaQuery
]);
var _useState = _sliced_to_array(React.useState(function() {
var _getMediaQueryList;
return resolvedMediaQuery ? Boolean((_getMediaQueryList = getMediaQueryList(resolvedMediaQuery)) === null || _getMediaQueryList === void 0 ? void 0 : _getMediaQueryList.matches) : false;
}), 2), isDetached = _useState[0], setIsDetached = _useState[1];
var _useState1 = _sliced_to_array(React.useState(false), 2), isModalOpen = _useState1[0], setIsModalOpen = _useState1[1];
var _useState2 = _sliced_to_array(React.useState(false), 2), isModalDetached = _useState2[0], setIsModalDetached = _useState2[1];
React.useEffect(function() {
if (!resolvedMediaQuery) {
setIsDetached(false);
return function() {};
}
var mql = getMediaQueryList(resolvedMediaQuery);
if (!mql) {
setIsDetached(false);
return function() {};
}
var handler = function handler(event) {
var wasDetached = isDetached;
setIsDetached(event.matches);
// Close modal if switching from detached to non-detached
if (wasDetached && !event.matches) {
setIsModalOpen(false);
}
};
mql.addEventListener('change', handler);
return function() {
return mql.removeEventListener('change', handler);
};
}, [
resolvedMediaQuery,
isDetached
]);
React.useEffect(function() {
if (!isDetached) {
setIsModalDetached(false);
return function() {};
}
var modalMediaQuery = resolveMediaQuery(undefined, DETACHED_MODAL_MEDIA_QUERY_CSS_VAR, DEFAULT_DETACHED_MODAL_MEDIA_QUERY);
if (!modalMediaQuery) {
setIsModalDetached(false);
return function() {};
}
var mql = getMediaQueryList(modalMediaQuery);
if (!mql) {
setIsModalDetached(false);
return function() {};
}
var handler = function handler(event) {
setIsModalDetached(event.matches);
};
setIsModalDetached(mql.matches);
mql.addEventListener('change', handler);
return function() {
return mql.removeEventListener('change', handler);
};
}, [
isDetached
]);
React.useEffect(function() {
if (typeof document === 'undefined') return function() {};
if (isModalOpen) {
var scrollY = window.scrollY;
document.body.style.top = "-".concat(scrollY, "px");
document.body.classList.add('ais-Autocomplete--detached');
return function() {
document.body.classList.remove('ais-Autocomplete--detached');
document.body.style.top = '';
window.scrollTo(0, scrollY);
};
}
return function() {};
}, [
isModalOpen
]);
return {
isDetached: isDetached,
isModalDetached: isModalDetached,
isModalOpen: isModalOpen,
setIsModalOpen: setIsModalOpen
};
}
function Autocomplete(props) {
var _showRecent_classNames, _showRecent_classNames1, _showRecent_classNames2, _showRecent_classNames3;
var indices = 'indices' in props ? props.indices : undefined;
var feeds = 'feeds' in props ? props.feeds : undefined;
var isFeedsMode = feeds !== undefined;
var showQuerySuggestions = props.showQuerySuggestions, showPromptSuggestions = props.showPromptSuggestions, showRecent = props.showRecent, userSearchParameters = props.searchParameters, detachedMediaQuery = props.detachedMediaQuery, tmp = props.translations, userTranslations = tmp === void 0 ? {} : tmp, transformItems = props.transformItems, _props_requiresSearch = props.requiresSearch, requiresSearch = _props_requiresSearch === void 0 ? true : _props_requiresSearch, restProps = _object_without_properties(props, [
"showQuerySuggestions",
"showPromptSuggestions",
"showRecent",
"searchParameters",
"detachedMediaQuery",
"translations",
"transformItems",
"requiresSearch"
]);
var autoFocus = restProps.autoFocus, placeholder = restProps.placeholder, classNames = restProps.classNames;
// Eager-mount only when `autoFocus` is set — otherwise wait for first focus
// before registering the autocomplete subtree in the search graph.
var _useState = _sliced_to_array(React.useState(autoFocus === true), 2), activated = _useState[0], setActivated = _useState[1];
var translations = _object_spread({}, DEFAULT_TRANSLATIONS, userTranslations);
var _useInstantSearch = useInstantSearch(), indexUiState = _useInstantSearch.indexUiState, indexRenderState = _useInstantSearch.indexRenderState, status = _useInstantSearch.status;
var compositionID = useInstantSearchContext().compositionID;
var dependsOn = requiresSearch ? 'search' : 'none';
var refine = useSearchBox({}, _object_spread({
$$type: 'ais.autocomplete',
$$widgetType: 'ais.autocomplete',
dependsOn: dependsOn
}, props.aiMode ? {
opensChat: true
} : {})).refine;
var domId = useAutocompleteId();
var instanceKey = domId.replace(/:/g, '');
if (isFeedsMode && indices !== undefined) {
throw new Error('Autocomplete: `feeds` and `indices` are mutually exclusive.');
}
if (isFeedsMode && !compositionID) {
throw new Error('Autocomplete in feeds-mode requires a composition-based <InstantSearch> (compositionID must be set).');
}
var isSearchStalled = status === 'stalled';
var searchParameters = _object_spread({
hitsPerPage: 5
}, userSearchParameters);
// In feeds-mode `indexName` carries the feedID so downstream matching
// (section building, dedupe in createAutocompleteStorage) treats feeds
// like indices without any changes to InnerAutocomplete.
var querySuggestionsKey = isFeedsMode ? showQuerySuggestions === null || showQuerySuggestions === void 0 ? void 0 : showQuerySuggestions.feedID : showQuerySuggestions === null || showQuerySuggestions === void 0 ? void 0 : showQuerySuggestions.indexName;
var promptSuggestionsKey = isFeedsMode ? showPromptSuggestions === null || showPromptSuggestions === void 0 ? void 0 : showPromptSuggestions.feedID : showPromptSuggestions === null || showPromptSuggestions === void 0 ? void 0 : showPromptSuggestions.indexName;
var indicesConfig = React.useMemo(function() {
var config = isFeedsMode ? feeds.map(function(feed) {
return {
indexName: feed.feedID,
headerComponent: feed.headerComponent,
itemComponent: feed.itemComponent,
noResultsComponent: feed.noResultsComponent,
getURL: feed.getURL,
getQuery: feed.getQuery,
classNames: feed.classNames
};
}) : _to_consumable_array(indices !== null && indices !== void 0 ? indices : []);
if (querySuggestionsKey) {
var _showQuerySuggestions_classNames, _showQuerySuggestions_classNames1, _showQuerySuggestions_classNames2, _showQuerySuggestions_classNames3;
var querySuggestionsSearchParameters = isFeedsMode ? undefined : _object_spread({
hitsPerPage: 3
}, showQuerySuggestions.searchParameters);
config.unshift({
indexName: querySuggestionsKey,
headerComponent: showQuerySuggestions.headerComponent,
itemComponent: showQuerySuggestions.itemComponent || function(param) {
var item = param.item, onSelect = param.onSelect, onApply = param.onApply;
return /*#__PURE__*/ React.createElement(AutocompleteSuggestion, {
item: item,
onSelect: onSelect,
onApply: onApply
}, /*#__PURE__*/ React.createElement(ConditionalReverseHighlight, {
item: item
}));
},
classNames: {
root: cx('ais-AutocompleteSuggestions', showQuerySuggestions === null || showQuerySuggestions === void 0 ? void 0 : (_showQuerySuggestions_classNames = showQuerySuggestions.classNames) === null || _showQuerySuggestions_classNames === void 0 ? void 0 : _showQuerySuggestions_classNames.root),
list: cx('ais-AutocompleteSuggestionsList', showQuerySuggestions === null || showQuerySuggestions === void 0 ? void 0 : (_showQuerySuggestions_classNames1 = showQuerySuggestions.classNames) === null || _showQuerySuggestions_classNames1 === void 0 ? void 0 : _showQuerySuggestions_classNames1.list),
header: cx('ais-AutocompleteSuggestionsHeader', showQuerySuggestions === null || showQuerySuggestions === void 0 ? void 0 : (_showQuerySuggestions_classNames2 = showQuerySuggestions.classNames) === null || _showQuerySuggestions_classNames2 === void 0 ? void 0 : _showQuerySuggestions_classNames2.header),
item: cx('ais-AutocompleteSuggestionsItem', showQuerySuggestions === null || showQuerySuggestions === void 0 ? void 0 : (_showQuerySuggestions_classNames3 = showQuerySuggestions.classNames) === null || _showQuerySuggestions_classNames3 === void 0 ? void 0 : _showQuerySuggestions_classNames3.item)
},
searchParameters: querySuggestionsSearchParameters,
getQuery: function getQuery(item) {
return item.query;
},
getURL: showQuerySuggestions.getURL
});
}
if (promptSuggestionsKey) {
var _showPromptSuggestions_classNames, _showPromptSuggestions_classNames1, _showPromptSuggestions_classNames2, _showPromptSuggestions_classNames3;
var promptSuggestionsSearchParameters = isFeedsMode ? undefined : _object_spread({
hitsPerPage: 3
}, showPromptSuggestions.searchParameters);
config.push({
indexName: promptSuggestionsKey,
headerComponent: showPromptSuggestions.headerComponent,
itemComponent: showPromptSuggestions.itemComponent || function(param) {
var item = param.item, onSelect = param.onSelect;
return /*#__PURE__*/ React.createElement(AutocompletePromptSuggestion, {
item: item,
onSelect: onSelect
}, /*#__PURE__*/ React.createElement(ConditionalHighlight, {
item: item,
attribute: "prompt"
}));
},
classNames: {
root: cx('ais-AutocompletePromptSuggestions', showPromptSuggestions === null || showPromptSuggestions === void 0 ? void 0 : (_showPromptSuggestions_classNames = showPromptSuggestions.classNames) === null || _showPromptSuggestions_classNames === void 0 ? void 0 : _showPromptSuggestions_classNames.root),
list: cx('ais-AutocompletePromptSuggestionsList', showPromptSuggestions === null || showPromptSuggestions === void 0 ? void 0 : (_showPromptSuggestions_classNames1 = showPromptSuggestions.classNames) === null || _showPromptSuggestions_classNames1 === void 0 ? void 0 : _showPromptSuggestions_classNames1.list),
header: cx('ais-AutocompletePromptSuggestionsHeader', showPromptSuggestions === null || showPromptSuggestions === void 0 ? void 0 : (_showPromptSuggestions_classNames2 = showPromptSuggestions.classNames) === null || _showPromptSuggestions_classNames2 === void 0 ? void 0 : _showPromptSuggestions_classNames2.header),
item: cx('ais-AutocompletePromptSuggestionsItem', showPromptSuggestions === null || showPromptSuggestions === void 0 ? void 0 : (_showPromptSuggestions_classNames3 = showPromptSuggestions.classNames) === null || _showPromptSuggestions_classNames3 === void 0 ? void 0 : _showPromptSuggestions_classNames3.item)
},
searchParameters: promptSuggestionsSearchParameters,
getQuery: function getQuery(item) {
return item.prompt;
},
getURL: showPromptSuggestions.getURL
});
}
return config;
}, [
feeds,
indices,
isFeedsMode,
promptSuggestionsKey,
querySuggestionsKey,
showPromptSuggestions,
showQuerySuggestions
]);
// Normalize `show*` for InnerAutocomplete: always surface `indexName`
// (in feeds-mode it carries the feedID). Keeps downstream dedupe in
// createAutocompleteStorage (suggestionsIndexName === index.indexName) working.
var normalizedShowQuerySuggestions = React.useMemo(function() {
if (!showQuerySuggestions) {
return undefined;
}
if (isFeedsMode) {
return _object_spread_props(_object_spread({}, showQuerySuggestions), {
indexName: querySuggestionsKey
});
}
return showQuerySuggestions;
}, [
isFeedsMode,
querySuggestionsKey,
showQuerySuggestions
]);
var normalizedShowPromptSuggestions = React.useMemo(function() {
if (!showPromptSuggestions) {
return undefined;
}
if (isFeedsMode) {
return _object_spread_props(_object_spread({}, showPromptSuggestions), {
indexName: promptSuggestionsKey
});
}
return showPromptSuggestions;
}, [
isFeedsMode,
promptSuggestionsKey,
showPromptSuggestions
]);
// In feeds-mode, remap `indexName := indexId` so downstream storage (which
// matches on indexName) sees feedIDs instead of the composition index name
// that connectAutocomplete sets from the helper results.
// Must be memoized: useConnector's useStableValue runs dequal on each render
// and treats a new function identity as a change, re-registering the widget.
var effectiveTransformItems = React.useMemo(function() {
return isFeedsMode ? function(items) {
var remapped = items.map(function(item) {
return _object_spread_props(_object_spread({}, item), {
indexName: item.indexId
});
});
return transformItems ? transformItems(remapped) : remapped;
} : transformItems;
}, [
isFeedsMode,
transformItems
]);
var recentSearchConfig = showRecent ? {
headerComponent: (typeof showRecent === "undefined" ? "undefined" : _type_of(showRecent)) === 'object' ? showRecent.headerComponent : undefined,
itemComponent: (typeof showRecent === "undefined" ? "undefined" : _type_of(showRecent)) === 'object' && showRecent.itemComponent ? showRecent.itemComponent : AutocompleteRecentSearch,
classNames: {
root: cx('ais-AutocompleteRecentSearches', (typeof showRecent === "undefined" ? "undefined" : _type_of(showRecent)) === 'object' ? (_showRecent_classNames = showRecent.classNames) === null || _showRecent_classNames === void 0 ? void 0 : _showRecent_classNames.root : undefined),
list: cx('ais-AutocompleteRecentSearchesList', (typeof showRecent === "undefined" ? "undefined" : _type_of(showRecent)) === 'object' ? (_showRecent_classNames1 = showRecent.classNames) === null || _showRecent_classNames1 === void 0 ? void 0 : _showRecent_classNames1.list : undefined),
header: cx('ais-AutocompleteRecentSearchesHeader', (typeof showRecent === "undefined" ? "undefined" : _type_of(showRecent)) === 'object' ? (_showRecent_classNames2 = showRecent.classNames) === null || _showRecent_classNames2 === void 0 ? void 0 : _showRecent_classNames2.header : undefined),
item: cx('ais-AutocompleteRecentSearchesItem', (typeof showRecent === "undefined" ? "undefined" : _type_of(showRecent)) === 'object' ? (_showRecent_classNames3 = showRecent.classNames) === null || _showRecent_classNames3 === void 0 ? void 0 : _showRecent_classNames3.item : undefined)
}
} : undefined;
var isSearchPage = React.useMemo(function() {
return typeof indexRenderState.hits !== 'undefined' || typeof indexRenderState.infiniteHits !== 'undefined';
}, [
indexRenderState
]);
restProps.indices; restProps.feeds; var forwardedProps = _object_without_properties(restProps, [
"indices",
"feeds"
]);
var instance = useInstantSearchContext();
var detached = useDetachedMode(detachedMediaQuery);
var isDetached = detached.isDetached, setIsModalOpen = detached.setIsModalOpen;
// Lazy activation only: when `activated` flips from false to true, the
// newly-mounted isolated `<Index>` schedules the parent's search even
// though the parent's state hasn't changed. Cancel it so only the
// autocomplete's own search fires on activation. Skip when `autoFocus`
// mounts the inner eagerly — the parent's legitimate initial search
// shares the same defer slot and must not be cancelled.
var initialActivatedRef = React.useRef(activated);
React.useLayoutEffect(function() {
if (activated && !initialActivatedRef.current) {
initialActivatedRef.current = true;
instance.scheduleSearch.cancel();
}
}, [
activated,
instance
]);
if (!activated) {
var _indexUiState_query, _indexUiState_query1;
restProps.indices; restProps.feeds; restProps.autoFocus; restProps.placeholder; restProps.classNames; restProps.aiMode; restProps.panelComponent; restProps.getSearchPageURL; restProps.onSelect; var shellRootProps = _object_without_properties(restProps, [
"indices",
"feeds",
"autoFocus",
"placeholder",
"classNames",
"aiMode",
"panelComponent",
"getSearchPageURL",
"onSelect"
]);
var activateWithQueryMirror = function activateWithQueryMirror() {
// Routing only fills the parent index's UI state, not the
// autocomplete's isolated one, so without this, the autocomplete
// would activate with an empty query and fire a useless search.
// We copy the parent's query into the autocomplete's slot of
// `_initialUiState` right before flipping `activated`: that's the
// moment the isolated `<Index>` is about to mount and read it.
// Doing this later would mean firing a second search to correct
// the first.
if (indexUiState.query) {
var isoIndexId = "ais-autocomplete-".concat(instanceKey);
var initial = instance._initialUiState;
initial[isoIndexId] = _object_spread_props(_object_spread({}, initial[isoIndexId]), {
query: indexUiState.query
});
}
setActivated(true);
};
return /*#__PURE__*/ React.createElement(AutocompleteUiComponent, _object_spread_props(_object_spread({}, shellRootProps), {
classNames: classNames
}), isDetached ? /*#__PURE__*/ React.createElement(AutocompleteDetachedSearchButton, {
query: (_indexUiState_query = indexUiState.query) !== null && _indexUiState_query !== void 0 ? _indexUiState_query : '',
placeholder: placeholder,
classNames: classNames,
translations: translations,
onClick: function onClick() {
setIsModalOpen(true);
activateWithQueryMirror();
}
}) : /*#__PURE__*/ React.createElement(AutocompleteSearch, {
inputProps: {
id: "autocomplete".concat(domId, "input"),
role: 'combobox',
placeholder: placeholder,
onFocus: activateWithQueryMirror
},
clearQuery: function clearQuery() {},
query: (_indexUiState_query1 = indexUiState.query) !== null && _indexUiState_query1 !== void 0 ? _indexUiState_query1 : '',
isSearchStalled: false,
classNames: classNames
}));
}
var innerAutocomplete = /*#__PURE__*/ React.createElement(InnerAutocomplete, _object_spread_props(_object_spread({}, forwardedProps), {
autoFocus: true,
domId: domId,
detached: detached,
indicesConfig: indicesConfig,
refineSearchBox: refine,
isSearchStalled: isSearchStalled,
indexUiState: indexUiState,
isSearchPage: isSearchPage,
showRecent: showRecent,
recentSearchConfig: recentSearchConfig,
showQuerySuggestions: normalizedShowQuerySuggestions,
translations: translations,
showPromptSuggestions: normalizedShowPromptSuggestions,
transformItems: effectiveTransformItems,
chatRenderState: indexRenderState.chat
}));
if (isFeedsMode) {
return /*#__PURE__*/ React.createElement(Index, {
isolated: true,
indexName: compositionID,
indexId: "ais-autocomplete-".concat(instanceKey)
}, /*#__PURE__*/ React.createElement(Configure, searchParameters), /*#__PURE__*/ React.createElement(Feeds, {
isolated: false,
renderFeed: function renderFeed() {
return null;
}
}), innerAutocomplete);
}
return /*#__PURE__*/ React.createElement(Index, {
isolated: true,
indexId: "ais-autocomplete-".concat(instanceKey)
}, /*#__PURE__*/ React.createElement(Configure, searchParameters), indicesConfig.map(function(index) {
return /*#__PURE__*/ React.createElement(Index, {
key: index.indexName,
indexName: index.indexName,
indexId: "ais-autocomplete-".concat(instanceKey, "-").concat(index.indexName)
}, /*#__PURE__*/ React.createElement(Configure, index.searchParameters));
}), innerAutocomplete);
}
/** @deprecated use Autocomplete instead */ var EXPERIMENTAL_Autocomplete = deprecate(Autocomplete);
function InnerAutocomplete(_0) {
var indicesConfig = _0.indicesConfig, refineSearchBox = _0.refineSearchBox, isSearchStalled = _0.isSearchStalled, getSearchPageURL = _0.getSearchPageURL, userOnSelect = _0.onSelect, indexUiState = _0.indexUiState, isSearchPage = _0.isSearchPage, PanelComponent = _0.panelComponent, showRecent = _0.showRecent, recentSearchConfig = _0.recentSearchConfig, showQuerySuggestions = _0.showQuerySuggestions, showPromptSuggestions = _0.showPromptSuggestions, chatRenderState = _0.chatRenderState, transformItems = _0.transformItems, placeholder = _0.placeholder, autoFocus = _0.autoFocus, translations = _0.translations, classNames = _0.classNames, aiMode = _0.aiMode, domId = _0.domId, detached = _0.detached, props = _object_without_properties(_0, [
"indicesConfig",
"refineSearchBox",
"isSearchStalled",
"getSearchPageURL",
"onSelect",
"indexUiState",
"isSearchPage",
"panelComponent",
"showRecent",
"recentSearchConfig",
"showQuerySuggestions",
"showPromptSuggestions",
"chatRenderState",
"transformItems",
"placeholder",
"autoFocus",
"translations",
"classNames",
"aiMode",
"domId",
"detached"
]);
var _indexUiState_query, _ref;
var _showPromptSuggestions_searchParameters;
var _useAutocomplete = useAutocomplete({
transformItems: transformItems,
future: {
undefinedEmptyQuery: true
}
}), indices = _useAutocomplete.indices, refineAutocomplete = _useAutocomplete.refine, currentRefinement = _useAutocomplete.currentRefinement;
var resolvedQuery = currentRefinement !== undefined ? currentRefinement : (_indexUiState_query = indexUiState.query) !== null && _indexUiState_query !== void 0 ? _indexUiState_query : '';
var isDetached = detached.isDetached, isModalDetached = detached.isModalDetached, isModalOpen = detached.isModalOpen, setIsModalOpen = detached.setIsModalOpen;
var previousIsDetachedRef = React.useRef(isDetached);
var _useStorage = useStorage({
showRecent: showRecent,
query: currentRefinement,
indices: indices,
indicesConfig: indicesConfig,
suggestionsIndexName: showQuerySuggestions === null || showQuerySuggestions === void 0 ? void 0 : showQuerySuggestions.indexName
}), storage = _useStorage.storage, storageHits = _useStorage.storageHits, indicesForPropGetters = _useStorage.indicesForPropGetters, indicesConfigForPropGetters = _useStorage.indicesConfigForPropGetters;
var promptSuggestionsIndexName = showPromptSuggestions === null || showPromptSuggestions === void 0 ? void 0 : showPromptSuggestions.indexName;
var promptSuggestionsLimit = (_ref = showPromptSuggestions === null || showPromptSuggestions === void 0 ? void 0 : (_showPromptSuggestions_searchParameters = showPromptSuggestions.searchParameters) === null || _showPromptSuggestions_searchParameters === void 0 ? void 0 : _showPromptSuggestions_searchParameters.hitsPerPage) !== null && _ref !== void 0 ? _ref : 3;
var indicesForPanel = React.useMemo(function() {
return indices.map(function(index) {
var dedupedHits = index.indexName === (showQuerySuggestions === null || showQuerySuggestions === void 0 ? void 0 : showQuerySuggestions.indexName) && showRecent ? index.hits.filter(function(suggestionHit) {
return !storageHits.find(function(storageHit) {
return storageHit.query === suggestionHit.query;
});
}) : index.hits;
if (index.indexName !== promptSuggestionsIndexName) {
return _object_spread_props(_object_spread({}, index), {
hits: dedupedHits
});
}
return _object_spread_props(_object_spread({}, index), {
hits: getPromptSuggestionHits({
hits: dedupedHits,
limit: promptSuggestionsLimit
})
});
});
}, [
indices,
promptSuggestionsIndexName,
promptSuggestionsLimit,
showRecent,
showQuerySuggestions === null || showQuerySuggestions === void 0 ? void 0 : showQuerySuggestions.indexName,
storageHits
]);
var indicesForPropGettersWithPromptSuggestions = React.useMemo(function() {
return indicesForPropGetters.map(function(index) {
if (index.indexName !== promptSuggestionsIndexName) {
return index;
}
return _object_spread_props(_object_spread({}, index), {
hits: getPromptSuggestionHits({
hits: index.hits,
limit: promptSuggestionsLimit
})
});
});
}, [
indicesForPropGetters,
promptSuggestionsIndexName,
promptSuggestionsLimit
]);
var hasWarnedMissingPromptSuggestionsChatRef = React.useRef(false);
var allIndicesEmpty = indicesForPanel.every(function(param) {
var hits = param.hits;
return hits.length === 0;
});
var recentEmpty = !storageHits || storageHits.length === 0;
var hasNoResultsTemplate = indicesConfig.some(function(c) {
return c.noResultsComponent !== undefined;
});
var shouldHideEmptyPanel = allIndicesEmpty && recentEmpty && !hasNoResultsTemplate && !PanelComponent;
var _usePropGetters = usePropGetters({
id: domId,
indices: indicesForPropGettersWithPromptSuggestions,
indicesConfig: indicesConfigForPropGetters,
onRefine: function onRefine(query) {
refineAutocomplete(query);
refineSearchBox(query);
storage.onAdd(query);
},
onApply: function onApply(query) {
refineAutocomplete(query);
},
onSelect: userOnSelect !== null && userOnSelect !== void 0 ? userOnSelect : function(param) {
var item = param.item, query = param.query, setQuery = param.setQuery, url = param.url;
if (isPromptSuggestion(item)) {
if (chatRenderState) {
if (openChat(chatRenderState, {
message: item.prompt,
referer: 'prompt-suggestions-autocomplete'
})) {
setQuery('');
}
return;
}
if ((showPromptSuggestions === null || showPromptSuggestions === void 0 ? void 0 : showPromptSuggestions.indexName) && !hasWarnedMissingPromptSuggestionsChatRef.current) {
hasWarnedMissingPromptSuggestionsChatRef.current = true;
{ warn('showPromptSuggestions requires a Chat widget in the same index to open chat and send messages. Add <Chat /> to enable this behavior.'); }
}
}
if (url) {
window.location.href = url;
return;
}
if (!isSearchPage && typeof getSearchPageURL !== 'undefined') {
window.location.href = getSearchPageURL(_object_spread_props(_object_spread({}, indexUiState), {
query: query
}));
return;
}
setQuery(query);
},
onSubmit: function onSubmit() {
// Close the detached modal when form is submitted
if (isDetached) {
setIsModalOpen(false);
}
},
placeholder: placeholder,
isDetached: isDetached,
shouldHidePanel: shouldHideEmptyPanel,
autoFocus: autoFocus
}), getInputProps = _usePropGetters.getInputProps, getItemProps = _usePropGetters.getItemProps, getPanelProps = _usePropGetters.getPanelProps, getRootProps = _usePropGetters.getRootProps, isOpen = _usePropGetters.isOpen, setIsOpen = _usePropGetters.setIsOpen, focusInput = _usePropGetters.focusInput;
// Open panel and focus input when modal opens
React.useEffect(function() {
if (isDetached && isModalOpen) {
setIsOpen(true);
// Focus input to show the keyboard on mobile
focusInput();
}
}, [
isDetached,
isModalOpen,
setIsOpen,
focusInput
]);
// Keep the modal open if the panel was open before switching to detached
React.useEffect(function() {
var wasDetached = previousIsDetachedRef.current;
var switchedToDetached = !wasDetached && isDetached;
if (switchedToDetached && isOpen) {
setIsModalOpen(true);
}
previousIsDetachedRef.current = isDetached;
}, [
isDetached,
isOpen,
setIsModalOpen
]);
var elements = {};
if (showRecent && recentSearchConfig) {
var RecentSearchItemComponent = recentSearchConfig.itemComponent;
elements.recent = /*#__PURE__*/ React.createElement(AutocompleteIndex, {
HeaderComponent: recentSearchConfig.headerComponent,
// @ts-ignore - there seems to be problems with React.ComponentType and this, but it's actually correct
ItemComponent: function ItemComponent(param) {
var item = param.item, onSelect = param.onSelect, onApply = param.onApply;
return /*#__PURE__*/ React.createElement(RecentSearchItemComponent, {
item: item,
onSelect: onSelect,
onRemoveRecentSearch: function onRemoveRecentSearch() {
return storage.onRemove(item.query);
},
onApply: onApply
}, /*#__PURE__*/ React.createElement(ConditionalReverseHighlight, {
item: item
}));
},
classNames: recentSearchConfig.classNames,
items: storageHits,
getItemProps: getItemProps,
key: "recentSearches"
});
}
indicesForPanel.forEach(function(param) {
var indexId = param.indexId, indexName = param.indexName, hits = param.hits, sendEvent = param.sendEvent;
var elementId = indexName;
if (indexName === (showQuerySuggestions === null || showQuerySuggestions === void 0 ? void 0 : showQuerySuggestions.indexName)) {
elementId = 'suggestions';
} else if (indexName === (showPromptSuggestions === null || showPromptSuggestions === void 0 ? void 0 : showPromptSuggestions.indexName)) {
elementId = 'promptSuggestions';
}
var currentIndexConfig = indicesConfig.find(function(config) {
return config.indexName === indexName;
});
if (!currentIndexConfig) {
return;
}
elements[elementId] = /*#__PURE__*/ React.createElement(AutocompleteIndex, {
key: indexId,
// @ts-expect-error - there seems to be problems with React.ComponentType and this, but it's actually correct
HeaderComponent: currentIndexConfig.headerComponent,
// @ts-expect-error - there seems to be problems with React.ComponentType and this, but it's actually correct
ItemComponent: currentIndexConfig.itemComponent,
NoResultsComponent: currentIndexConfig.noResultsComponent,
items: hits.map(function(item) {
return _object_spread_props(_object_spread({}, item), {
__indexName: indexName
});
}),
getItemProps: getItemProps,
sendEvent: sendEvent,
classNames: currentIndexConfig.classNames
});
});
var handleCancel = function handleCancel() {
setIsModalOpen(false);
setIsOpen(false);
};
var searchBoxContent = /*#__PURE__*/ React.createElement(AutocompleteSearch, {
inputProps: getInputProps(),
clearQuery: function clearQuery() {
refineSearchBox('');
refineAutocomplete('');
},
onQueryChange: function onQueryChange(query) {
refineAutocomplete(query);
},
query: resolvedQuery,
isSearchStalled: isSearchStalled,
onCancel: function onCancel() {
if (isDetached) {
handleCancel();
}
},
isDetached: isDetached,
submitTitle: isDetached ? translations.detachedCancelButtonText : undefined,
onAiModeClick: aiMode ? function() {
setIsOpen(false);
if (isDetached) {
setIsModalOpen(false);
}
if (openChat(chatRenderState, {
message: resolvedQuery,
referer: 'ai-mode'
})) {
refineSearchBox('');
refineAutocomplete('');
}
} : undefined,
aiModeButtonDisabled: aiMode ? isChatBusy(chatRenderState) : undefined,
classNames: classNames
});
var panelContent = /*#__PURE__*/ React.createElement(AutocompletePanel, _object_spread_props(_object_spread({}, getPanelProps()), {
classNames: {
root: classNames === null || classNames === void 0 ? void 0 : classNames.panel,
open: classNames === null || classNames === void 0 ? void 0 : classNames.panelOpen,
layout: classNames === null || classNames === void 0 ? void 0 : classNames.panelLayout
}
}), PanelComponent ? /*#__PURE__*/ React.createElement(PanelComponent, {
elements: elements,
indices: indicesForPanel
}) : Object.keys(elements).map(function(elementId) {
return elements[elementId];
}));
var detachedContainerClassNames = isModalDetached ? _object_spread_props(_object_spread({}, classNames), {
detachedContainer: cx('ais-AutocompleteDetachedContainer--modal', classNames === null || classNames === void 0 ? void 0 : classNames.detachedContainer)
}) : classNames;
var _getRootProps = getRootProps(), rootRef = _getRootProps.ref, rootProps = _object_without_properties(_getRootProps, [
"ref"
]);
if (isDetached) {
return /*#__PURE__*/ React.createElement(AutocompleteUiComponent, _object_spread_props(_object_spread({}, props, rootProps), {
rootRef: rootRef,
classNames: classNames
}), /*#__PURE__*/ React.createElement(AutocompleteDetachedSearchButton, {
query: resolvedQuery,
placeholder: placeholder,
classNames: classNames,
onClick: function onClick() {
setIsModalOpen(true);
setIsOpen(true);
},
onClear: function onClear() {
refineSearchBox('');
refineAutocomplete('');
},
translations: translations
}), isModalOpen && /*#__PURE__*/ React.createElement(AutocompleteDetachedOverlay, {
classNames: classNames,
onClose: handleCancel
}, /*#__PURE__*/ React.createElement(AutocompleteDetachedContainer, {
classNames: detachedContainerClassNames
}, /*#__PURE__*/ React.createElement(AutocompleteDetachedFormContainer, {
classNames: classNames
}, searchBoxContent), panelContent)));
}
// Normal (non-detached) rendering
return /*#__PURE__*/ React.createElement(AutocompleteUiComponent, _object_spread_props(_object_spread({}, props, rootProps), {
rootRef: rootRef,
classNames: classNames
}), searchBoxContent, panelContent);
}
function ConditionalReverseHighlight(param) {
var item = param.item;
var _item__highlightResult;
if (!((_item__highlightResult = item._highlightResult) === null || _item__highlightResult === void 0 ? void 0 : _item__highlightResult.query) || // @ts-expect-error - we should not have matchLevel as arrays here
item._highlightResult.query.matchLevel === 'none') {
return item.query;
}
return /*#__PURE__*/ React.createElement(ReverseHighlight, {
attribute: "query",
hit: item
});
}
function ConditionalHighlight(param) {
var item = param.item, _param_attribute = param.attribute, attribute = _param_attribute === void 0 ? 'query' : _param_attribute;
var _item__highlightResult;
if (!((_item__highlightResult = item._highlightResult) === null || _item__highlightResult === void 0 ? void 0 : _item__highlightResult[attribute]) || // @ts-expect-error - we should not have matchLevel as arrays here
item._highlightResult[attribute].matchLevel === 'none') {
return /*#__PURE__*/ React.createElement(React.Fragment, null, item[attribute]);
}
return /*#__PURE__*/ React.createElement(Highlight, {
attribute: attribute,
hit: item
});
}
function isModifierClick(event) {
var isMiddleClick = event.button === 1;
return Boolean(isMiddleClick || event.altKey || event.ctrlKey || event.metaKey || event.shiftKey);
}
function Breadcrumb$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, _0_items = _0.items, items = _0_items === void 0 ? [] : _0_items, hasItems = _0.hasItems, createURL = _0.createURL, onNavigate = _0.onNavigate, _0_separator = _0.separator, separator = _0_separator === void 0 ? '>' : _0_separator, translations = _0.translations, props = _object_without_properties(_0, [
"classNames",
"items",
"hasItems",
"createURL",
"onNavigate",
"separator",
"translations"
]);
var handleClick = function handleClick(value) {
return function(event) {
if (!isModifierClick(event)) {
event.preventDefault();
onNavigate(value);
}
};
};
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-Breadcrumb', classNames.root, !hasItems && cx('ais-Breadcrumb--noRefinement', classNames.noRefinementRoot), props.className)
}), /*#__PURE__*/ React.createElement("ul", {
className: cx('ais-Breadcrumb-list', classNames.list)
}, /*#__PURE__*/ React.createElement("li", {
className: cx('ais-Breadcrumb-item', classNames.item, !hasItems && cx('ais-Breadcrumb-item--selected', classNames.selectedItem))
}, /*#__PURE__*/ React.createElement("a", {
href: createURL(null),
onClick: handleClick(null),
className: cx('ais-Breadcrumb-link', classNames.link)
}, translations.rootElementText)), items.map(function(item, index) {
var isLast = index === items.length - 1;
return /*#__PURE__*/ React.createElement("li", {
key: index,
className: cx('ais-Breadcrumb-item', classNames.item, isLast && cx('ais-Breadcrumb-item--selected', classNames.selectedItem))
}, /*#__PURE__*/ React.createElement("span", {
"aria-hidden": "true",
className: cx('ais-Breadcrumb-separator', classNames.separator)
}, separator), isLast ? item.label : /*#__PURE__*/ React.createElement("a", {
className: cx('ais-Breadcrumb-link', classNames.link),
href: createURL(item.value),
onClick: handleClick(item.value)
}, item.label));
})));
}
function Breadcrumb(_0) {
var attributes = _0.attributes, rootPath = _0.rootPath; _0.separator; var transformItems = _0.transformItems, translations = _0.translations, props = _object_without_properties(_0, [
"attributes",
"rootPath",
"separator",
"transformItems",
"translations"
]);
var _useBreadcrumb = useBreadcrumb({
attributes: attributes,
rootPath: rootPath,
transformItems: transformItems
}, {
$$widgetType: 'ais.breadcrumb'
}), canRefine = _useBreadcrumb.canRefine, createURL = _useBreadcrumb.createURL, items = _useBreadcrumb.items, refine = _useBreadcrumb.refine;
var uiProps = {
items: items,
hasItems: canRefine,
createURL: createURL,
onNavigate: refine,
translations: _object_spread({
rootElementText: 'Home'
}, translations)
};
return /*#__PURE__*/ React.createElement(Breadcrumb$1, _object_spread({}, props, uiProps));
}
var containersHeldInert = new WeakSet();
var revealAnimationsHeldByContainer = new WeakMap();
function getContainer(prompt) {
var _ref;
return (_ref = prompt === null || prompt === void 0 ? void 0 : prompt.closest('.ais-Chat-container')) !== null && _ref !== void 0 ? _ref : null;
}
function getActiveContainerAnimations(prompt) {
return getActiveAnimations(getContainer(prompt));
}
function getActiveAnimations(container) {
if (!container || typeof container.getAnimations !== 'function') {
return [];
}
return container.getAnimations().filter(function(animation) {
return animation.playState !== 'finished';
}).map(function(animation) {
return {
animation: animation,
currentTime: animation.currentTime,
playState: animation.playState,
startTime: animation.startTime
};
});
}
var revealProperties = [
'opacity',
'transform',
'translate',
'scale',
'rotate',
'visibility',
'clip',
'clipPath'
];
function isRevealed(style, property) {
if (property === 'opacity') {
return style.opacity === '1';
}
if (property === 'transform') {
return [
'none',
'matrix(1, 0, 0, 1, 0, 0)',
'matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)'
].includes(style.transform);
}
if (property === 'translate') {
return [
'none',
'0px',
'0px 0px',
'0px 0px 0px'
].includes(style.translate);
}
if (property === 'scale') {
return [
'none',
'1',
'1 1'
].includes(style.scale);
}
if (property === 'rotate') {
return [
'none',
'0deg'
].includes(style.rotate);
}
if (property === 'visibility') {
return style.visibility === 'visible';
}
if (property === 'clip') {
return [
'auto',
'rect(auto, auto, auto, auto)'
].includes(style.getPropertyValue('clip'));
}
return style.clipPath === 'none';
}
function getPendingRevealProperties(container) {
if (!container || typeof getComputedStyle !== 'function') {
return new Set(revealProperties);
}
var style = getComputedStyle(container);
return new Set(revealProperties.filter(function(property) {
return !isRevealed(style, property);
}));
}
function affectsReveal(animation, pendingRevealProperties) {
if (pendingRevealProperties.size === 0) {
return false;
}
var effect = animation.effect;
if (typeof (effect === null || effect === void 0 ? void 0 : effect.getKeyframes) !== 'function') {
return true;
}
return effect.getKeyframes().some(function(keyframe) {
return Array.from(pendingRevealProperties).some(function(property) {
return Object.prototype.hasOwnProperty.call(keyframe, property);
});
});
}
function startedDuringReveal(current, animationsBeforeReveal) {
var previous = animationsBeforeReveal.find(function(param) {
var animation = param.animation;
return animation === current.animation;
});
if (!previous) {
return true;
}
if (previous.playState !== current.playState) {
return true;
}
if (current.startTime !== null && previous.startTime !== current.startTime) {
return true;
}
return typeof previous.currentTime === 'number' && typeof current.currentTime === 'number' && current.currentTime < previous.currentTime;
}
function holdContainerInertUntilReveal(prompt) {
var container = getContainer(prompt);
if (!(container === null || container === void 0 ? void 0 : container.classList.contains('ais-Chat-container--open')) || container.hasAttribute('inert')) {
return;
}
container.setAttribute('inert', '');
containersHeldInert.add(container);
}
function restoreContainerInertUntilReveal(prompt) {
var container = getContainer(prompt);
if (container && containersHeldInert.has(container) && getPendingRevealProperties(container).size > 0) {
container.setAttribute('inert', '');
}
}
function requestAnimationFrameOrRun(callback) {
if (typeof requestAnimationFrame === 'function') {
requestAnimationFrame(callback);
} else {
callback();
}
}
function focusAfterReveal(prompt, animationsBeforeReveal, shouldFocus) {
var shouldRelease = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : shouldFocus;
var container = getContainer(prompt);
var settle = function settle() {
if (!shouldRelease()) {
return;
}
if (container) {
revealAnimationsHeldByContainer.delete(container);
}
if (container && containersHeldInert.has(container) && container.classList.contains('ais-Chat-container--open')) {
container.removeAttribute('inert');
containersHeldInert.delete(container);
}
if (prompt && shouldFocus()) {
prompt.focus();
}
};
var waitForReveal = function waitForReveal1() {
var requestIsCurrent = shouldRelease();
var pendingRevealProperties = getPendingRevealProperties(container);
var heldRevealAnimations = container ? revealAnimationsHeldByContainer.get(container) : undefined;
var activeAnimations = getActiveAnimations(container);
var heldRevealIsActive = activeAnimations.some(function(param) {
var animation = param.animation;
return heldRevealAnimations === null || heldRevealAnimations === void 0 ? void 0 : heldRevealAnimations.has(animation);
});
var replacesInactiveHeldReveal = heldRevealAnimations !== undefined && !heldRevealIsActive;
var revealAnimations = activeAnimations.filter(function(current) {
var _current_animation_effect;
return (startedDuringReveal(current, animationsBeforeReveal) || (heldRevealAnimations === null || heldRevealAnimations === void 0 ? void 0 : heldRevealAnimations.has(current.animation)) || replacesInactiveHeldReveal) && ((_current_animation_effect = current.animation.effect) === null || _current_animation_effect === void 0 ? void 0 : _current_animation_effect.getTiming().iterations) !== Infinity && affectsReveal(current.animation, pendingRevealProperties);
});
if (container && revealAnimations.length > 0 && (!heldRevealAnimations || requestIsCurrent || !heldRevealIsActive)) {
revealAnimationsHeldByContainer.set(container, new Set(revealAnimations.map(function(param) {
var animation = param.animation;
return animation;
})));
}
if (!requestIsCurrent) {
if (container && !container.classList.contains('ais-Chat-container--open')) {
revealAnimationsHeldByContainer.delete(container);
containersHeldInert.delete(container);
}
return;
}
if (revealAnimations.length === 0) {
settle();
return;
}
Promise.all(revealAnimations.map(function(param) {
var animation = param.animation;
return animation.finished.catch(function() {});
})).then(function() {
return requestAnimationFrameOrRun(waitForReveal);
});
};
waitForReveal();
}
var useStickToBottom = createStickToBottom({
useCallback: React.useCallback,
useEffect: React.useEffect,
useMemo: React.useMemo,
useRef: React.useRef,
useState: React.useState
});
var CarouselUiComponent = createCarouselComponent({
createElement: React.createElement,
Fragment: React.Fragment,
useEffect: React.useEffect,
useRef: React.useRef
});
function Carousel(props) {
var _useState = _sliced_to_array(React.useState(false), 2), canScrollLeft = _useState[0], setCanScrollLeft = _useState[1];
var _useState1 = _sliced_to_array(React.useState(true), 2), canScrollRight = _useState1[0], setCanScrollRight = _useState1[1];
var carouselRefs = {
listRef: React.useRef(null),
nextButtonRef: React.useRef(null),
previousButtonRef: React.useRef(null),
carouselIdRef: React.useRef(generateCarouselId()),
canScrollLeft: canScrollLeft,
canScrollRight: canScrollRight,
setCanScrollLeft: setCanScrollLeft,
setCanScrollRight: setCanScrollRight
};
return /*#__PURE__*/ React.createElement(CarouselUiComponent, _object_spread({}, carouselRefs, props));
}
var ChatMessageLoader = createChatMessageLoaderComponent({
createElement: React.createElement
});
var ChatOverlayLayout = createChatOverlayLayoutComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var ChatInlineLayout = createChatInlineLayoutComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
// Marker used by `<Chat>` to auto-exempt inline layouts from the entry-point
// validation, since inline chats are always visible (no trigger needed).
ChatInlineLayout.$$inlineLayout = true;
var ChatSidePanelLayout = createChatSidePanelLayoutComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
var ChatGreeting = createChatGreetingComponent({
createElement: React.createElement
});
function createGroupedResultsTool(itemComponent) {
var DisplayResultsUIComponent = createDisplayResultsToolComponent({
createElement: React.createElement,
Fragment: React.Fragment,
useEffect: React.useEffect,
useRef: React.useRef
});
var Button = createButtonComponent({
createElement: React.createElement
});
var DisplayResultsCarouselHeader = function DisplayResultsCarouselHeader(param) {
var nbItems = param.nbItems, canScrollLeft = param.canScrollLeft, canScrollRight = param.canScrollRight, scrollLeft = param.scrollLeft, scrollRight = param.scrollRight;
return /*#__PURE__*/ React.createElement("div", {
className: "ais-ChatToolDisplayResultsCarouselHeader"
}, /*#__PURE__*/ React.createElement("div", {
className: "ais-ChatToolDisplayResultsCarouselHeaderCount"
}, nbItems, " result", nbItems > 1 ? 's' : ''), /*#__PURE__*/ React.createElement("div", {
className: "ais-ChatToolDisplayResultsCarouselHeaderScrollButtons"
}, /*#__PURE__*/ React.createElement(Button, {
variant: "outline",
size: "sm",
iconOnly: true,
"aria-label": "Previous",
onClick: scrollLeft,
disabled: !canScrollLeft,
className: "ais-ChatToolDisplayResultsCarouselHeaderScrollButton"
}, /*#__PURE__*/ React.createElement(ChevronLeftIcon, {
createElement: React.createElement
})), /*#__PURE__*/ React.createElement(Button, {
variant: "outline",
size: "sm",
iconOnly: true,
"aria-label": "Next",
onClick: scrollRight,
disabled: !canScrollRight,
className: "ais-ChatToolDisplayResultsCarouselHeaderScrollButton"
}, /*#__PURE__*/ React.createElement(ChevronRightIcon, {
createElement: React.createElement
}))));
};
var DisplayResultsLayoutComponent = function DisplayResultsLayoutComponent(toolProps) {
return /*#__PURE__*/ React.createElement(DisplayResultsUIComponent, {
toolProps: toolProps,
groupCarouselComponent: function groupCarouselComponent(param) {
var items = param.items, sendEvent = param.sendEvent;
return /*#__PURE__*/ React.createElement(Carousel, {
items: items,
itemComponent: itemComponent,
sendEvent: sendEvent,
showNavigation: false,
headerComponent: DisplayResultsCarouselHeader
});
}
});
};
return {
layoutComponent: DisplayResultsLayoutComponent,
streamInput: true
};
}
function createCarouselTool(showViewAll, itemComponent, getSearchPageURL) {
var SearchLayoutUIComponent = createCarouselToolComponent({
createElement: React.createElement,
Fragment: React.Fragment,
useEffect: React.useEffect,
useMemo: React.useMemo,
useRef: React.useRef,
useState: React.useState
});
var SearchLayoutComponent = function SearchLayoutComponent(toolProps) {
return /*#__PURE__*/ React.createElement(SearchLayoutUIComponent, {
getSearchPageURL: getSearchPageURL,
headerProps: {
showViewAll: showViewAll
},
itemComponent: itemComponent,
toolProps: toolProps
});
};
return {
layoutComponent: SearchLayoutComponent
};
}
var ChatUiComponent = createChatComponent({
createElement: React.createElement,
Fragment: React.Fragment,
useMemo: React.useMemo,
useState: React.useState,
useEffect: React.useEffect
});
function createDefaultTools(itemComponent, getSearchPageURL) {
var _obj;
return _obj = {}, _define_property(_obj, SearchIndexToolType, _object_spread_props(_object_spread({}, createCarouselTool(true, itemComponent, getSearchPageURL)), {
// The agent decides per turn whether the richer Grouped Results tool
// takes over the rendering of the search results.
shouldRender: isDisplayResultsDisabled
})), _define_property(_obj, RecommendToolType, createCarouselTool(false, itemComponent, getSearchPageURL)), _define_property(_obj, DisplayResultsToolType, createGroupedResultsTool(itemComponent)), _define_property(_obj, GroupedResultsToolType, createGroupedResultsTool(itemComponent)), _define_property(_obj, MemorizeToolType, {}), _define_property(_obj, MemorySearchToolType, {}), _define_property(_obj, PonderToolType, {}), _obj;
}
/**
* Whether the search tool renders its own results, i.e. the agent did not hand
* the turn to the Grouped Results tool. Set on the message by the backend.
*/ function isDisplayResultsDisabled(param) {
var parentMessage = param.parentMessage;
var _parentMessage_metadata;
return ((_parentMessage_metadata = parentMessage.metadata) === null || _parentMessage_metadata === void 0 ? void 0 : _parentMessage_metadata.displayResultsEnabled) !== true;
}
function mergeToolOptions(defaultTools, userTools) {
if (!userTools) {
return defaultTools;
}
var tools = _object_spread({}, defaultTools, userTools);
Object.keys(userTools).forEach(function(toolName) {
var userTool = userTools[toolName];
var defaultTool = defaultTools[toolName];
var defaultStreamInput = defaultTool === null || defaultTool === void 0 ? void 0 : defaultTool.streamInput;
if (userTool.layoutComponent !== undefined && userTool.streamInput === undefined && defaultStreamInput !== undefined) {
tools[toolName] = _object_spread_props(_object_spread({}, tools[toolName]), {
streamInput: defaultStreamInput
});
}
// Overriding a tool's rendering shouldn't opt it out of the conditions
// under which the default renders at all.
if (userTool.shouldRender === undefined && (defaultTool === null || defaultTool === void 0 ? void 0 : defaultTool.shouldRender)) {
tools[toolName] = _object_spread_props(_object_spread({}, tools[toolName]), {
shouldRender: defaultTool.shouldRender
});
}
});
return tools;
}
var AnimationSnapshot = /*#__PURE__*/ function(_React_Component) {
_inherits(AnimationSnapshot, _React_Component);
function AnimationSnapshot() {
_class_call_check(this, AnimationSnapshot);
return _call_super(this, AnimationSnapshot, arguments);
}
_create_class(AnimationSnapshot, [
{
key: "getSnapshotBeforeUpdate",
value: function getSnapshotBeforeUpdate() {
return getActiveContainerAnimations(this.props.promptRef.current);
}
},
{
key: "componentDidUpdate",
value: function componentDidUpdate(_previousProps, _previousState, animationsBeforeReveal) {
this.props.animationsBeforeReveal.current = animationsBeforeReveal;
if (!_previousProps.open && this.props.open) {
holdContainerInertUntilReveal(this.props.promptRef.current);
} else if (this.props.open) {
restoreContainerInertUntilReveal(this.props.promptRef.current);
}
}
},
{
key: "render",
value: function render() {
return null;
}
}
]);
return AnimationSnapshot;
}(React.Component);
function ChatInner(_0, _1) {
var _ref = [
_0,
_1
], _ref1 = _to_array(_ref), _ref2 = _ref1[0], _rest = _ref1.slice(1), userTools = _ref2.tools, headerProps = _ref2.headerProps, messagesProps = _ref2.messagesProps, promptProps = _ref2.promptProps, itemComponent = _ref2.itemComponent, layoutComponent = _ref2.layoutComponent, headerComponent = _ref2.headerComponent, headerTitleIconComponent = _ref2.headerTitleIconComponent, headerCloseIconComponent = _ref2.headerCloseIconComponent, headerMinimizeIconComponent = _ref2.headerMinimizeIconComponent, headerMaximizeIconComponent = _ref2.headerMaximizeIconComponent, loaderComponent = _ref2.loaderComponent, loaderPosition = _ref2.loaderPosition, shouldShowLoader = _ref2.shouldShowLoader, loaderShowDelay = _ref2.loaderShowDelay, loaderMinDuration = _ref2.loaderMinDuration, messagesErrorComponent = _ref2.messagesErrorComponent, promptComponent = _ref2.promptComponent, promptHeaderComponent = _ref2.promptHeaderComponent, promptFooterComponent = _ref2.promptFooterComponent, assistantMessageLeadingComponent = _ref2.assistantMessageLeadingComponent, assistantMessageFooterComponent = _ref2.assistantMessageFooterComponent, userMessageLeadingComponent = _ref2.userMessageLeadingComponent, userMessageFooterComponent = _ref2.userMessageFooterComponent, emptyComponent = _ref2.emptyComponent, actionsComponent = _ref2.actionsComponent, suggestionsComponent = _ref2.suggestionsComponent, classNames = _ref2.classNames, _ref_translations = _ref2.translations, translations = _ref_translations === void 0 ? {} : _ref_translations, title = _ref2.title, getSearchPageURL = _ref2.getSearchPageURL, _ref_disableTriggerValidation = _ref2.disableTriggerValidation, disableTriggerValidation = _ref_disableTriggerValidation === void 0 ? false : _ref_disableTriggerValidation, showReasoning = _ref2.showReasoning, reasoningComponent = _ref2.reasoningComponent, props = _object_without_properties(_ref2, [
"tools",
"headerProps",
"messagesProps",
"promptProps",
"itemComponent",
"layoutComponent",
"headerComponent",
"headerTitleIconComponent",
"headerCloseIconComponent",
"headerMinimizeIconComponent",
"headerMaximizeIconComponent",
"loaderComponent",
"loaderPosition",
"shouldShowLoader",
"loaderShowDelay",
"loaderMinDuration",
"messagesErrorComponent",
"promptComponent",
"promptHeaderComponent",
"promptFooterComponent",
"assistantMessageLeadingComponent",
"assistantMessageFooterComponent",
"userMessageLeadingComponent",
"userMessageFooterComponent",
"emptyComponent",
"actionsComponent",
"suggestionsComponent",
"classNames",
"translations",
"title",
"getSearchPageURL",
"disableTriggerValidation",
"showReasoning",
"reasoningComponent"
]), _rest1 = _sliced_to_array(_rest, 1), ref = _rest1[0];
var _ref3;
var promptTranslations = translations.prompt, headerTranslations = translations.header, messageTranslations = translations.message, messagesTranslations = translations.messages;
var _useInstantSearch = useInstantSearch(), indexUiState = _useInstantSearch.indexUiState, setIndexUiState = _useInstantSearch.setIndexUiState;
var _useState = _sliced_to_array(React.useState(false), 2), maximized = _useState[0], setMaximized = _useState[1];
var promptRef = React.useRef(null);
var focusRequestId = React.useRef(0);
var animationsBeforeReveal = React.useRef([]);
var _useStickToBottom = useStickToBottom({
initial: 'smooth',
resize: 'smooth'
}), scrollRef = _useStickToBottom.scrollRef, contentRef = _useStickToBottom.contentRef, scrollToBottom = _useStickToBottom.scrollToBottom, isAtBottom = _useStickToBottom.isAtBottom;
var tools = React.useMemo(function() {
var defaults = createDefaultTools(itemComponent, getSearchPageURL);
return mergeToolOptions(defaults, userTools);
}, [
getSearchPageURL,
itemComponent,
userTools
]);
// Inline layouts are always visible, so they don't require a `<ChatTrigger />`
// (or AI mode) to be present. We detect this via a `$$inlineLayout` marker
// set on the layout component, which is consistent across flavors.
var isInlineLayoutComponent = typeof layoutComponent === 'function' && layoutComponent.$$inlineLayout === true;
var effectiveDisableTriggerValidation = disableTriggerValidation || isInlineLayoutComponent;
var chatState = useChat(_object_spread_props(_object_spread({}, props), {
tools: tools,
disableTriggerValidation: effectiveDisableTriggerValidation
}));
var messages = chatState.messages, sendMessage = chatState.sendMessage, status = chatState.status, regenerate = chatState.regenerate, stop = chatState.stop, error = chatState.error, input = chatState.input, setInput = chatState.setInput, open = chatState.open, setOpen = chatState.setOpen, clearMessages = chatState.clearMessages, toolsFromConnector = chatState.tools, suggestions = chatState.suggestions, onFeedback = chatState.sendChatMessageFeedback, feedbackState = chatState.feedbackState, consumeInputFocus = chatState['~consumeInputFocus'], isOpenStatePersistenceEnabled = chatState['~isOpenStatePersistenceEnabled'];
var sendMessageAndScrollToBottom = React.useCallback(function() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
scrollToBottom();
return sendMessage.apply(void 0, _to_consumable_array(args));
}, [
scrollToBottom,
sendMessage
]);
React.useImperativeHandle(ref, function() {
return {
setOpen: setOpen,
sendMessage: function sendMessage(params) {
return sendMessageAndScrollToBottom(params);
},
setInput: setInput
};
});
React.useEffect(function() {
if (!open) {
focusRequestId.current++;
return;
}
if (consumeInputFocus === null || consumeInputFocus === void 0 ? void 0 : consumeInputFocus()) {
var currentFocusRequestId = ++focusRequestId.current;
var previousAnimations = animationsBeforeReveal.current;
holdContainerInertUntilReveal(promptRef.current);
window.requestAnimationFrame(function() {
var prompt = promptRef.current;
focusAfterReveal(prompt, previousAnimations, function() {
return focusRequestId.current === currentFocusRequestId && promptRef.current === prompt;
}, function() {
return focusRequestId.current === currentFocusRequestId;
});
});
}
});
// Keep the conversation pinned to the bottom while streaming. The stick-to-
// bottom ResizeObserver only reacts to content *height* changes, but tool
// results such as a horizontally-growing carousel stream in without changing
// height — so we also re-pin on every message/status update. Passing
// `preserveScrollPosition` reuses the existing "only if already at the
// bottom" gate, so this never fights a user who has scrolled up to read.
React.useEffect(function() {
if (status === 'streaming' || status === 'submitted') {
scrollToBottom({
preserveScrollPosition: true
});
}
}, [
messages,
status,
scrollToBottom
]);
if (error) {
throw error;
}
var _ref4 = messagesProps !== null && messagesProps !== void 0 ? messagesProps : {}, callerAssistantMessageProps = _ref4.assistantMessageProps, callerUserMessageProps = _ref4.userMessageProps, restMessagesProps = _object_without_properties(_ref4, [
"assistantMessageProps",
"userMessageProps"
]);
var chat = /*#__PURE__*/ React.createElement(ChatUiComponent, {
title: title,
open: open,
maximized: maximized,
sendMessage: sendMessageAndScrollToBottom,
regenerate: regenerate,
stop: stop,
error: error,
layoutComponent: layoutComponent,
headerComponent: headerComponent,
promptComponent: promptComponent,
suggestionsComponent: suggestionsComponent,
headerProps: _object_spread({
onClose: function onClose() {
return setOpen(false);
},
maximized: maximized,
onToggleMaximize: function onToggleMaximize() {
return setMaximized(!maximized);
},
onClear: clearMessages,
canClear: Boolean(messages === null || messages === void 0 ? void 0 : messages.length),
titleIconComponent: headerTitleIconComponent,
closeIconComponent: headerCloseIconComponent,
minimizeIconComponent: headerMinimizeIconComponent,
maximizeIconComponent: headerMaximizeIconComponent,
translations: headerTranslations
}, headerProps),
messagesProps: _object_spread_props(_object_spread({
status: status,
onReload: function onReload(messageId) {
return regenerate({
messageId: messageId
});
},
onNewConversation: clearMessages,
onClose: function onClose() {
return setOpen(false);
},
sendMessage: sendMessageAndScrollToBottom,
setInput: setInput,
onFeedback: onFeedback,
feedbackState: feedbackState,
messages: messages,
tools: toolsFromConnector,
indexUiState: indexUiState,
setIndexUiState: setIndexUiState,
isScrollAtBottom: isAtBottom,
scrollRef: scrollRef,
contentRef: contentRef,
onScrollToBottom: scrollToBottom,
loaderComponent: loaderComponent,
loaderPosition: loaderPosition,
shouldShowLoader: shouldShowLoader,
loaderShowDelay: loaderShowDelay,
loaderMinDuration: loaderMinDuration,
errorComponent: messagesErrorComponent,
emptyComponent: emptyComponent,
actionsComponent: actionsComponent,
translations: messagesTranslations,
messageTranslations: messageTranslations
}, restMessagesProps), {
assistantMessageProps: _object_spread({
leadingComponent: assistantMessageLeadingComponent,
footerComponent: assistantMessageFooterComponent,
showReasoning: showReasoning,
reasoningComponent: reasoningComponent
}, callerAssistantMessageProps),
userMessageProps: _object_spread({
leadingComponent: userMessageLeadingComponent,
footerComponent: userMessageFooterComponent
}, callerUserMessageProps),
error: error
}),
promptProps: _object_spread_props(_object_spread({
promptRef: promptRef,
status: status,
value: input,
translations: promptTranslations,
onInput: function onInput(event) {
setInput(event.currentTarget.value);
},
onSubmit: function onSubmit() {
sendMessageAndScrollToBottom({
text: input
});
setInput('');
},
onStop: function onStop() {
stop();
},
headerComponent: promptHeaderComponent,
footerComponent: promptFooterComponent
}, promptProps), {
autoFocus: (_ref3 = promptProps === null || promptProps === void 0 ? void 0 : promptProps.autoFocus) !== null && _ref3 !== void 0 ? _ref3 : !isOpenStatePersistenceEnabled || isInlineLayoutComponent
}),
suggestionsProps: {
suggestions: suggestions,
onSuggestionClick: function onSuggestionClick(suggestion) {
sendMessageAndScrollToBottom({
text: suggestion
});
}
},
classNames: classNames
});
return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(AnimationSnapshot, {
promptRef: promptRef,
animationsBeforeReveal: animationsBeforeReveal,
open: open
}), chat);
}
var Chat = /*#__PURE__*/ React.forwardRef(ChatInner);
var PromptSuggestionsUi = createPromptSuggestionsComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
function PromptSuggestions(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, LayoutComponent = _0.layoutComponent, onSuggestionClickOverride = _0.onSuggestionClick, // Connector params — forwarded to the hook, not the UI root.
agentId = _0.agentId, transport = _0.transport, configurationId = _0.configurationId, transformHits = _0.transformHits, context = _0.context, transformItems = _0.transformItems, props = _object_without_properties(_0, [
"classNames",
"layoutComponent",
"onSuggestionClick",
"agentId",
"transport",
"configurationId",
"transformHits",
"context",
"transformItems"
]);
var source = agentId !== undefined ? {
agentId: agentId,
transport: transport
} : {
transport: transport
};
var _usePromptSuggestions = usePromptSuggestions(_object_spread_props(_object_spread({}, source), {
configurationId: configurationId,
transformHits: transformHits,
context: context,
transformItems: transformItems
}), {
$$widgetType: 'ais.promptSuggestions'
}), suggestions = _usePromptSuggestions.suggestions, isLoading = _usePromptSuggestions.isLoading, error = _usePromptSuggestions.error, onSuggestionClick = _usePromptSuggestions.onSuggestionClick, isChatBusy = _usePromptSuggestions.isChatBusy, sendToChat = _usePromptSuggestions.sendToChat;
if (!sendToChat && !onSuggestionClickOverride) {
throw new Error('No <Chat> widget is mounted on this index, so there is nothing to send a clicked suggestion to. Mount a <Chat> on the same index, or pass `onSuggestionClick` to handle the click yourself.');
}
var handleClick = onSuggestionClickOverride ? function(prompt) {
return onSuggestionClickOverride(prompt, {
// `sendToChat` is only absent when the override above owns the click,
// in which case falling through to the chat is a no-op.
sendToChat: sendToChat !== null && sendToChat !== void 0 ? sendToChat : function() {
return false;
}
});
} : onSuggestionClick;
if (LayoutComponent) {
return /*#__PURE__*/ React.createElement(LayoutComponent, {
suggestions: suggestions,
isLoading: isLoading,
error: error,
onSuggestionClick: handleClick,
isChatBusy: isChatBusy
});
}
return /*#__PURE__*/ React.createElement(PromptSuggestionsUi, _object_spread_props(_object_spread({}, props), {
classNames: classNames,
suggestions: suggestions,
isLoading: isLoading,
onSuggestionClick: handleClick,
disabled: isChatBusy
}));
}
var ChatToggleButton = createChatToggleButtonComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
function ChatTrigger(_0) {
var classNames = _0.classNames, toggleIconComponent = _0.toggleIconComponent, onClick = _0.onClick, _0_floating = _0.floating, floating = _0_floating === void 0 ? true : _0_floating, props = _object_without_properties(_0, [
"classNames",
"toggleIconComponent",
"onClick",
"floating"
]);
var _useChatTrigger = useChatTrigger({}, {
$$widgetType: 'ais.chatTrigger'
}), open = _useChatTrigger.open, toggleOpen = _useChatTrigger.toggleOpen;
var handleClick = function handleClick() {
toggleOpen();
onClick === null || onClick === void 0 ? void 0 : onClick();
};
var rootClassName = [
floating && 'ais-ChatToggleButton--floating',
classNames === null || classNames === void 0 ? void 0 : classNames.root
].filter(Boolean).flat();
return /*#__PURE__*/ React.createElement(ChatToggleButton, _object_spread({
open: open,
onClick: handleClick,
classNames: _object_spread_props(_object_spread({}, classNames), {
root: rootClassName
}),
toggleIconComponent: toggleIconComponent
}, props));
}
function ClearRefinements$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, _0_disabled = _0.disabled, disabled = _0_disabled === void 0 ? false : _0_disabled, _0_onClick = _0.onClick, onClick = _0_onClick === void 0 ? function() {} : _0_onClick, translations = _0.translations, props = _object_without_properties(_0, [
"classNames",
"disabled",
"onClick",
"translations"
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-ClearRefinements', classNames.root, props.className)
}), /*#__PURE__*/ React.createElement("button", {
disabled: disabled,
onClick: onClick,
className: cx('ais-ClearRefinements-button', classNames.button, disabled && cx('ais-ClearRefinements-button--disabled', classNames.disabledButton))
}, translations.resetButtonText));
}
function ClearRefinements(_0) {
var includedAttributes = _0.includedAttributes, excludedAttributes = _0.excludedAttributes, transformItems = _0.transformItems, translations = _0.translations, props = _object_without_properties(_0, [
"includedAttributes",
"excludedAttributes",
"transformItems",
"translations"
]);
var _useClearRefinements = useClearRefinements({
includedAttributes: includedAttributes,
excludedAttributes: excludedAttributes,
transformItems: transformItems
}, {
$$widgetType: 'ais.clearRefinements'
}), canRefine = _useClearRefinements.canRefine, refine = _useClearRefinements.refine;
var uiProps = {
onClick: refine,
disabled: !canRefine,
translations: _object_spread({
resetButtonText: 'Clear refinements'
}, translations)
};
return /*#__PURE__*/ React.createElement(ClearRefinements$1, _object_spread({}, props, uiProps));
}
function capitalize(text) {
return text.toString().charAt(0).toUpperCase() + text.toString().slice(1);
}
function CurrentRefinements$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, _0_items = _0.items, items = _0_items === void 0 ? [] : _0_items, _0_hasRefinements = _0.hasRefinements, hasRefinements = _0_hasRefinements === void 0 ? false : _0_hasRefinements, props = _object_without_properties(_0, [
"classNames",
"items",
"hasRefinements"
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-CurrentRefinements', classNames.root, !hasRefinements && cx('ais-CurrentRefinements--noRefinement', classNames.noRefinementRoot), props.className)
}), /*#__PURE__*/ React.createElement("ul", {
className: cx('ais-CurrentRefinements-list', classNames.list, /* @MAJOR remove to ensure conformity with InstantSearch.css specs */ !hasRefinements && cx('ais-CurrentRefinements-list--noRefinement', classNames.noRefinementList))
}, items.map(function(item) {
return /*#__PURE__*/ React.createElement("li", {
key: [
item.indexName,
item.label
].join('/'),
className: cx('ais-CurrentRefinements-item', classNames.item)
}, /*#__PURE__*/ React.createElement("span", {
className: cx('ais-CurrentRefinements-label', classNames.label)
}, capitalize(item.label), ":", ' '), item.refinements.map(function(refinement) {
return /*#__PURE__*/ React.createElement("span", {
key: refinement.label,
className: cx('ais-CurrentRefinements-category', classNames.category)
}, /*#__PURE__*/ React.createElement("span", {
className: cx('ais-CurrentRefinements-categoryLabel', classNames.categoryLabel)
}, refinement.label), /*#__PURE__*/ React.createElement("button", {
type: "button",
onClick: function onClick(event) {
if (isModifierClick(event)) {
return;
}
item.refine(refinement);
},
className: cx('ais-CurrentRefinements-delete', classNames.delete)
}, "✕"));
}));
})));
}
function CurrentRefinements(_0) {
var includedAttributes = _0.includedAttributes, excludedAttributes = _0.excludedAttributes, transformItems = _0.transformItems, props = _object_without_properties(_0, [
"includedAttributes",
"excludedAttributes",
"transformItems"
]);
var _useCurrentRefinements = useCurrentRefinements({
includedAttributes: includedAttributes,
excludedAttributes: excludedAttributes,
transformItems: transformItems
}, {
$$widgetType: 'ais.currentRefinements'
}), items = _useCurrentRefinements.items, canRefine = _useCurrentRefinements.canRefine;
var uiProps = {
items: items,
hasRefinements: canRefine
};
return /*#__PURE__*/ React.createElement(CurrentRefinements$1, _object_spread({}, props, uiProps));
}
var FrequentlyBoughtTogetherUiComponent = createFrequentlyBoughtTogetherComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
function FrequentlyBoughtTogether(_0) {
var objectIDs = _0.objectIDs, limit = _0.limit, threshold = _0.threshold, queryParameters = _0.queryParameters, fallbackParameters = _0.fallbackParameters, escapeHTML = _0.escapeHTML, transformItems = _0.transformItems, itemComponent = _0.itemComponent, headerComponent = _0.headerComponent, emptyComponent = _0.emptyComponent, layoutComponent = _0.layoutComponent, props = _object_without_properties(_0, [
"objectIDs",
"limit",
"threshold",
"queryParameters",
"fallbackParameters",
"escapeHTML",
"transformItems",
"itemComponent",
"headerComponent",
"emptyComponent",
"layoutComponent"
]);
var status = useInstantSearch().status;
var _useFrequentlyBoughtTogether = useFrequentlyBoughtTogether({
objectIDs: objectIDs,
limit: limit,
threshold: threshold,
queryParameters: queryParameters,
fallbackParameters: fallbackParameters,
escapeHTML: escapeHTML,
transformItems: transformItems
}, {
$$widgetType: 'ais.frequentlyBoughtTogether'
}), items = _useFrequentlyBoughtTogether.items, sendEvent = _useFrequentlyBoughtTogether.sendEvent;
var layout = layoutComponent ? function(layoutProps) {
return layoutComponent(_object_spread_props(_object_spread({}, layoutProps), {
classNames: {
list: layoutProps.classNames.list,
item: layoutProps.classNames.item
}
}));
} : undefined;
var _itemComponent = React.useMemo(function() {
return itemComponent ? function(itemProps) {
return itemComponent(_object_spread_props(_object_spread({}, itemProps), {
sendEvent: sendEvent
}));
} : undefined;
}, [
itemComponent,
sendEvent
]);
var uiProps = {
items: items,
itemComponent: _itemComponent,
headerComponent: headerComponent,
emptyComponent: emptyComponent,
layout: layout,
status: status,
sendEvent: sendEvent
};
return /*#__PURE__*/ React.createElement(FrequentlyBoughtTogetherUiComponent, _object_spread({}, props, uiProps));
}
function ShowMoreButton(_0) {
var isShowingMore = _0.isShowingMore, translations = _0.translations, props = _object_without_properties(_0, [
"isShowingMore",
"translations"
]);
return /*#__PURE__*/ React.createElement("button", _object_spread_props(_object_spread({}, props), {
"aria-expanded": isShowingMore,
"aria-label": translations.showMoreButtonLabel
}), translations.showMoreButtonText({
isShowingMore: isShowingMore
}));
}
function HierarchicalList(param) {
var className = param.className, _param_classNames = param.classNames, classNames = _param_classNames === void 0 ? {} : _param_classNames, items = param.items, createURL = param.createURL, onNavigate = param.onNavigate;
if (items.length === 0) {
return null;
}
return /*#__PURE__*/ React.createElement("ul", {
className: cx('ais-HierarchicalMenu-list', classNames.list, className)
}, items.map(function(item) {
return /*#__PURE__*/ React.createElement("li", {
key: item.value,
className: cx('ais-HierarchicalMenu-item', classNames.item, item.isRefined && cx('ais-HierarchicalMenu-item--selected', classNames.selectedItem), item.data && item.data.length > 0 && cx('ais-HierarchicalMenu-item--parent', classNames.parentItem))
}, /*#__PURE__*/ React.createElement("a", {
className: cx('ais-HierarchicalMenu-link', classNames.link, item.isRefined && cx('ais-HierarchicalMenu-link--selected', classNames.selectedItemLink)),
href: createURL(item.value),
onClick: function onClick(event) {
if (isModifierClick(event)) {
return;
}
event.preventDefault();
onNavigate(item.value);
}
}, /*#__PURE__*/ React.createElement("span", {
className: cx('ais-HierarchicalMenu-label', classNames.label)
}, item.label), /*#__PURE__*/ React.createElement("span", {
className: cx('ais-HierarchicalMenu-count', classNames.count)
}, item.count)), item.data && /*#__PURE__*/ React.createElement(HierarchicalList, {
className: cx('ais-HierarchicalMenu-list--child', classNames.childList),
classNames: classNames,
items: item.data,
onNavigate: onNavigate,
createURL: createURL
}));
}));
}
function HierarchicalMenu$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, items = _0.items, hasItems = _0.hasItems, onNavigate = _0.onNavigate, createURL = _0.createURL, showMore = _0.showMore, canToggleShowMore = _0.canToggleShowMore, onToggleShowMore = _0.onToggleShowMore, isShowingMore = _0.isShowingMore, translations = _0.translations, props = _object_without_properties(_0, [
"classNames",
"items",
"hasItems",
"onNavigate",
"createURL",
"showMore",
"canToggleShowMore",
"onToggleShowMore",
"isShowingMore",
"translations"
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-HierarchicalMenu', classNames.root, !hasItems && cx('ais-HierarchicalMenu--noRefinement', classNames.noRefinementRoot), props.className)
}), /*#__PURE__*/ React.createElement(HierarchicalList, {
classNames: classNames,
items: items,
onNavigate: onNavigate,
createURL: createURL
}), showMore && /*#__PURE__*/ React.createElement(ShowMoreButton, {
className: cx('ais-HierarchicalMenu-showMore', classNames.showMore, !canToggleShowMore && cx('ais-HierarchicalMenu-showMore--disabled', classNames.disabledShowMore)),
disabled: !canToggleShowMore,
onClick: onToggleShowMore,
isShowingMore: isShowingMore,
translations: translations
}));
}
function HierarchicalMenu(_0) {
var attributes = _0.attributes, limit = _0.limit, rootPath = _0.rootPath, separator = _0.separator, showMore = _0.showMore, showMoreLimit = _0.showMoreLimit, showParentLevel = _0.showParentLevel, sortBy = _0.sortBy, transformItems = _0.transformItems, translations = _0.translations, props = _object_without_properties(_0, [
"attributes",
"limit",
"rootPath",
"separator",
"showMore",
"showMoreLimit",
"showParentLevel",
"sortBy",
"transformItems",
"translations"
]);
var _useHierarchicalMenu = useHierarchicalMenu({
attributes: attributes,
limit: limit,
rootPath: rootPath,
separator: separator,
showMore: showMore,
showMoreLimit: showMoreLimit,
showParentLevel: showParentLevel,
sortBy: sortBy,
transformItems: transformItems
}, {
$$widgetType: 'ais.hierarchicalMenu'
}), items = _useHierarchicalMenu.items, canRefine = _useHierarchicalMenu.canRefine, canToggleShowMore = _useHierarchicalMenu.canToggleShowMore, createURL = _useHierarchicalMenu.createURL, isShowingMore = _useHierarchicalMenu.isShowingMore, refine = _useHierarchicalMenu.refine, toggleShowMore = _useHierarchicalMenu.toggleShowMore;
var uiProps = {
items: items,
hasItems: canRefine,
createURL: createURL,
onNavigate: refine,
canToggleShowMore: canToggleShowMore,
onToggleShowMore: toggleShowMore,
isShowingMore: isShowingMore,
translations: _object_spread({
showMoreButtonText: function showMoreButtonText(options) {
return options.isShowingMore ? 'Show less' : 'Show more';
}
}, translations)
};
return /*#__PURE__*/ React.createElement(HierarchicalMenu$1, _object_spread_props(_object_spread({}, props, uiProps), {
showMore: showMore
}));
}
// @MAJOR: Move default hit component back to the UI library
// once flavour specificities are erased
function DefaultHitComponent$1(param) {
var hit = param.hit;
return /*#__PURE__*/ React.createElement("div", {
style: {
wordBreak: 'break-all'
}
}, JSON.stringify(hit).slice(0, 100), "…");
}
var HitsUiComponent = createHitsComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
function Hits(_0) {
var escapeHTML = _0.escapeHTML, transformItems = _0.transformItems, tmp = _0.hitComponent, HitComponent = tmp === void 0 ? DefaultHitComponent$1 : tmp, BannerComponent = _0.bannerComponent, props = _object_without_properties(_0, [
"escapeHTML",
"transformItems",
"hitComponent",
"bannerComponent"
]);
var _useHits = useHits({
escapeHTML: escapeHTML,
transformItems: transformItems
}, {
$$widgetType: 'ais.hits'
}), hits = _useHits.hits, banner = _useHits.banner, sendEvent = _useHits.sendEvent;
var itemComponent = React.useMemo(function() {
return function(_0) {
var hit = _0.hit; _0.index; var itemProps = _object_without_properties(_0, [
"hit",
"index"
]);
return /*#__PURE__*/ React.createElement("li", _object_spread({
key: hit.objectID
}, itemProps), /*#__PURE__*/ React.createElement(HitComponent, {
hit: hit,
sendEvent: sendEvent
}));
};
}, [
HitComponent,
sendEvent
]);
var bannerComponent = BannerComponent === false ? function() {
return null;
} : BannerComponent;
var uiProps = {
hits: hits,
sendEvent: sendEvent,
itemComponent: itemComponent,
banner: banner,
bannerComponent: bannerComponent
};
return /*#__PURE__*/ React.createElement(HitsUiComponent, _object_spread({}, props, uiProps));
}
function HitsPerPage$1(_0) {
var items = _0.items, onChange = _0.onChange, currentValue = _0.currentValue, _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, props = _object_without_properties(_0, [
"items",
"onChange",
"currentValue",
"classNames"
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-HitsPerPage', classNames.root, props.className)
}), /*#__PURE__*/ React.createElement("select", {
className: cx('ais-HitsPerPage-select', classNames.select),
onChange: function onChange1(event) {
onChange(Number(event.target.value));
},
value: String(currentValue)
}, items.map(function(item) {
return /*#__PURE__*/ React.createElement("option", {
key: item.value,
className: cx('ais-HitsPerPage-option', classNames.option),
value: item.value
}, item.label);
})));
}
function HitsPerPage(_0) {
var userItems = _0.items, transformItems = _0.transformItems, props = _object_without_properties(_0, [
"items",
"transformItems"
]);
var _useHitsPerPage = useHitsPerPage({
items: userItems,
transformItems: transformItems
}, {
$$widgetType: 'ais.hitsPerPage'
}), items = _useHitsPerPage.items, refine = _useHitsPerPage.refine;
var _ref = items.find(function(param) {
var isRefined = param.isRefined;
return isRefined;
}) || {}, currentValue = _ref.value;
var uiProps = {
items: items,
currentValue: currentValue,
onChange: function onChange(value) {
return refine(value);
}
};
return /*#__PURE__*/ React.createElement(HitsPerPage$1, _object_spread({}, props, uiProps));
}
function DefaultHitComponent(param) {
var hit = param.hit;
return /*#__PURE__*/ React.createElement("div", {
style: {
wordBreak: 'break-all'
}
}, JSON.stringify(hit).slice(0, 100), "…");
}
function DefaultBanner(param) {
var classNames = param.classNames, banner = param.banner;
if (!banner.image.urls[0].url) {
return null;
}
return /*#__PURE__*/ React.createElement("aside", {
className: cx('ais-InfiniteHits-banner', classNames.bannerRoot)
}, banner.link ? /*#__PURE__*/ React.createElement("a", {
className: cx('ais-InfiniteHits-banner-link', classNames.bannerLink),
href: banner.link.url,
target: banner.link.target
}, /*#__PURE__*/ React.createElement("img", {
className: cx('ais-InfiniteHits-banner-image', classNames.bannerImage),
src: banner.image.urls[0].url,
alt: banner.image.title
})) : /*#__PURE__*/ React.createElement("img", {
className: cx('ais-InfiniteHits-banner-image', classNames.bannerImage),
src: banner.image.urls[0].url,
alt: banner.image.title
}));
}
function InfiniteHits$1(_0) {
var tmp = _0.hitComponent, HitComponent = tmp === void 0 ? DefaultHitComponent : tmp, hits = _0.hits, BannerComponent = _0.bannerComponent, banner = _0.banner, sendEvent = _0.sendEvent, isFirstPage = _0.isFirstPage, isLastPage = _0.isLastPage, onShowPrevious = _0.onShowPrevious, onShowMore = _0.onShowMore, _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, translations = _0.translations, props = _object_without_properties(_0, [
"hitComponent",
"hits",
"bannerComponent",
"banner",
"sendEvent",
"isFirstPage",
"isLastPage",
"onShowPrevious",
"onShowMore",
"classNames",
"translations"
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-InfiniteHits', classNames.root, hits.length === 0 && cx('ais-InfiniteHits--empty', classNames.emptyRoot), props.className)
}), onShowPrevious && /*#__PURE__*/ React.createElement("button", {
className: cx('ais-InfiniteHits-loadPrevious', classNames.loadPrevious, isFirstPage && cx('ais-InfiniteHits-loadPrevious--disabled', classNames.disabledLoadPrevious)),
onClick: onShowPrevious,
disabled: isFirstPage
}, translations.showPreviousButtonText), banner && (BannerComponent ? /*#__PURE__*/ React.createElement(BannerComponent, {
className: cx('ais-InfiniteHits-banner', classNames.bannerRoot),
banner: banner
}) : /*#__PURE__*/ React.createElement(DefaultBanner, {
classNames: classNames,
banner: banner
})), /*#__PURE__*/ React.createElement("ol", {
className: cx('ais-InfiniteHits-list', classNames.list)
}, hits.map(function(hit) {
return /*#__PURE__*/ React.createElement("li", {
key: hit.objectID,
className: cx('ais-InfiniteHits-item', classNames.item),
onClick: function onClick() {
sendEvent('click:internal', hit, 'Hit Clicked');
},
onAuxClick: function onAuxClick() {
sendEvent('click:internal', hit, 'Hit Clicked');
}
}, /*#__PURE__*/ React.createElement(HitComponent, {
hit: hit,
sendEvent: sendEvent
}));
})), /*#__PURE__*/ React.createElement("button", {
className: cx('ais-InfiniteHits-loadMore', classNames.loadMore, isLastPage && cx('ais-InfiniteHits-loadMore--disabled', classNames.disabledLoadMore)),
onClick: onShowMore,
disabled: isLastPage
}, translations.showMoreButtonText));
}
function InfiniteHits(_0) {
var tmp = _0.showPrevious, shouldShowPrevious = tmp === void 0 ? true : tmp, cache = _0.cache, escapeHTML = _0.escapeHTML, transformItems = _0.transformItems, translations = _0.translations, BannerComponent = _0.bannerComponent, props = _object_without_properties(_0, [
"showPrevious",
"cache",
"escapeHTML",
"transformItems",
"translations",
"bannerComponent"
]);
var _useInfiniteHits = useInfiniteHits({
cache: cache,
escapeHTML: escapeHTML,
showPrevious: shouldShowPrevious,
transformItems: transformItems
}, {
$$widgetType: 'ais.infiniteHits'
}), items = _useInfiniteHits.items, banner = _useInfiniteHits.banner, sendEvent = _useInfiniteHits.sendEvent, showPrevious = _useInfiniteHits.showPrevious, showMore = _useInfiniteHits.showMore, isFirstPage = _useInfiniteHits.isFirstPage, isLastPage = _useInfiniteHits.isLastPage;
var bannerComponent = BannerComponent === false ? function() {
return null;
} : BannerComponent;
var uiProps = {
hits: items,
banner: banner,
bannerComponent: bannerComponent,
sendEvent: sendEvent,
onShowPrevious: shouldShowPrevious ? showPrevious : undefined,
onShowMore: showMore,
isFirstPage: isFirstPage,
isLastPage: isLastPage,
translations: _object_spread({
showPreviousButtonText: 'Show previous results',
showMoreButtonText: 'Show more results'
}, translations)
};
return /*#__PURE__*/ React.createElement(InfiniteHits$1, _object_spread({}, props, uiProps));
}
var LookingSimilarUiComponent = createLookingSimilarComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
function LookingSimilar(_0) {
var objectIDs = _0.objectIDs, limit = _0.limit, threshold = _0.threshold, queryParameters = _0.queryParameters, fallbackParameters = _0.fallbackParameters, escapeHTML = _0.escapeHTML, transformItems = _0.transformItems, itemComponent = _0.itemComponent, headerComponent = _0.headerComponent, emptyComponent = _0.emptyComponent, layoutComponent = _0.layoutComponent, props = _object_without_properties(_0, [
"objectIDs",
"limit",
"threshold",
"queryParameters",
"fallbackParameters",
"escapeHTML",
"transformItems",
"itemComponent",
"headerComponent",
"emptyComponent",
"layoutComponent"
]);
var status = useInstantSearch().status;
var _useLookingSimilar = useLookingSimilar({
objectIDs: objectIDs,
limit: limit,
threshold: threshold,
queryParameters: queryParameters,
fallbackParameters: fallbackParameters,
escapeHTML: escapeHTML,
transformItems: transformItems
}, {
$$widgetType: 'ais.lookingSimilar'
}), items = _useLookingSimilar.items, sendEvent = _useLookingSimilar.sendEvent;
var layout = layoutComponent ? function(layoutProps) {
return layoutComponent(_object_spread_props(_object_spread({}, layoutProps), {
classNames: {
list: layoutProps.classNames.list,
item: layoutProps.classNames.item
}
}));
} : undefined;
var _itemComponent = React.useMemo(function() {
return itemComponent ? function(itemProps) {
return itemComponent(_object_spread_props(_object_spread({}, itemProps), {
sendEvent: sendEvent
}));
} : undefined;
}, [
itemComponent,
sendEvent
]);
var uiProps = {
items: items,
itemComponent: _itemComponent,
headerComponent: headerComponent,
emptyComponent: emptyComponent,
layout: layout,
status: status,
sendEvent: sendEvent
};
return /*#__PURE__*/ React.createElement(LookingSimilarUiComponent, _object_spread({}, props, uiProps));
}
function Menu$1(_0) {
var items = _0.items, _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, showMore = _0.showMore, canToggleShowMore = _0.canToggleShowMore, onToggleShowMore = _0.onToggleShowMore, isShowingMore = _0.isShowingMore, createURL = _0.createURL, onRefine = _0.onRefine, translations = _0.translations, props = _object_without_properties(_0, [
"items",
"classNames",
"showMore",
"canToggleShowMore",
"onToggleShowMore",
"isShowingMore",
"createURL",
"onRefine",
"translations"
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-Menu', classNames.root, items.length === 0 && cx('ais-Menu--noRefinement', classNames.noRefinementRoot), props.className)
}), /*#__PURE__*/ React.createElement("ul", {
className: cx('ais-Menu-list', classNames.list)
}, items.map(function(item) {
return /*#__PURE__*/ React.createElement("li", {
key: item.label,
className: cx('ais-Menu-item', classNames.item, item.isRefined && cx('ais-Menu-item--selected', classNames.selectedItem))
}, /*#__PURE__*/ React.createElement("a", {
className: cx('ais-Menu-link', classNames.link),
href: createURL(item.value),
onClick: function onClick(event) {
if (isModifierClick(event)) {
return;
}
event.preventDefault();
onRefine(item);
}
}, /*#__PURE__*/ React.createElement("span", {
className: cx('ais-Menu-label', classNames.label)
}, item.label), /*#__PURE__*/ React.createElement("span", {
className: cx('ais-Menu-count', classNames.count)
}, item.count)));
})), showMore && /*#__PURE__*/ React.createElement(ShowMoreButton, {
className: cx('ais-Menu-showMore', classNames.showMore, !canToggleShowMore && cx('ais-Menu-showMore--disabled', classNames.disabledShowMore)),
disabled: !canToggleShowMore,
onClick: onToggleShowMore,
isShowingMore: isShowingMore,
translations: translations
}));
}
function Menu(_0) {
var attribute = _0.attribute, limit = _0.limit, showMore = _0.showMore, showMoreLimit = _0.showMoreLimit, sortBy = _0.sortBy, transformItems = _0.transformItems, translations = _0.translations, props = _object_without_properties(_0, [
"attribute",
"limit",
"showMore",
"showMoreLimit",
"sortBy",
"transformItems",
"translations"
]);
var _useMenu = useMenu({
attribute: attribute,
limit: limit,
showMore: showMore,
showMoreLimit: showMoreLimit,
sortBy: sortBy,
transformItems: transformItems
}, {
$$widgetType: 'ais.menu'
}), canToggleShowMore = _useMenu.canToggleShowMore, isShowingMore = _useMenu.isShowingMore, items = _useMenu.items, refine = _useMenu.refine, createURL = _useMenu.createURL, toggleShowMore = _useMenu.toggleShowMore;
var uiProps = {
items: items,
createURL: createURL,
onRefine: function onRefine(item) {
return refine(item.value);
},
canToggleShowMore: canToggleShowMore,
onToggleShowMore: toggleShowMore,
isShowingMore: isShowingMore,
translations: _object_spread({
showMoreButtonText: function showMoreButtonText(options) {
return options.isShowingMore ? 'Show less' : 'Show more';
}
}, translations)
};
return /*#__PURE__*/ React.createElement(Menu$1, _object_spread_props(_object_spread({}, props, uiProps), {
showMore: showMore
}));
}
function Pagination$1(_0) {
var pages = _0.pages, currentPage = _0.currentPage, nbPages = _0.nbPages, isFirstPage = _0.isFirstPage, isLastPage = _0.isLastPage, _0_showFirst = _0.showFirst, showFirst = _0_showFirst === void 0 ? true : _0_showFirst, _0_showPrevious = _0.showPrevious, showPrevious = _0_showPrevious === void 0 ? true : _0_showPrevious, _0_showNext = _0.showNext, showNext = _0_showNext === void 0 ? true : _0_showNext, _0_showLast = _0.showLast, showLast = _0_showLast === void 0 ? true : _0_showLast, createURL = _0.createURL, onNavigate = _0.onNavigate, translations = _0.translations, _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, props = _object_without_properties(_0, [
"pages",
"currentPage",
"nbPages",
"isFirstPage",
"isLastPage",
"showFirst",
"showPrevious",
"showNext",
"showLast",
"createURL",
"onNavigate",
"translations",
"classNames"
]);
var firstPageIndex = 0;
var previousPageIndex = currentPage - 1;
var nextPageIndex = currentPage + 1;
var lastPageIndex = nbPages - 1;
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-Pagination', classNames.root, nbPages <= 1 && cx('ais-Pagination--noRefinement', classNames.noRefinementRoot), props.className)
}), /*#__PURE__*/ React.createElement("ul", {
className: cx('ais-Pagination-list', classNames.list)
}, showFirst && /*#__PURE__*/ React.createElement(PaginationItem, {
isDisabled: isFirstPage,
className: cx('ais-Pagination-item--firstPage', classNames.firstPageItem),
classNames: classNames,
"aria-label": translations.firstPageItemAriaLabel,
href: createURL(firstPageIndex),
onClick: function onClick() {
return onNavigate(firstPageIndex);
}
}, translations.firstPageItemText), showPrevious && /*#__PURE__*/ React.createElement(PaginationItem, {
isDisabled: isFirstPage,
className: cx('ais-Pagination-item--previousPage', classNames.previousPageItem),
classNames: classNames,
"aria-label": translations.previousPageItemAriaLabel,
href: createURL(previousPageIndex),
onClick: function onClick() {
return onNavigate(previousPageIndex);
}
}, translations.previousPageItemText), pages.map(function(page) {
return /*#__PURE__*/ React.createElement(PaginationItem, {
key: page,
isDisabled: false,
className: cx('ais-Pagination-item--page', classNames.pageItem, page === currentPage && cx('ais-Pagination-item--selected', classNames.selectedItem)),
classNames: classNames,
"aria-label": translations.pageItemAriaLabel({
currentPage: page + 1,
nbPages: nbPages
}),
"aria-current": page === currentPage ? 'page' : undefined,
href: createURL(page),
onClick: function onClick() {
return onNavigate(page);
}
}, translations.pageItemText({
currentPage: page + 1,
nbPages: nbPages
}));
}), showNext && /*#__PURE__*/ React.createElement(PaginationItem, {
isDisabled: isLastPage,
className: cx('ais-Pagination-item--nextPage', classNames.nextPageItem),
classNames: classNames,
"aria-label": translations.nextPageItemAriaLabel,
href: createURL(nextPageIndex),
onClick: function onClick() {
return onNavigate(nextPageIndex);
}
}, translations.nextPageItemText), showLast && /*#__PURE__*/ React.createElement(PaginationItem, {
isDisabled: isLastPage,
className: cx('ais-Pagination-item--lastPage', classNames.lastPageItem),
classNames: classNames,
"aria-label": translations.lastPageItemAriaLabel,
href: createURL(lastPageIndex),
onClick: function onClick() {
return onNavigate(lastPageIndex);
}
}, translations.lastPageItemText)));
}
function PaginationItem(_0) {
var isDisabled = _0.isDisabled, className = _0.className, classNames = _0.classNames, href = _0.href, onClick = _0.onClick, props = _object_without_properties(_0, [
"isDisabled",
"className",
"classNames",
"href",
"onClick"
]);
if (isDisabled) {
return /*#__PURE__*/ React.createElement("li", {
className: cx('ais-Pagination-item', classNames.item, 'ais-Pagination-item--disabled', classNames.disabledItem, className)
}, /*#__PURE__*/ React.createElement("span", _object_spread({
className: cx('ais-Pagination-link', classNames.link)
}, props)));
}
return /*#__PURE__*/ React.createElement("li", {
className: cx('ais-Pagination-item', classNames.item, className)
}, /*#__PURE__*/ React.createElement("a", _object_spread({
className: cx('ais-Pagination-link', classNames.link),
href: href,
onClick: function onClick1(event) {
if (isModifierClick(event)) {
return;
}
event.preventDefault();
onClick(event);
}
}, props)));
}
function Pagination(_0) {
var showFirst = _0.showFirst, showPrevious = _0.showPrevious, showNext = _0.showNext, showLast = _0.showLast, padding = _0.padding, totalPages = _0.totalPages, translations = _0.translations, props = _object_without_properties(_0, [
"showFirst",
"showPrevious",
"showNext",
"showLast",
"padding",
"totalPages",
"translations"
]);
var _usePagination = usePagination({
padding: padding,
totalPages: totalPages
}, {
$$widgetType: 'ais.pagination'
}), pages = _usePagination.pages, currentRefinement = _usePagination.currentRefinement, isFirstPage = _usePagination.isFirstPage, isLastPage = _usePagination.isLastPage, nbPages = _usePagination.nbPages, createURL = _usePagination.createURL, refine = _usePagination.refine;
var uiProps = {
pages: pages,
currentPage: currentRefinement,
isFirstPage: isFirstPage,
isLastPage: isLastPage,
nbPages: nbPages,
createURL: createURL,
onNavigate: refine,
translations: _object_spread({
firstPageItemText: '‹‹',
previousPageItemText: '‹',
nextPageItemText: '›',
lastPageItemText: '››',
pageItemText: function pageItemText(param) {
var currentPage = param.currentPage;
return String(currentPage);
},
firstPageItemAriaLabel: 'First Page',
previousPageItemAriaLabel: 'Previous Page',
nextPageItemAriaLabel: 'Next Page',
lastPageItemAriaLabel: "Last Page, Page ".concat(nbPages),
pageItemAriaLabel: function pageItemAriaLabel(param) {
var currentPage = param.currentPage;
return "Page ".concat(currentPage);
}
}, translations)
};
return /*#__PURE__*/ React.createElement(Pagination$1, _object_spread_props(_object_spread({}, props, uiProps), {
showFirst: showFirst,
showPrevious: showPrevious,
showNext: showNext,
showLast: showLast
}));
}
function PoweredBy$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, url = _0.url, _0_theme = _0.theme, theme = _0_theme === void 0 ? 'light' : _0_theme, props = _object_without_properties(_0, [
"classNames",
"url",
"theme"
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-PoweredBy', theme === 'dark' ? cx('ais-PoweredBy--dark', classNames.dark) : cx('ais-PoweredBy--light', classNames.light), classNames.root, props.className)
}), /*#__PURE__*/ React.createElement("a", {
href: url,
target: "_blank",
className: cx('ais-PoweredBy-link', classNames.link),
"aria-label": "Search by Algolia",
rel: "noopener noreferrer"
}, /*#__PURE__*/ React.createElement("svg", {
viewBox: "0 0 572 64",
className: cx('ais-PoweredBy-logo', classNames.logo)
}, /*#__PURE__*/ React.createElement("path", {
fill: theme === 'dark' ? '#FFF' : '#36395A',
d: "M16 48.3c-3.4 0-6.3-.6-8.7-1.7A12.4 12.4 0 0 1 1.9 42C.6 40 0 38 0 35.4h6.5a6.7 6.7 0 0 0 3.9 6c1.4.7 3.3 1.1 5.6 1.1 2.2 0 4-.3 5.4-1a7 7 0 0 0 3-2.4 6 6 0 0 0 1-3.4c0-1.5-.6-2.8-1.9-3.7-1.3-1-3.3-1.6-5.9-1.8l-4-.4c-3.7-.3-6.6-1.4-8.8-3.4a10 10 0 0 1-3.3-7.9c0-2.4.6-4.6 1.8-6.4a12 12 0 0 1 5-4.3c2.2-1 4.7-1.6 7.5-1.6s5.5.5 7.6 1.6a12 12 0 0 1 5 4.4c1.2 1.8 1.8 4 1.8 6.7h-6.5a6.4 6.4 0 0 0-3.5-5.9c-1-.6-2.6-1-4.4-1s-3.2.3-4.4 1c-1.1.6-2 1.4-2.6 2.4-.5 1-.8 2-.8 3.1a5 5 0 0 0 1.5 3.6c1 1 2.6 1.7 4.7 1.9l4 .3c2.8.2 5.2.8 7.2 1.8 2.1 1 3.7 2.2 4.9 3.8a9.7 9.7 0 0 1 1.7 5.8c0 2.5-.7 4.7-2 6.6a13 13 0 0 1-5.6 4.4c-2.4 1-5.2 1.6-8.4 1.6Zm35.6 0c-2.6 0-4.8-.4-6.7-1.3a13 13 0 0 1-4.7-3.5 17.1 17.1 0 0 1-3.6-10.4v-1c0-2 .3-3.8 1-5.6a13 13 0 0 1 7.3-8.3 15 15 0 0 1 6.3-1.4A13.2 13.2 0 0 1 64 24.3c1 2.2 1.6 4.6 1.6 7.2V34H39.4v-4.3h21.8l-1.8 2.2c0-2-.3-3.7-.9-5.1a7.3 7.3 0 0 0-2.7-3.4c-1.2-.7-2.7-1.1-4.6-1.1s-3.4.4-4.7 1.3a8 8 0 0 0-2.9 3.6c-.6 1.5-.9 3.3-.9 5.4 0 2 .3 3.7 1 5.3a7.9 7.9 0 0 0 2.8 3.7c1.3.8 3 1.3 5 1.3s3.8-.5 5.1-1.3c1.3-1 2.1-2 2.4-3.2h6a11.8 11.8 0 0 1-7 8.7 16 16 0 0 1-6.4 1.2ZM80 48c-2.2 0-4-.3-5.7-1a8.4 8.4 0 0 1-3.7-3.3 9.7 9.7 0 0 1-1.3-5.2c0-2 .5-3.8 1.5-5.2a9 9 0 0 1 4.3-3.1c1.8-.7 4-1 6.7-1H89v4.1h-7.5c-2 0-3.4.5-4.4 1.4-1 1-1.6 2.1-1.6 3.6s.5 2.7 1.6 3.6c1 1 2.5 1.4 4.4 1.4 1.1 0 2.2-.2 3.2-.7 1-.4 1.9-1 2.6-2 .6-1 1-2.4 1-4.2l1.7 2.1c-.2 2-.7 3.8-1.5 5.2a9 9 0 0 1-3.4 3.3 12 12 0 0 1-5.3 1Zm9.5-.7v-8.8h-1v-10c0-1.8-.5-3.2-1.4-4.1-1-1-2.4-1.4-4.2-1.4a142.9 142.9 0 0 0-10.2.4v-5.6a74.8 74.8 0 0 1 8.6-.4c3 0 5.5.4 7.5 1.2s3.4 2 4.4 3.6c1 1.7 1.4 4 1.4 6.7v18.4h-5Zm12.9 0V17.8h5v12.3h-.2c0-4.2 1-7.4 2.8-9.5a11 11 0 0 1 8.3-3.1h1v5.6h-2a9 9 0 0 0-6.3 2.2c-1.5 1.5-2.2 3.6-2.2 6.4v15.6h-6.4Zm34.4 1a15 15 0 0 1-6.6-1.3c-1.9-.9-3.4-2-4.7-3.5a15.5 15.5 0 0 1-2.7-5c-.6-1.7-1-3.6-1-5.4v-1c0-2 .4-3.8 1-5.6a15 15 0 0 1 2.8-4.9c1.3-1.5 2.8-2.6 4.6-3.5a16.4 16.4 0 0 1 13.3.2c2 1 3.5 2.3 4.8 4a12 12 0 0 1 2 6H144c-.2-1.6-1-3-2.2-4.1a7.5 7.5 0 0 0-5.2-1.7 8 8 0 0 0-4.7 1.3 8 8 0 0 0-2.8 3.6 13.8 13.8 0 0 0 0 10.3c.6 1.5 1.5 2.7 2.8 3.6s2.8 1.3 4.8 1.3c1.5 0 2.7-.2 3.8-.8a7 7 0 0 0 2.6-2c.7-1 1-2 1.2-3.2h6.2a11 11 0 0 1-2 6.2 15.1 15.1 0 0 1-11.8 5.5Zm19.7-1v-40h6.4V31h-1.3c0-3 .4-5.5 1.1-7.6a9.7 9.7 0 0 1 3.5-4.8A9.9 9.9 0 0 1 172 17h.3c3.5 0 6 1.1 7.9 3.5 1.7 2.3 2.6 5.7 2.6 10v16.8h-6.4V29.6c0-2.1-.6-3.8-1.8-5a6.4 6.4 0 0 0-4.8-1.8c-2 0-3.7.7-5 2a7.8 7.8 0 0 0-1.9 5.5v17h-6.4Zm63.8 1a12.2 12.2 0 0 1-10.9-6.2 19 19 0 0 1-1.8-7.3h1.4v12.5h-5.1v-40h6.4v19.8l-2 3.5c.2-3.1.8-5.7 1.9-7.7a11 11 0 0 1 4.4-4.5c1.8-1 3.9-1.5 6.1-1.5a13.4 13.4 0 0 1 12.8 9.1c.7 1.9 1 3.8 1 6v1c0 2.2-.3 4.1-1 6a13.6 13.6 0 0 1-13.2 9.4Zm-1.2-5.5a8.4 8.4 0 0 0 7.9-5c.7-1.5 1.1-3.3 1.1-5.3s-.4-3.8-1.1-5.3a8.7 8.7 0 0 0-3.2-3.6 9.6 9.6 0 0 0-9.2-.2 8.5 8.5 0 0 0-3.3 3.2c-.8 1.4-1.3 3-1.3 5v2.3a9 9 0 0 0 1.3 4.8 9 9 0 0 0 3.4 3c1.4.7 2.8 1 4.4 1Zm27.3 3.9-10-28.9h6.5l9.5 28.9h-6Zm-7.5 12.2v-5.7h4.9c1 0 2-.1 2.9-.4a4 4 0 0 0 2-1.4c.4-.7.9-1.6 1.2-2.7l8.6-30.9h6.2l-9.3 32.4a14 14 0 0 1-2.5 5 8.9 8.9 0 0 1-4 2.8c-1.5.6-3.4.9-5.6.9h-4.4Zm9-12.2v-5.2h6.4v5.2H248Z"
}), /*#__PURE__*/ React.createElement("path", {
fill: theme === 'dark' ? '#FFF' : '#003DFF',
d: "M534.4 9.1H528a.8.8 0 0 1-.7-.7V1.8c0-.4.2-.7.6-.8l6.5-1c.4 0 .8.2.9.6v7.8c0 .4-.4.7-.8.7zM428 35.2V.8c0-.5-.3-.8-.7-.8h-.2l-6.4 1c-.4 0-.7.4-.7.8v35c0 1.6 0 11.8 12.3 12.2.5 0 .8-.4.8-.8V43c0-.4-.3-.7-.6-.8-4.5-.5-4.5-6-4.5-7zm106.5-21.8H528c-.4 0-.7.4-.7.8v34c0 .4.3.8.7.8h6.5c.4 0 .8-.4.8-.8v-34c0-.5-.4-.8-.8-.8zm-17.7 21.8V.8c0-.5-.3-.8-.8-.8l-6.5 1c-.4 0-.7.4-.7.8v35c0 1.6 0 11.8 12.3 12.2.4 0 .8-.4.8-.8V43c0-.4-.3-.7-.7-.8-4.4-.5-4.4-6-4.4-7zm-22.2-20.6a16.5 16.5 0 0 1 8.6 9.3c.8 2.2 1.3 4.8 1.3 7.5a19.4 19.4 0 0 1-4.6 12.6 14.8 14.8 0 0 1-5.2 3.6c-2 .9-5.2 1.4-6.8 1.4a21 21 0 0 1-6.7-1.4 15.4 15.4 0 0 1-8.6-9.3 21.3 21.3 0 0 1 0-14.4 15.2 15.2 0 0 1 8.6-9.3c2-.8 4.3-1.2 6.7-1.2s4.6.4 6.7 1.2zm-6.7 27.6c2.7 0 4.7-1 6.2-3s2.2-4.3 2.2-7.8-.7-6.3-2.2-8.3-3.5-3-6.2-3-4.7 1-6.1 3c-1.5 2-2.2 4.8-2.2 8.3s.7 5.8 2.2 7.8 3.5 3 6.2 3zm-88.8-28.8c-6.2 0-11.7 3.3-14.8 8.2a18.6 18.6 0 0 0 4.8 25.2c1.8 1.2 4 1.8 6.2 1.7s.1 0 .1 0h.9c4.2-.7 8-4 9.1-8.1v7.4c0 .4.3.7.8.7h6.4a.7.7 0 0 0 .7-.7V14.2c0-.5-.3-.8-.7-.8h-13.5zm6.3 26.5a9.8 9.8 0 0 1-5.7 2h-.5a10 10 0 0 1-9.2-14c1.4-3.7 5-6.3 9-6.3h6.4v18.3zm152.3-26.5h13.5c.5 0 .8.3.8.7v33.7c0 .4-.3.7-.8.7h-6.4a.7.7 0 0 1-.8-.7v-7.4c-1.2 4-4.8 7.4-9 8h-.1a4.2 4.2 0 0 1-.5.1h-.9a10.3 10.3 0 0 1-7-2.6c-4-3.3-6.5-8.4-6.5-14.2 0-3.7 1-7.2 3-10 3-5 8.5-8.3 14.7-8.3zm.6 28.4c2.2-.1 4.2-.6 5.7-2V21.7h-6.3a9.8 9.8 0 0 0-9 6.4 10.2 10.2 0 0 0 9.1 13.9h.5zM452.8 13.4c-6.2 0-11.7 3.3-14.8 8.2a18.5 18.5 0 0 0 3.6 24.3 10.4 10.4 0 0 0 13 .6c2.2-1.5 3.8-3.7 4.5-6.1v7.8c0 2.8-.8 5-2.2 6.3-1.5 1.5-4 2.2-7.5 2.2l-6-.3c-.3 0-.7.2-.8.5l-1.6 5.5c-.1.4.1.8.5 1h.1c2.8.4 5.5.6 7 .6 6.3 0 11-1.4 14-4.1 2.7-2.5 4.2-6.3 4.5-11.4V14.2c0-.5-.4-.8-.8-.8h-13.5zm6.3 8.2v18.3a9.6 9.6 0 0 1-5.6 2h-1a10.3 10.3 0 0 1-8.8-14c1.4-3.7 5-6.3 9-6.3h6.4zM291 31.5A32 32 0 0 1 322.8 0h30.8c.6 0 1.2.5 1.2 1.2v61.5c0 1.1-1.3 1.7-2.2 1l-19.2-17a18 18 0 0 1-11 3.4 18.1 18.1 0 1 1 18.2-14.8c-.1.4-.5.7-.9.6-.1 0-.3 0-.4-.2l-3.8-3.4c-.4-.3-.6-.8-.7-1.4a12 12 0 1 0-2.4 8.3c.4-.4 1-.5 1.6-.2l14.7 13.1v-46H323a26 26 0 1 0 10 49.7c.8-.4 1.6-.2 2.3.3l3 2.7c.3.2.3.7 0 1l-.2.2a32 32 0 0 1-47.2-28.6z"
}))));
}
function PoweredBy(props) {
var url = usePoweredBy().url;
var uiProps = {
url: url
};
return /*#__PURE__*/ React.createElement(PoweredBy$1, _object_spread({}, props, uiProps));
}
// if the default value is undefined, React considers the component uncontrolled initially, which we don't want 0 or NaN as the default value
var unsetNumberInputValue = '';
// Strips leading `0` from a positive number value
function stripLeadingZeroFromInput(value) {
return value.replace(/^(0+)\d/, function(part) {
return Number(part).toString();
});
}
function RangeInput$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, _0_range = _0.range, min = _0_range.min, max = _0_range.max, _0_start = _sliced_to_array(_0.start, 2), minValue = _0_start[0], maxValue = _0_start[1], _0_step = _0.step, step = _0_step === void 0 ? 1 : _0_step, disabled = _0.disabled, onSubmit = _0.onSubmit, translations = _0.translations, props = _object_without_properties(_0, [
"classNames",
"range",
"start",
"step",
"disabled",
"onSubmit",
"translations"
]);
var _values_min, _values_max;
var values = {
min: minValue !== -Infinity && minValue !== min ? minValue : unsetNumberInputValue,
max: maxValue !== Infinity && maxValue !== max ? maxValue : unsetNumberInputValue
};
var _useState = _sliced_to_array(React.useState(values), 2), prevValues = _useState[0], setPrevValues = _useState[1];
var _useState1 = _sliced_to_array(React.useState({
from: (_values_min = values.min) === null || _values_min === void 0 ? void 0 : _values_min.toString(),
to: (_values_max = values.max) === null || _values_max === void 0 ? void 0 : _values_max.toString()
}), 2), _useState_ = _useState1[0], from = _useState_.from, to = _useState_.to, setRange = _useState1[1];
if (values.min !== prevValues.min || values.max !== prevValues.max) {
var _values_min1, _values_max1;
setRange({
from: (_values_min1 = values.min) === null || _values_min1 === void 0 ? void 0 : _values_min1.toString(),
to: (_values_max1 = values.max) === null || _values_max1 === void 0 ? void 0 : _values_max1.toString()
});
setPrevValues(values);
}
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx(cx('ais-RangeInput', classNames.root), disabled && cx('ais-RangeInput--noRefinement', classNames.noRefinementRoot), props.className)
}), /*#__PURE__*/ React.createElement("form", {
className: cx('ais-RangeInput-form', classNames.form),
onSubmit: function onSubmit1(event) {
event.preventDefault();
onSubmit([
from ? Number(from) : undefined,
to ? Number(to) : undefined
]);
}
}, /*#__PURE__*/ React.createElement("label", {
className: cx('ais-RangeInput-label', classNames.label)
}, /*#__PURE__*/ React.createElement("input", {
className: cx('ais-RangeInput-input', classNames.input, 'ais-RangeInput-input--min', classNames.inputMin),
type: "number",
min: min,
max: max,
value: stripLeadingZeroFromInput(from || unsetNumberInputValue),
step: step,
placeholder: min === null || min === void 0 ? void 0 : min.toString(),
disabled: disabled,
onInput: function onInput(param) {
var currentTarget = param.currentTarget;
var value = currentTarget.value;
setRange({
from: value || unsetNumberInputValue,
to: to
});
}
})), /*#__PURE__*/ React.createElement("span", {
className: cx('ais-RangeInput-separator', classNames.separator)
}, translations.separatorElementText), /*#__PURE__*/ React.createElement("label", {
className: cx('ais-RangeInput-label', classNames.label)
}, /*#__PURE__*/ React.createElement("input", {
className: cx('ais-RangeInput-input', classNames.input, 'ais-RangeInput-input--max', classNames.inputMax),
type: "number",
min: min,
max: max,
value: stripLeadingZeroFromInput(to || unsetNumberInputValue),
step: step,
placeholder: max === null || max === void 0 ? void 0 : max.toString(),
disabled: disabled,
onInput: function onInput(param) {
var currentTarget = param.currentTarget;
var value = currentTarget.value;
setRange({
from: from,
to: value || unsetNumberInputValue
});
}
})), /*#__PURE__*/ React.createElement("button", {
className: cx('ais-RangeInput-submit', classNames.submit),
type: "submit"
}, translations.submitButtonText)));
}
function RangeInput(_0) {
var attribute = _0.attribute, min = _0.min, max = _0.max, precision = _0.precision, translations = _0.translations, props = _object_without_properties(_0, [
"attribute",
"min",
"max",
"precision",
"translations"
]);
var _useRange = useRange({
attribute: attribute,
min: min,
max: max,
precision: precision
}, {
$$widgetType: 'ais.rangeInput'
}), range = _useRange.range, start = _useRange.start, canRefine = _useRange.canRefine, refine = _useRange.refine;
var step = 1 / Math.pow(10, precision || 0);
var uiProps = {
range: range,
start: start,
step: step,
disabled: !canRefine,
onSubmit: refine,
translations: _object_spread({
separatorElementText: 'to',
submitButtonText: 'Go'
}, translations)
};
return /*#__PURE__*/ React.createElement(RangeInput$1, _object_spread({}, props, uiProps));
}
function RefinementList$1(_0) {
_0.canRefine; var items = _0.items, onRefine = _0.onRefine, query = _0.query, searchBox = _0.searchBox, noResults = _0.noResults, showMore = _0.showMore, canToggleShowMore = _0.canToggleShowMore, onToggleShowMore = _0.onToggleShowMore, isShowingMore = _0.isShowingMore, className = _0.className, _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, translations = _0.translations, props = _object_without_properties(_0, [
"canRefine",
"items",
"onRefine",
"query",
"searchBox",
"noResults",
"showMore",
"canToggleShowMore",
"onToggleShowMore",
"isShowingMore",
"className",
"classNames",
"translations"
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-RefinementList', classNames.root, items.length === 0 && cx('ais-RefinementList--noRefinement', classNames.noRefinementRoot), className)
}), searchBox && /*#__PURE__*/ React.createElement("div", {
className: cx('ais-RefinementList-searchBox', classNames.searchBox)
}, searchBox), noResults ? /*#__PURE__*/ React.createElement("div", {
className: cx('ais-RefinementList-noResults', classNames.noResults)
}, noResults) : /*#__PURE__*/ React.createElement("ul", {
className: cx('ais-RefinementList-list', classNames.list)
}, items.map(function(item) {
return /*#__PURE__*/ React.createElement("li", {
key: item.value,
className: cx('ais-RefinementList-item', classNames.item, item.isRefined && cx('ais-RefinementList-item--selected', classNames.selectedItem))
}, /*#__PURE__*/ React.createElement("label", {
className: cx('ais-RefinementList-label', classNames.label)
}, /*#__PURE__*/ React.createElement("input", {
checked: item.isRefined,
className: cx('ais-RefinementList-checkbox', classNames.checkbox),
type: "checkbox",
value: item.value,
onChange: function onChange() {
onRefine(item);
}
}), /*#__PURE__*/ React.createElement("span", {
className: cx('ais-RefinementList-labelText', classNames.labelText)
}, query.length > 0 ? /*#__PURE__*/ React.createElement(Highlight$1, {
parts: [
getHighlightedParts(unescape$1(item.highlighted || ''))
]
}) : item.label), /*#__PURE__*/ React.createElement("span", {
className: cx('ais-RefinementList-count', classNames.count)
}, item.count)));
})), showMore && /*#__PURE__*/ React.createElement(ShowMoreButton, {
className: cx('ais-RefinementList-showMore', classNames.showMore, !canToggleShowMore && cx('ais-RefinementList-showMore--disabled', classNames.disabledShowMore)),
disabled: !canToggleShowMore,
onClick: onToggleShowMore,
isShowingMore: isShowingMore,
translations: translations
}));
}
function DefaultSubmitIcon(param) {
var classNames = param.classNames;
return /*#__PURE__*/ React.createElement("svg", {
className: cx('ais-SearchBox-submitIcon', classNames.submitIcon),
width: "10",
height: "10",
viewBox: "0 0 40 40",
"aria-hidden": "true"
}, /*#__PURE__*/ React.createElement("path", {
d: "M26.804 29.01c-2.832 2.34-6.465 3.746-10.426 3.746C7.333 32.756 0 25.424 0 16.378 0 7.333 7.333 0 16.378 0c9.046 0 16.378 7.333 16.378 16.378 0 3.96-1.406 7.594-3.746 10.426l10.534 10.534c.607.607.61 1.59-.004 2.202-.61.61-1.597.61-2.202.004L26.804 29.01zm-10.426.627c7.323 0 13.26-5.936 13.26-13.26 0-7.32-5.937-13.257-13.26-13.257C9.056 3.12 3.12 9.056 3.12 16.378c0 7.323 5.936 13.26 13.258 13.26z"
}));
}
function DefaultResetIcon(param) {
var classNames = param.classNames;
return /*#__PURE__*/ React.createElement("svg", {
className: cx('ais-SearchBox-resetIcon', classNames.resetIcon),
viewBox: "0 0 20 20",
width: "10",
height: "10",
"aria-hidden": "true"
}, /*#__PURE__*/ React.createElement("path", {
d: "M8.114 10L.944 2.83 0 1.885 1.886 0l.943.943L10 8.113l7.17-7.17.944-.943L20 1.886l-.943.943-7.17 7.17 7.17 7.17.943.944L18.114 20l-.943-.943-7.17-7.17-7.17 7.17-.944.943L0 18.114l.943-.943L8.113 10z"
}));
}
function DefaultLoadingIcon(param) {
var classNames = param.classNames;
return /*#__PURE__*/ React.createElement("svg", {
"aria-label": "Results are loading",
width: "16",
height: "16",
viewBox: "0 0 38 38",
stroke: "#444",
className: cx('ais-SearchBox-loadingIcon', classNames.loadingIcon),
"aria-hidden": "true"
}, /*#__PURE__*/ React.createElement("g", {
fill: "none",
fillRule: "evenodd"
}, /*#__PURE__*/ React.createElement("g", {
transform: "translate(1 1)",
strokeWidth: "2"
}, /*#__PURE__*/ React.createElement("circle", {
strokeOpacity: ".5",
cx: "18",
cy: "18",
r: "18"
}), /*#__PURE__*/ React.createElement("path", {
d: "M36 18c0-9.94-8.06-18-18-18"
}, /*#__PURE__*/ React.createElement("animateTransform", {
attributeName: "transform",
type: "rotate",
from: "0 18 18",
to: "360 18 18",
dur: "1s",
repeatCount: "indefinite"
})))));
}
function DefaultAiModeIcon(param) {
var classNames = param.classNames;
return /*#__PURE__*/ React.createElement("svg", {
className: cx('ais-AiModeButton-icon', classNames.aiModeIcon),
xmlns: "http://www.w3.org/2000/svg",
fill: "none",
viewBox: "0 0 20 20",
width: "16",
height: "16",
"aria-hidden": "true"
}, /*#__PURE__*/ React.createElement("path", {
fill: "currentColor",
fillRule: "evenodd",
d: "M10 1.875c.27 0 .51.173.594.43l1.593 4.844a1.043 1.043 0 0 0 .664.664l4.844 1.593a.625.625 0 0 1 0 1.188l-4.844 1.593a1.043 1.043 0 0 0-.664.664l-1.593 4.844a.625.625 0 0 1-1.188 0l-1.593-4.844a1.042 1.042 0 0 0-.664-.664l-4.844-1.593a.625.625 0 0 1 0-1.188l4.844-1.593a1.042 1.042 0 0 0 .664-.664l1.593-4.844a.625.625 0 0 1 .594-.43ZM9 7.539A2.292 2.292 0 0 1 7.54 9L4.5 10l3.04 1A2.292 2.292 0 0 1 9 12.46l1 3.04 1-3.04A2.293 2.293 0 0 1 12.46 11l3.04-1-3.04-1A2.292 2.292 0 0 1 11 7.54L10 4.5 9 7.54ZM4.167 1.875c.345 0 .625.28.625.625v3.333a.625.625 0 0 1-1.25 0V2.5c0-.345.28-.625.625-.625ZM15.833 13.542c.345 0 .625.28.625.625V17.5a.625.625 0 1 1-1.25 0v-3.333c0-.345.28-.625.625-.625Z",
clipRule: "evenodd"
}), /*#__PURE__*/ React.createElement("path", {
fill: "currentColor",
fillRule: "evenodd",
d: "M1.875 4.167c0-.346.28-.625.625-.625h3.333a.625.625 0 1 1 0 1.25H2.5a.625.625 0 0 1-.625-.625ZM13.542 15.833c0-.345.28-.625.625-.625H17.5a.625.625 0 0 1 0 1.25h-3.333a.625.625 0 0 1-.625-.625Z",
clipRule: "evenodd"
}));
}
function SearchBox$1(_0) {
var formRef = _0.formRef, inputRef = _0.inputRef, inputProps = _0.inputProps, isSearchStalled = _0.isSearchStalled, onChange = _0.onChange, onReset = _0.onReset, onSubmit = _0.onSubmit, _0_placeholder = _0.placeholder, placeholder = _0_placeholder === void 0 ? '' : _0_placeholder, value = _0.value, autoFocus = _0.autoFocus, tmp = _0.resetIconComponent, ResetIcon = tmp === void 0 ? DefaultResetIcon : tmp, tmp1 = _0.submitIconComponent, SubmitIcon = tmp1 === void 0 ? DefaultSubmitIcon : tmp1, tmp2 = _0.loadingIconComponent, LoadingIcon = tmp2 === void 0 ? DefaultLoadingIcon : tmp2, tmp3 = _0.aiModeIconComponent, AiModeIcon = tmp3 === void 0 ? DefaultAiModeIcon : tmp3, onAiModeClick = _0.onAiModeClick, _0_aiModeButtonDisabled = _0.aiModeButtonDisabled, aiModeButtonDisabled = _0_aiModeButtonDisabled === void 0 ? false : _0_aiModeButtonDisabled, _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, translations = _0.translations, props = _object_without_properties(_0, [
"formRef",
"inputRef",
"inputProps",
"isSearchStalled",
"onChange",
"onReset",
"onSubmit",
"placeholder",
"value",
"autoFocus",
"resetIconComponent",
"submitIconComponent",
"loadingIconComponent",
"aiModeIconComponent",
"onAiModeClick",
"aiModeButtonDisabled",
"classNames",
"translations"
]);
function handleSubmit(event) {
event.preventDefault();
event.stopPropagation();
if (onSubmit) {
onSubmit(event);
}
if (inputRef.current) {
inputRef.current.blur();
}
}
function handleReset(event) {
event.preventDefault();
event.stopPropagation();
onReset(event);
if (inputRef.current) {
inputRef.current.focus();
}
}
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-SearchBox', classNames.root, props.className)
}), /*#__PURE__*/ React.createElement("form", {
ref: formRef,
action: "",
className: cx('ais-SearchBox-form', classNames.form),
noValidate: true,
onSubmit: handleSubmit,
onReset: handleReset,
role: "search"
}, /*#__PURE__*/ React.createElement("input", _object_spread_props(_object_spread({}, inputProps), {
ref: inputRef,
className: cx('ais-SearchBox-input', classNames.input, inputProps === null || inputProps === void 0 ? void 0 : inputProps.className),
"aria-label": "Search",
autoComplete: "off",
autoCorrect: "off",
autoCapitalize: "off",
placeholder: placeholder,
spellCheck: false,
maxLength: 512,
type: "search",
value: value,
onChange: onChange,
onCompositionEnd: onChange,
autoFocus: autoFocus
})), /*#__PURE__*/ React.createElement("button", {
className: cx('ais-SearchBox-submit', classNames.submit),
type: "submit",
title: translations.submitButtonTitle,
"aria-label": translations.submitButtonTitle
}, /*#__PURE__*/ React.createElement(SubmitIcon, {
classNames: classNames
})), /*#__PURE__*/ React.createElement("button", {
className: cx('ais-SearchBox-reset', classNames.reset),
type: "reset",
title: translations.resetButtonTitle,
"aria-label": translations.resetButtonTitle,
hidden: value.length === 0 || isSearchStalled
}, /*#__PURE__*/ React.createElement(ResetIcon, {
classNames: classNames
})), onAiModeClick && /*#__PURE__*/ React.createElement("button", {
className: cx('ais-AiModeButton', classNames.aiModeButton),
type: "button",
title: translations.aiModeButtonTitle || 'AI Mode',
disabled: aiModeButtonDisabled,
onClick: function onClick(e) {
e.preventDefault();
onAiModeClick();
}
}, /*#__PURE__*/ React.createElement(AiModeIcon, {
classNames: classNames
}), /*#__PURE__*/ React.createElement("span", {
className: "ais-AiModeButton-label"
}, translations.aiModeButtonTitle || 'AI Mode')), /*#__PURE__*/ React.createElement("span", {
className: cx('ais-SearchBox-loadingIndicator', classNames.loadingIndicator),
hidden: !isSearchStalled
}, /*#__PURE__*/ React.createElement(LoadingIcon, {
classNames: classNames
}))));
}
function RefinementList(_0) {
var searchable = _0.searchable, searchablePlaceholder = _0.searchablePlaceholder, _0_searchableSelectOnSubmit = _0.searchableSelectOnSubmit, searchableSelectOnSubmit = _0_searchableSelectOnSubmit === void 0 ? true : _0_searchableSelectOnSubmit, attribute = _0.attribute, operator = _0.operator, limit = _0.limit, showMore = _0.showMore, showMoreLimit = _0.showMoreLimit, sortBy = _0.sortBy, escapeFacetValues = _0.escapeFacetValues, transformItems = _0.transformItems, translations = _0.translations, props = _object_without_properties(_0, [
"searchable",
"searchablePlaceholder",
"searchableSelectOnSubmit",
"attribute",
"operator",
"limit",
"showMore",
"showMoreLimit",
"sortBy",
"escapeFacetValues",
"transformItems",
"translations"
]);
var _useRefinementList = useRefinementList({
attribute: attribute,
operator: operator,
limit: limit,
showMore: showMore,
showMoreLimit: showMoreLimit,
sortBy: sortBy,
escapeFacetValues: escapeFacetValues,
transformItems: transformItems
}, {
$$widgetType: 'ais.refinementList'
}), canRefine = _useRefinementList.canRefine, canToggleShowMore = _useRefinementList.canToggleShowMore, isFromSearch = _useRefinementList.isFromSearch, isShowingMore = _useRefinementList.isShowingMore, items = _useRefinementList.items, refine = _useRefinementList.refine, searchForItems = _useRefinementList.searchForItems, toggleShowMore = _useRefinementList.toggleShowMore;
var _useState = _sliced_to_array(React.useState(''), 2), inputValue = _useState[0], setInputValue = _useState[1];
var inputRef = React.useRef(null);
function setQuery(newQuery) {
var compositionComplete = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
setInputValue(newQuery);
if (compositionComplete) {
searchForItems(newQuery);
}
}
function onRefine(item) {
refine(item.value);
setQuery('');
}
function onChange(event) {
var compositionComplete = event.type === 'compositionend' || !event.nativeEvent.isComposing;
setQuery(event.currentTarget.value, compositionComplete);
}
function onReset() {
setQuery('');
}
function onSubmit() {
if (searchableSelectOnSubmit === false) {
return;
}
if (items.length > 0) {
refine(items[0].value);
setQuery('');
}
}
var mergedTranslations = _object_spread({
resetButtonTitle: 'Clear the search query',
submitButtonTitle: 'Submit the search query',
noResultsText: 'No results.',
showMoreButtonText: function showMoreButtonText(options) {
return options.isShowingMore ? 'Show less' : 'Show more';
}
}, translations);
var uiProps = {
items: items,
canRefine: canRefine,
onRefine: onRefine,
query: inputValue,
searchBox: searchable && /*#__PURE__*/ React.createElement(SearchBox$1, {
inputRef: inputRef,
placeholder: searchablePlaceholder,
isSearchStalled: false,
value: inputValue,
onChange: onChange,
onReset: onReset,
onSubmit: onSubmit,
translations: {
submitButtonTitle: mergedTranslations.submitButtonTitle,
resetButtonTitle: mergedTranslations.resetButtonTitle
}
}),
noResults: searchable && isFromSearch && items.length === 0 && mergedTranslations.noResultsText,
canToggleShowMore: canToggleShowMore,
onToggleShowMore: toggleShowMore,
isShowingMore: isShowingMore,
translations: {
showMoreButtonText: mergedTranslations.showMoreButtonText,
showMoreButtonLabel: translations === null || translations === void 0 ? void 0 : translations.showMoreButtonLabel
}
};
return /*#__PURE__*/ React.createElement(RefinementList$1, _object_spread_props(_object_spread({}, props, uiProps), {
showMore: showMore
}));
}
var RelatedProductsUiComponent = createRelatedProductsComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
function RelatedProducts(_0) {
var objectIDs = _0.objectIDs, limit = _0.limit, threshold = _0.threshold, fallbackParameters = _0.fallbackParameters, queryParameters = _0.queryParameters, escapeHTML = _0.escapeHTML, transformItems = _0.transformItems, itemComponent = _0.itemComponent, headerComponent = _0.headerComponent, emptyComponent = _0.emptyComponent, layoutComponent = _0.layoutComponent, props = _object_without_properties(_0, [
"objectIDs",
"limit",
"threshold",
"fallbackParameters",
"queryParameters",
"escapeHTML",
"transformItems",
"itemComponent",
"headerComponent",
"emptyComponent",
"layoutComponent"
]);
var status = useInstantSearch().status;
var _useRelatedProducts = useRelatedProducts({
objectIDs: objectIDs,
limit: limit,
threshold: threshold,
fallbackParameters: fallbackParameters,
queryParameters: queryParameters,
escapeHTML: escapeHTML,
transformItems: transformItems
}, {
$$widgetType: 'ais.relatedProducts'
}), items = _useRelatedProducts.items, sendEvent = _useRelatedProducts.sendEvent;
var layout = layoutComponent ? function(layoutProps) {
return layoutComponent(_object_spread_props(_object_spread({}, layoutProps), {
classNames: {
list: layoutProps.classNames.list,
item: layoutProps.classNames.item
}
}));
} : undefined;
var _itemComponent = React.useMemo(function() {
return itemComponent ? function(itemProps) {
return itemComponent(_object_spread_props(_object_spread({}, itemProps), {
sendEvent: sendEvent
}));
} : undefined;
}, [
itemComponent,
sendEvent
]);
var uiProps = {
items: items,
itemComponent: _itemComponent,
headerComponent: headerComponent,
emptyComponent: emptyComponent,
layout: layout,
status: status,
sendEvent: sendEvent
};
return /*#__PURE__*/ React.createElement(RelatedProductsUiComponent, _object_spread({}, props, uiProps));
}
function SearchBox(_0) {
var queryHook = _0.queryHook, _0_searchAsYouType = _0.searchAsYouType, searchAsYouType = _0_searchAsYouType === void 0 ? true : _0_searchAsYouType, _0_ignoreCompositionEvents = _0.ignoreCompositionEvents, ignoreCompositionEvents = _0_ignoreCompositionEvents === void 0 ? false : _0_ignoreCompositionEvents, aiMode = _0.aiMode, translations = _0.translations, props = _object_without_properties(_0, [
"queryHook",
"searchAsYouType",
"ignoreCompositionEvents",
"aiMode",
"translations"
]);
var _useSearchBox = useSearchBox({
queryHook: queryHook
}, _object_spread({
$$widgetType: 'ais.searchBox'
}, aiMode ? {
opensChat: true
} : {})), query = _useSearchBox.query, refine = _useSearchBox.refine, isSearchStalled = _useSearchBox.isSearchStalled;
var indexRenderState = useInstantSearch().indexRenderState;
var _useState = _sliced_to_array(React.useState(query), 2), inputValue = _useState[0], setInputValue = _useState[1];
var inputRef = React.useRef(null);
function setQuery(newQuery) {
var isComposing = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
setInputValue(newQuery);
if (searchAsYouType && !(ignoreCompositionEvents && isComposing)) {
refine(newQuery);
}
}
function onReset() {
setQuery('');
if (!searchAsYouType) {
refine('');
}
}
function onChange(event) {
setQuery(event.currentTarget.value, event.nativeEvent.isComposing);
}
function onSubmit(event) {
if (!searchAsYouType) {
refine(inputValue);
}
if (props.onSubmit) {
props.onSubmit(event);
}
}
// Track when the InstantSearch query changes to synchronize it with
// the React state.
// We bypass the state update if the input is focused to avoid concurrent
// updates when typing.
if (query !== inputValue && document.activeElement !== inputRef.current) {
setInputValue(query);
}
var chatRenderState = indexRenderState.chat;
var uiProps = {
inputRef: inputRef,
isSearchStalled: isSearchStalled,
onChange: onChange,
onReset: onReset,
onSubmit: onSubmit,
onAiModeClick: aiMode ? function() {
if (openChat(chatRenderState, {
message: inputValue,
referer: 'ai-mode'
})) {
onReset();
}
} : undefined,
aiModeButtonDisabled: aiMode ? isChatBusy(chatRenderState) : undefined,
value: inputValue,
translations: _object_spread({
submitButtonTitle: 'Submit the search query',
resetButtonTitle: 'Clear the search query',
aiModeButtonTitle: 'AI Mode'
}, translations)
};
return /*#__PURE__*/ React.createElement(SearchBox$1, _object_spread({}, props, uiProps));
}
function Snippet$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, props = _object_without_properties(_0, [
"classNames"
]);
return /*#__PURE__*/ React.createElement(InternalHighlight, _object_spread({
classNames: {
root: cx('ais-Snippet', classNames.root),
highlighted: cx('ais-Snippet-highlighted', classNames.highlighted),
nonHighlighted: cx('ais-Snippet-nonHighlighted', classNames.nonHighlighted),
separator: cx('ais-Snippet-separator', classNames.separator)
}
}, props));
}
function Snippet(_0) {
var hit = _0.hit, attribute = _0.attribute, highlightedTagName = _0.highlightedTagName, nonHighlightedTagName = _0.nonHighlightedTagName, separator = _0.separator, props = _object_without_properties(_0, [
"hit",
"attribute",
"highlightedTagName",
"nonHighlightedTagName",
"separator"
]);
var property = getPropertyByPath(hit._snippetResult, attribute) || [];
var properties = Array.isArray(property) ? property : [
property
];
var parts = properties.map(function(singleValue) {
return getHighlightedParts(unescape$1(singleValue.value || ''));
});
return /*#__PURE__*/ React.createElement(Snippet$1, _object_spread_props(_object_spread({}, props), {
parts: parts,
highlightedTagName: highlightedTagName,
nonHighlightedTagName: nonHighlightedTagName,
separator: separator
}));
}
function SortBy$1(_0) {
var items = _0.items, value = _0.value, _0_onChange = _0.onChange, onChange = _0_onChange === void 0 ? function() {} : _0_onChange, _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, props = _object_without_properties(_0, [
"items",
"value",
"onChange",
"classNames"
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-SortBy', classNames.root, props.className)
}), /*#__PURE__*/ React.createElement("select", {
className: cx('ais-SortBy-select', classNames.select),
onChange: function onChange1(event) {
return onChange(event.target.value);
},
value: value,
"aria-label": "Sort results by"
}, items.map(function(item) {
return /*#__PURE__*/ React.createElement("option", {
className: cx('ais-SortBy-option', classNames.option),
key: item.value,
value: item.value
}, item.label);
})));
}
function SortBy(_0) {
var items = _0.items, transformItems = _0.transformItems, props = _object_without_properties(_0, [
"items",
"transformItems"
]);
var _useSortBy = useSortBy({
items: items,
transformItems: transformItems
}, {
$$widgetType: 'ais.sortBy'
}), currentRefinement = _useSortBy.currentRefinement, options = _useSortBy.options, refine = _useSortBy.refine;
var uiProps = {
items: options,
value: currentRefinement,
onChange: refine
};
return /*#__PURE__*/ React.createElement(SortBy$1, _object_spread({}, props, uiProps));
}
// Delay before announcing an update, so that rapid changes (e.g. typing in the
// search box) settle into a single announcement instead of piling up. Mirrors
// the debounce used by GOV.UK's accessible-autocomplete.
var ANNOUNCEMENT_DELAY = 1400;
var visuallyHiddenStyle = {
position: 'absolute',
width: 1,
height: 1,
padding: 0,
margin: -1,
overflow: 'hidden',
clip: 'rect(0, 0, 0, 0)',
whiteSpace: 'nowrap',
border: 0
};
function Stats$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, nbHits = _0.nbHits, processingTimeMS = _0.processingTimeMS, nbSortedHits = _0.nbSortedHits, areHitsSorted = _0.areHitsSorted, translations = _0.translations, props = _object_without_properties(_0, [
"classNames",
"nbHits",
"processingTimeMS",
"nbSortedHits",
"areHitsSorted",
"translations"
]);
var translationOptions = {
nbHits: nbHits,
processingTimeMS: processingTimeMS,
nbSortedHits: nbSortedHits,
areHitsSorted: areHitsSorted
};
var nextAnnouncement = translations.announcementText ? translations.announcementText(translationOptions) : '';
var _useState = _sliced_to_array(React.useState(''), 2), announcement = _useState[0], setAnnouncement = _useState[1];
var timerRef = React.useRef(undefined);
var isInitialRef = React.useRef(true);
React.useEffect(function() {
// Don't announce the initial results, only subsequent changes.
if (isInitialRef.current) {
isInitialRef.current = false;
return undefined;
}
clearTimeout(timerRef.current);
timerRef.current = setTimeout(function() {
setAnnouncement(nextAnnouncement);
}, ANNOUNCEMENT_DELAY);
return function() {
return clearTimeout(timerRef.current);
};
}, [
nextAnnouncement
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-Stats', classNames.root, props.className)
}), /*#__PURE__*/ React.createElement("span", {
className: "ais-Stats-text"
}, translations.rootElementText(translationOptions)), /*#__PURE__*/ React.createElement("span", {
className: "ais-Stats-announcement",
role: "status",
"aria-live": "polite",
"aria-atomic": "true",
style: visuallyHiddenStyle
}, announcement));
}
function Stats(_0) {
var translations = _0.translations, props = _object_without_properties(_0, [
"translations"
]);
var _useStats = useStats(undefined, {
$$widgetType: 'ais.stats'
}), nbHits = _useStats.nbHits, nbSortedHits = _useStats.nbSortedHits, processingTimeMS = _useStats.processingTimeMS, areHitsSorted = _useStats.areHitsSorted;
var uiProps = {
nbHits: nbHits,
nbSortedHits: nbSortedHits,
processingTimeMS: processingTimeMS,
areHitsSorted: areHitsSorted,
translations: _object_spread({
rootElementText: function rootElementText(options) {
return "".concat(options.areHitsSorted ? getSortedResultsSentence(options) : getResultsSentence(options), " found in ").concat(options.processingTimeMS.toLocaleString(), "ms");
},
announcementText: function announcementText(options) {
return options.areHitsSorted ? getSortedResultsSentence(options) : getResultsSentence(options);
}
}, translations)
};
return /*#__PURE__*/ React.createElement(Stats$1, _object_spread({}, props, uiProps));
}
function getSortedResultsSentence(param) {
var nbHits = param.nbHits, nbSortedHits = param.nbSortedHits;
var suffix = "sorted out of ".concat(nbHits.toLocaleString());
if (nbSortedHits === 0) {
return "No relevant results ".concat(suffix);
}
if (nbSortedHits === 1) {
return "1 relevant result ".concat(suffix);
}
if (nbSortedHits > 1) {
return "".concat((nbSortedHits || 0).toLocaleString(), " relevant results ").concat(suffix);
}
return '';
}
function getResultsSentence(param) {
var nbHits = param.nbHits;
if (nbHits === 0) {
return 'No results';
}
if (nbHits === 1) {
return '1 result';
}
if (nbHits > 1) {
return "".concat(nbHits.toLocaleString(), " results");
}
return '';
}
function ToggleRefinement$1(_0) {
var _0_classNames = _0.classNames, classNames = _0_classNames === void 0 ? {} : _0_classNames, checked = _0.checked, onChange = _0.onChange, label = _0.label, props = _object_without_properties(_0, [
"classNames",
"checked",
"onChange",
"label"
]);
return /*#__PURE__*/ React.createElement("div", _object_spread_props(_object_spread({}, props), {
className: cx('ais-ToggleRefinement', classNames.root, props.className)
}), /*#__PURE__*/ React.createElement("label", {
className: cx('ais-ToggleRefinement-label', classNames.label)
}, /*#__PURE__*/ React.createElement("input", {
className: cx('ais-ToggleRefinement-checkbox', classNames.checkbox),
type: "checkbox",
checked: checked,
onChange: function onChange1(event) {
onChange(event.target.checked);
}
}), /*#__PURE__*/ React.createElement("span", {
className: cx('ais-ToggleRefinement-labelText', classNames.labelText)
}, label)));
}
function ToggleRefinement(_0) {
var attribute = _0.attribute, on = _0.on, off = _0.off, props = _object_without_properties(_0, [
"attribute",
"on",
"off"
]);
var _useToggleRefinement = useToggleRefinement({
attribute: attribute,
on: on,
off: off
}, {
$$widgetType: 'ais.toggleRefinement'
}), refine = _useToggleRefinement.refine, value = _useToggleRefinement.value;
var uiProps = {
checked: value.isRefined,
onChange: function onChange(isChecked) {
return refine({
isRefined: !isChecked
});
}
};
return /*#__PURE__*/ React.createElement(ToggleRefinement$1, _object_spread({
label: value.name
}, props, uiProps));
}
var TrendingItemsUiComponent = createTrendingItemsComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
function TrendingItems(_0) {
var facetName = _0.facetName, facetValue = _0.facetValue, limit = _0.limit, threshold = _0.threshold, fallbackParameters = _0.fallbackParameters, queryParameters = _0.queryParameters, escapeHTML = _0.escapeHTML, transformItems = _0.transformItems, itemComponent = _0.itemComponent, headerComponent = _0.headerComponent, emptyComponent = _0.emptyComponent, layoutComponent = _0.layoutComponent, props = _object_without_properties(_0, [
"facetName",
"facetValue",
"limit",
"threshold",
"fallbackParameters",
"queryParameters",
"escapeHTML",
"transformItems",
"itemComponent",
"headerComponent",
"emptyComponent",
"layoutComponent"
]);
var facetParameters = facetName && facetValue ? {
facetName: facetName,
facetValue: facetValue
} : {};
var status = useInstantSearch().status;
var _useTrendingItems = useTrendingItems(_object_spread_props(_object_spread({}, facetParameters), {
limit: limit,
threshold: threshold,
fallbackParameters: fallbackParameters,
queryParameters: queryParameters,
escapeHTML: escapeHTML,
transformItems: transformItems
}), {
$$widgetType: 'ais.trendingItems'
}), items = _useTrendingItems.items, sendEvent = _useTrendingItems.sendEvent;
var layout = layoutComponent ? function(layoutProps) {
return layoutComponent(_object_spread_props(_object_spread({}, layoutProps), {
classNames: {
list: layoutProps.classNames.list,
item: layoutProps.classNames.item
}
}));
} : undefined;
var _itemComponent = React.useMemo(function() {
return itemComponent ? function(itemProps) {
return itemComponent(_object_spread_props(_object_spread({}, itemProps), {
sendEvent: sendEvent
}));
} : undefined;
}, [
itemComponent,
sendEvent
]);
var uiProps = {
items: items,
itemComponent: _itemComponent,
headerComponent: headerComponent,
emptyComponent: emptyComponent,
layout: layout,
status: status,
sendEvent: sendEvent
};
return /*#__PURE__*/ React.createElement(TrendingItemsUiComponent, _object_spread({}, props, uiProps));
}
var TrendingFacetsUiComponent = createTrendingFacetsComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
function TrendingFacets(_0) {
var facetName = _0.facetName, limit = _0.limit, threshold = _0.threshold, fallbackParameters = _0.fallbackParameters, escapeHTML = _0.escapeHTML, transformItems = _0.transformItems, itemComponent = _0.itemComponent, headerComponent = _0.headerComponent, emptyComponent = _0.emptyComponent, props = _object_without_properties(_0, [
"facetName",
"limit",
"threshold",
"fallbackParameters",
"escapeHTML",
"transformItems",
"itemComponent",
"headerComponent",
"emptyComponent"
]);
var status = useInstantSearch().status;
var items = useTrendingFacets({
facetName: facetName,
limit: limit,
threshold: threshold,
fallbackParameters: fallbackParameters,
escapeHTML: escapeHTML,
transformItems: transformItems
}, {
$$widgetType: 'ais.trendingFacets'
}).items;
var uiProps = {
items: items,
itemComponent: itemComponent,
headerComponent: headerComponent,
emptyComponent: emptyComponent,
status: status
};
return /*#__PURE__*/ React.createElement(TrendingFacetsUiComponent, _object_spread({}, props, uiProps));
}
var FilterSuggestionsUiComponent = createFilterSuggestionsComponent({
createElement: React.createElement,
Fragment: React.Fragment
});
/**
* @deprecated Filter suggestions are deprecated and will be removed in a future major version.
*/ function FilterSuggestions(_0) {
var agentId = _0.agentId, attributes = _0.attributes, maxSuggestions = _0.maxSuggestions, debounceMs = _0.debounceMs, hitsToSample = _0.hitsToSample, transformItems = _0.transformItems, itemComponent = _0.itemComponent, headerComponent = _0.headerComponent, emptyComponent = _0.emptyComponent, transport = _0.transport, props = _object_without_properties(_0, [
"agentId",
"attributes",
"maxSuggestions",
"debounceMs",
"hitsToSample",
"transformItems",
"itemComponent",
"headerComponent",
"emptyComponent",
"transport"
]);
var _useFilterSuggestions = useFilterSuggestions({
agentId: agentId,
attributes: attributes,
maxSuggestions: maxSuggestions,
debounceMs: debounceMs,
hitsToSample: hitsToSample,
transformItems: transformItems,
transport: transport
}, {
$$widgetType: 'ais.filterSuggestions'
}), suggestions = _useFilterSuggestions.suggestions, isLoading = _useFilterSuggestions.isLoading, refine = _useFilterSuggestions.refine;
var uiProps = {
suggestions: suggestions,
isLoading: isLoading,
refine: refine,
skeletonCount: maxSuggestions,
itemComponent: itemComponent,
headerComponent: headerComponent,
emptyComponent: emptyComponent
};
return /*#__PURE__*/ React.createElement(FilterSuggestionsUiComponent, _object_spread({}, props, uiProps));
}
exports.Autocomplete = Autocomplete;
exports.Breadcrumb = Breadcrumb;
exports.Carousel = Carousel;
exports.Chat = Chat;
exports.ChatGreeting = ChatGreeting;
exports.ChatInlineLayout = ChatInlineLayout;
exports.ChatMessageLoader = ChatMessageLoader;
exports.ChatOverlayLayout = ChatOverlayLayout;
exports.ChatSidePanelLayout = ChatSidePanelLayout;
exports.ChatTrigger = ChatTrigger;
exports.ClearRefinements = ClearRefinements;
exports.Configure = Configure;
exports.CurrentRefinements = CurrentRefinements;
exports.DisplayResultsToolType = DisplayResultsToolType;
exports.DynamicWidgets = DynamicWidgets;
exports.EXPERIMENTAL_Autocomplete = EXPERIMENTAL_Autocomplete;
exports.Feeds = Feeds;
exports.FilterSuggestions = FilterSuggestions;
exports.FrequentlyBoughtTogether = FrequentlyBoughtTogether;
exports.GroupedResultsToolType = GroupedResultsToolType;
exports.HierarchicalMenu = HierarchicalMenu;
exports.Highlight = Highlight;
exports.Hits = Hits;
exports.HitsPerPage = HitsPerPage;
exports.Index = Index;
exports.InfiniteHits = InfiniteHits;
exports.InstantSearch = InstantSearch;
exports.InstantSearchRSCContext = InstantSearchRSCContext;
exports.InstantSearchSSRContext = InstantSearchSSRContext;
exports.InstantSearchSSRProvider = InstantSearchSSRProvider;
exports.InstantSearchServerContext = InstantSearchServerContext;
exports.LookingSimilar = LookingSimilar;
exports.MemorizeToolType = MemorizeToolType;
exports.MemorySearchToolType = MemorySearchToolType;
exports.Menu = Menu;
exports.Pagination = Pagination;
exports.PonderToolType = PonderToolType;
exports.PoweredBy = PoweredBy;
exports.PromptSuggestions = PromptSuggestions;
exports.RangeInput = RangeInput;
exports.RecommendToolType = RecommendToolType;
exports.RefinementList = RefinementList;
exports.RelatedProducts = RelatedProducts;
exports.ReverseHighlight = ReverseHighlight;
exports.SearchBox = SearchBox;
exports.SearchIndexToolType = SearchIndexToolType;
exports.Snippet = Snippet;
exports.SortBy = SortBy;
exports.Stats = Stats;
exports.ToggleRefinement = ToggleRefinement;
exports.TrendingFacets = TrendingFacets;
exports.TrendingItems = TrendingItems;
exports.createDefaultTools = createDefaultTools;
exports.getServerState = getServerState;
exports.useAutocomplete = useAutocomplete;
exports.useBreadcrumb = useBreadcrumb;
exports.useChat = useChat;
exports.useChatTrigger = useChatTrigger;
exports.useClearRefinements = useClearRefinements;
exports.useConfigure = useConfigure;
exports.useConnector = useConnector;
exports.useCurrentRefinements = useCurrentRefinements;
exports.useDynamicWidgets = useDynamicWidgets;
exports.useFeeds = useFeeds;
exports.useFilterSuggestions = useFilterSuggestions;
exports.useFrequentlyBoughtTogether = useFrequentlyBoughtTogether;
exports.useGeoSearch = useGeoSearch;
exports.useHierarchicalMenu = useHierarchicalMenu;
exports.useHits = useHits;
exports.useHitsPerPage = useHitsPerPage;
exports.useInfiniteHits = useInfiniteHits;
exports.useInstantSearch = useInstantSearch;
exports.useInstantSearchContext = useInstantSearchContext;
exports.useLookingSimilar = useLookingSimilar;
exports.useMenu = useMenu;
exports.useNumericMenu = useNumericMenu;
exports.usePagination = usePagination;
exports.usePoweredBy = usePoweredBy;
exports.usePromptSuggestions = usePromptSuggestions;
exports.useQueryRules = useQueryRules;
exports.useRSCContext = useRSCContext;
exports.useRange = useRange;
exports.useRefinementList = useRefinementList;
exports.useRelatedProducts = useRelatedProducts;
exports.useSearchBox = useSearchBox;
exports.useSortBy = useSortBy;
exports.useStats = useStats;
exports.useStickToBottom = useStickToBottom;
exports.useToggleRefinement = useToggleRefinement;
exports.useTrendingFacets = useTrendingFacets;
exports.useTrendingItems = useTrendingItems;
exports.version = version$2;
exports.wrapPromiseWithState = wrapPromiseWithState;
}));