coveo-search-ui
Version:
Coveo JavaScript Search Framework
1,114 lines (1,050 loc) • 616 kB
JavaScript
webpackJsonpCoveo__temporary([4,1,3,19],{
/***/ 118:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Component_1 = __webpack_require__(7);
var ResultList_1 = __webpack_require__(93);
var Dom_1 = __webpack_require__(1);
var underscore_1 = __webpack_require__(0);
var Logger_1 = __webpack_require__(9);
var ResultListUtils = /** @class */ (function () {
function ResultListUtils() {
}
ResultListUtils.hideIfInfiniteScrollEnabled = function (cmp) {
var infiniteScrollEnabled = ResultListUtils.isInfiniteScrollEnabled(cmp.searchInterface.element);
if (infiniteScrollEnabled) {
cmp.disable();
Dom_1.$$(cmp.element).hide();
ResultListUtils.warnIfComponentNotNeeded(cmp);
}
else {
cmp.enable();
Dom_1.$$(cmp.element).unhide();
}
};
ResultListUtils.isInfiniteScrollEnabled = function (root) {
var resultList = ResultListUtils.getMainResultList(root);
return resultList ? !!resultList.options.enableInfiniteScroll : false;
};
ResultListUtils.scrollToTop = function (root) {
var resultList = ResultListUtils.getMainResultList(root);
if (!resultList) {
new Logger_1.Logger(this).warn('No active ResultList, scrolling to the top of the Window');
return window.scrollTo(0, 0);
}
var searchInterfacePosition = resultList.searchInterface.element.getBoundingClientRect().top;
if (searchInterfacePosition > 0) {
return;
}
window.scrollTo(0, window.pageYOffset + searchInterfacePosition);
};
ResultListUtils.getMainResultList = function (root) {
var resultLists = ResultListUtils.getResultLists(root);
return underscore_1.find(resultLists, function (resultList) {
var isRecInterface = resultList.searchInterface.element.classList.contains('CoveoRecommendation');
return !resultList.disabled && !isRecInterface;
});
};
ResultListUtils.getResultLists = function (root) {
return Dom_1.$$(root)
.findAll("." + ResultListUtils.cssClass())
.map(function (el) { return Component_1.Component.get(el, ResultList_1.ResultList); });
};
ResultListUtils.cssClass = function () {
return Component_1.Component.computeCssClassName(ResultList_1.ResultList);
};
ResultListUtils.warnIfComponentNotNeeded = function (cmp) {
var root = cmp.searchInterface.root;
var allListsUseInfiniteScroll = ResultListUtils.allResultListsUseInfiniteScroll(root);
allListsUseInfiniteScroll && ResultListUtils.notNeededComponentWarning(cmp);
};
ResultListUtils.allResultListsUseInfiniteScroll = function (root) {
var listsWithInfiniteScrollDisabled = ResultListUtils.getResultLists(root).filter(function (resultList) { return !resultList.options.enableInfiniteScroll; });
return listsWithInfiniteScrollDisabled.length === 0;
};
ResultListUtils.notNeededComponentWarning = function (cmp) {
var cmpCssClass = Component_1.Component.computeCssClassNameForType(cmp.type);
var message = "The " + cmpCssClass + " component is not needed because all " + ResultListUtils.cssClass() + " components have enableInfiniteScroll set to 'true'.\n For the best performance, remove the " + cmpCssClass + " component from your search page.";
new Logger_1.Logger(cmp).warn(message);
};
return ResultListUtils;
}());
exports.ResultListUtils = ResultListUtils;
/***/ }),
/***/ 119:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Assert_1 = __webpack_require__(5);
var Utils_1 = __webpack_require__(4);
var Globalize = __webpack_require__(23);
var underscore_1 = __webpack_require__(0);
/**
* A class which holds information and operation available on a single facet value returned by a {@link IGroupByRequest}.<br/>
* This class is used extensively in the {@link Facet} component.
*/
var FacetValue = /** @class */ (function () {
function FacetValue() {
this.selected = false;
this.excluded = false;
this.waitingForDelta = false;
}
FacetValue.prototype.reset = function () {
this.selected = false;
this.excluded = false;
};
FacetValue.prototype.updateCountsFromNewValue = function (newValue) {
Assert_1.Assert.exists(newValue);
this.occurrences = newValue.occurrences;
this.delta = newValue.delta;
this.computedField = newValue.computedField;
};
FacetValue.prototype.clone = function () {
this.computedField = undefined;
this.delta = undefined;
return this;
};
FacetValue.prototype.cloneWithZeroOccurrences = function () {
this.occurrences = 0;
return this.clone();
};
FacetValue.prototype.cloneWithDelta = function (count, delta) {
Assert_1.Assert.isLargerOrEqualsThan(0, count);
var clone = this.cloneWithZeroOccurrences();
clone.delta = delta;
clone.occurrences = count;
return clone;
};
FacetValue.prototype.getFormattedCount = function () {
var count = undefined;
if (Utils_1.Utils.exists(this.delta) && this.delta > 0) {
count = '+' + Globalize.format(this.delta, 'n0');
}
else {
if (this.occurrences > 0) {
count = Globalize.format(this.occurrences, 'n0');
}
}
return count;
};
FacetValue.prototype.getFormattedComputedField = function (format) {
if (this.computedField != 0) {
return Globalize.format(this.computedField, format);
}
else {
return undefined;
}
};
FacetValue.create = function (value) {
if (underscore_1.isString(value)) {
return FacetValue.createFromValue(value);
}
else if (underscore_1.isObject(value)) {
if ('computedFieldResults' in value) {
return FacetValue.createFromGroupByValue(value);
}
else {
return FacetValue.createFromFieldValue(value);
}
}
else {
throw new Error("Can't create value from " + value);
}
};
FacetValue.createFromValue = function (value) {
Assert_1.Assert.isNonEmptyString(value);
var facetValue = new FacetValue();
facetValue.value = value;
facetValue.lookupValue = value;
return facetValue;
};
FacetValue.createFromGroupByValue = function (groupByValue) {
Assert_1.Assert.exists(groupByValue);
Assert_1.Assert.exists(groupByValue);
var facetValue = new FacetValue();
facetValue.value = groupByValue.value;
facetValue.lookupValue = Utils_1.Utils.exists(groupByValue.lookupValue) ? groupByValue.lookupValue : groupByValue.value;
facetValue.occurrences = groupByValue.numberOfResults;
facetValue.computedField = Utils_1.Utils.isNonEmptyArray(groupByValue.computedFieldResults) ? groupByValue.computedFieldResults[0] : undefined;
facetValue.score = groupByValue.score;
return facetValue;
};
FacetValue.createFromFieldValue = function (fieldValue) {
Assert_1.Assert.exists(fieldValue);
var facetValue = new FacetValue();
facetValue.value = fieldValue.value;
facetValue.lookupValue = fieldValue.lookupValue;
facetValue.occurrences = fieldValue.numberOfResults;
return facetValue;
};
return FacetValue;
}());
exports.FacetValue = FacetValue;
/***/ }),
/***/ 131:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ResponsiveDropdownContent_1 = __webpack_require__(94);
var ResponsiveComponentsUtils = /** @class */ (function () {
function ResponsiveComponentsUtils() {
}
ResponsiveComponentsUtils.shouldDrawFacetSlider = function (root, facetSliderElement) {
return ResponsiveDropdownContent_1.ResponsiveDropdownContent.isTargetInsideOpenedDropdown(facetSliderElement) || !this.isSmallFacetActivated(root);
};
ResponsiveComponentsUtils.isSmallTabsActivated = function (root) {
return root.hasClass(this.smallTabsClassName);
};
ResponsiveComponentsUtils.isSmallFacetActivated = function (root) {
return root.hasClass(this.smallFacetClassName);
};
ResponsiveComponentsUtils.isSmallRecommendationActivated = function (root) {
return root.hasClass(this.smallRecommendationClassName);
};
ResponsiveComponentsUtils.activateSmallTabs = function (root) {
root.addClass(this.smallTabsClassName);
};
ResponsiveComponentsUtils.deactivateSmallTabs = function (root) {
root.removeClass(this.smallTabsClassName);
};
ResponsiveComponentsUtils.activateSmallFacet = function (root) {
root.addClass(this.smallFacetClassName);
};
ResponsiveComponentsUtils.deactivateSmallFacet = function (root) {
root.removeClass(this.smallFacetClassName);
};
ResponsiveComponentsUtils.activateSmallRecommendation = function (root) {
root.addClass(this.smallRecommendationClassName);
};
ResponsiveComponentsUtils.deactivateSmallRecommendation = function (root) {
root.removeClass(this.smallRecommendationClassName);
};
ResponsiveComponentsUtils.smallTabsClassName = 'coveo-small-tabs';
ResponsiveComponentsUtils.smallFacetClassName = 'coveo-small-facets';
ResponsiveComponentsUtils.smallRecommendationClassName = 'coveo-small-recommendation';
return ResponsiveComponentsUtils;
}());
exports.ResponsiveComponentsUtils = ResponsiveComponentsUtils;
/***/ }),
/***/ 132:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/// <reference path="Facet.ts" />
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ValueElement_1 = __webpack_require__(477);
var FacetValueElement = /** @class */ (function (_super) {
__extends(FacetValueElement, _super);
function FacetValueElement(facet, facetValue, keepDisplayedValueNextTime) {
var _this = _super.call(this, facet, facetValue) || this;
_this.facet = facet;
_this.facetValue = facetValue;
_this.keepDisplayedValueNextTime = keepDisplayedValueNextTime;
return _this;
}
FacetValueElement.prototype.bindEvent = function () {
_super.prototype.bindEvent.call(this, {
displayNextTime: this.keepDisplayedValueNextTime,
pinFacet: this.facet.options.preservePosition
});
};
return FacetValueElement;
}(ValueElement_1.ValueElement));
exports.FacetValueElement = FacetValueElement;
/***/ }),
/***/ 173:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/// <reference path="Facet.ts" />
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(4);
var FacetUtils_1 = __webpack_require__(40);
var QueryBuilder_1 = __webpack_require__(49);
var Dom_1 = __webpack_require__(1);
var _ = __webpack_require__(0);
var AllowedValuesPatternType_1 = __webpack_require__(476);
var FacetSearchParameters = /** @class */ (function () {
function FacetSearchParameters(facet) {
this.facet = facet;
this.valueToSearch = '';
this.alwaysInclude = [];
this.alwaysExclude = [];
this.sortCriteria = 'occurrences';
this.fetchMore = false;
this.completeFacetWithStandardValues = true;
this.nbResults = facet.options.numberOfValuesInFacetSearch;
this.ignoreAccents = facet.options.facetSearchIgnoreAccents;
}
FacetSearchParameters.prototype.setValueToSearch = function (value) {
this.valueToSearch = value;
if (Utils_1.Utils.isNonEmptyString(value)) {
this.valueToSearch = this.valueToSearch.trim();
this.alwaysInclude = this.alwaysInclude.concat(FacetUtils_1.FacetUtils.getValuesToUseForSearchInFacet(this.valueToSearch, this.facet));
}
return this;
};
FacetSearchParameters.prototype.excludeCurrentlyDisplayedValuesInSearch = function (searchResults) {
var _this = this;
_.each(this.getCurrentlyShowedValueInSearch(searchResults), function (v) {
var expandedValues = FacetUtils_1.FacetUtils.getValuesToUseForSearchInFacet(v, _this.facet);
_.each(expandedValues, function (expanded) {
_this.alwaysExclude.push(expanded);
});
});
_.each(this.facet.getDisplayedFacetValues(), function (v) {
_this.alwaysExclude.push(v.value);
});
};
FacetSearchParameters.prototype.getGroupByRequest = function () {
this.lowerCaseAll();
var nbResults = this.nbResults;
nbResults += this.alwaysExclude.length;
var typedByUser = [];
if (this.valueToSearch) {
typedByUser = ['*' + this.valueToSearch + '*'];
}
var allowedValues;
if (this.valueToSearch) {
allowedValues = typedByUser.concat(this.alwaysInclude).concat(this.alwaysExclude);
}
else {
allowedValues = _.compact(typedByUser.concat(this.alwaysInclude).concat(this.facet.options.allowedValues));
}
var completeFacetWithStandardValues = this.completeFacetWithStandardValues;
if (this.facet.options.lookupField != null) {
completeFacetWithStandardValues = false;
}
var request = {
allowedValues: allowedValues,
allowedValuesPatternType: this.facet.options.useWildcardsInFacetSearch
? AllowedValuesPatternType_1.AllowedValuesPatternType.Wildcards
: AllowedValuesPatternType_1.AllowedValuesPatternType.Legacy,
maximumNumberOfValues: nbResults,
completeFacetWithStandardValues: completeFacetWithStandardValues,
field: this.facet.options.field,
sortCriteria: this.facet.options.sortCriteria || this.sortCriteria,
injectionDepth: this.facet.options.injectionDepth
};
if (this.facet.options.lookupField) {
request.lookupField = this.facet.options.lookupField;
}
if (this.facet.options.computedField) {
request.computedFields = [
{
field: this.facet.options.computedField,
operation: this.facet.options.computedFieldOperation
}
];
}
return request;
};
FacetSearchParameters.prototype.getQuery = function () {
var lastQuery = _.clone(this.facet.queryController.getLastQuery());
if (!lastQuery) {
// There should normally always be a last query available
// If not, just create an empty one.
lastQuery = new QueryBuilder_1.QueryBuilder().build();
}
// We want to always force query syntax to true for a facet search,
// but arrange for the basic expression to adapt itself with no syntax block
if (lastQuery.enableQuerySyntax) {
lastQuery.q = this.facet.facetQueryController.basicExpressionToUseForFacetSearch;
}
else if (Utils_1.Utils.isNonEmptyString(this.facet.facetQueryController.basicExpressionToUseForFacetSearch)) {
lastQuery.q = "<@- " + this.facet.facetQueryController.basicExpressionToUseForFacetSearch + " -@>";
}
else {
lastQuery.q = '';
}
lastQuery.enableQuerySyntax = true;
lastQuery.cq = this.facet.facetQueryController.constantExpressionToUseForFacetSearch;
lastQuery.aq = this.facet.facetQueryController.advancedExpressionToUseForFacetSearch;
lastQuery.enableDidYouMean = false;
lastQuery.firstResult = 0;
lastQuery.numberOfResults = 0;
lastQuery.fieldsToInclude = [];
lastQuery.groupBy = [this.getGroupByRequest()];
return lastQuery;
};
FacetSearchParameters.prototype.getCurrentlyShowedValueInSearch = function (searchResults) {
return _.map(Dom_1.$$(searchResults).findAll('.coveo-facet-value-caption'), function (val) {
return Dom_1.$$(val).getAttribute('data-original-value') || Dom_1.$$(val).text();
});
};
FacetSearchParameters.prototype.lowerCaseAll = function () {
this.alwaysExclude = _.chain(this.alwaysExclude)
.map(function (v) {
return v.toLowerCase();
})
.uniq()
.value();
this.alwaysInclude = _.chain(this.alwaysInclude)
.map(function (v) {
return v.toLowerCase();
})
.uniq()
.value();
};
return FacetSearchParameters;
}());
exports.FacetSearchParameters = FacetSearchParameters;
/***/ }),
/***/ 174:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var underscore_1 = __webpack_require__(0);
var Core_1 = __webpack_require__(20);
var ComponentsTypes_1 = __webpack_require__(47);
var Dom_1 = __webpack_require__(1);
var InitializationEvents_1 = __webpack_require__(17);
var DependsOnManager = /** @class */ (function () {
function DependsOnManager(facet) {
var _this = this;
this.facet = facet;
Dom_1.$$(this.facet.ref.searchInterface.element).on(Core_1.QueryEvents.buildingQuery, function () { return _this.handleBuildingQuery(); });
if (this.getDependsOn(this.facet.ref)) {
this.facet.ref.bind.onRootElement(InitializationEvents_1.InitializationEvents.afterComponentsInitialization, function () { return _this.setupDependentFacet(); });
}
}
DependsOnManager.prototype.setupDependentFacet = function () {
var _this = this;
Dom_1.$$(this.facet.ref.element).addClass('coveo-hidden-dependant-facet');
this.parentFacetRef = this.getParentFacet(this.facet.ref);
if (this.parentFacetRef) {
Dom_1.$$(this.facet.ref.root).on('state:change', function () { return _this.resetIfConditionUnfullfiled(); });
}
};
DependsOnManager.prototype.resetIfConditionUnfullfiled = function () {
var condition = this.getDependsOnCondition(this.facet.ref);
if (!condition(this.parentFacetRef)) {
this.facet.reset();
}
};
DependsOnManager.prototype.getId = function (component) {
var id = component.options.id;
return id ? "" + id : null;
};
DependsOnManager.prototype.getDependsOn = function (component) {
var dependsOn = component.options.dependsOn;
return dependsOn ? "" + dependsOn : null;
};
DependsOnManager.prototype.getDependsOnCondition = function (component) {
var _this = this;
var conditionOption = component.options.dependsOnCondition;
return conditionOption && underscore_1.isFunction(conditionOption)
? conditionOption
: function () { return _this.parentHasSelectedValues(component) && _this.parentIsEnabled(component); };
};
DependsOnManager.prototype.parentHasSelectedValues = function (component) {
var parent = this.getParentFacet(component);
return parent && this.valuesExistForFacetWithId(this.getId(parent));
};
DependsOnManager.prototype.parentIsEnabled = function (component) {
var parent = this.getParentFacet(component);
return parent && !parent.disabled;
};
DependsOnManager.prototype.valuesExistForFacetWithId = function (facetId) {
var values = this.facet.ref.queryStateModel.get(Core_1.QueryStateModel.getFacetId(facetId));
return !!values && !!values.length;
};
Object.defineProperty(DependsOnManager.prototype, "allFacetsInInterface", {
get: function () {
return ComponentsTypes_1.ComponentsTypes.getAllFacetsFromSearchInterface(this.facet.ref.searchInterface);
},
enumerable: true,
configurable: true
});
DependsOnManager.prototype.getParentFacet = function (component) {
var _this = this;
var parent = this.allFacetsInInterface.filter(function (potentialParentFacet) { return _this.getId(potentialParentFacet) === _this.getDependsOn(component); });
if (!parent.length) {
component.logger.warn('DependsOn reference does not exist', this.getDependsOn(this.facet.ref));
return null;
}
return parent[0];
};
Object.defineProperty(DependsOnManager.prototype, "dependentFacets", {
get: function () {
var _this = this;
return this.allFacetsInInterface.filter(function (potentialDependentFacet) { return _this.getId(_this.facet.ref) === _this.getDependsOn(potentialDependentFacet); });
},
enumerable: true,
configurable: true
});
DependsOnManager.prototype.handleBuildingQuery = function () {
var _this = this;
this.dependentFacets.forEach(function (dependentFacet) {
var condition = _this.getDependsOnCondition(dependentFacet);
if (condition(_this.facet.ref)) {
Dom_1.$$(dependentFacet.element).removeClass('coveo-hidden-dependant-facet');
return dependentFacet.enable();
}
dependentFacet.disable();
Dom_1.$$(dependentFacet.element).addClass('coveo-hidden-dependant-facet');
});
};
Object.defineProperty(DependsOnManager.prototype, "hasDependentFacets", {
get: function () {
return !!this.dependentFacets.length;
},
enumerable: true,
configurable: true
});
Object.defineProperty(DependsOnManager.prototype, "dependentFacetsHaveSelectedValues", {
get: function () {
var _this = this;
return this.dependentFacets.some(function (dependentFacet) { return _this.valuesExistForFacetWithId(_this.getId(dependentFacet)); });
},
enumerable: true,
configurable: true
});
return DependsOnManager;
}());
exports.DependsOnManager = DependsOnManager;
/***/ }),
/***/ 175:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ResponsiveFacetColumn_1 = __webpack_require__(216);
var Facet_1 = __webpack_require__(70);
var ResponsiveFacets = /** @class */ (function (_super) {
__extends(ResponsiveFacets, _super);
function ResponsiveFacets() {
return _super !== null && _super.apply(this, arguments) || this;
}
ResponsiveFacets.init = function (root, component, options) {
ResponsiveFacetColumn_1.ResponsiveFacetColumn.init(ResponsiveFacets, root, component, options, Facet_1.Facet.ID);
};
return ResponsiveFacets;
}(ResponsiveFacetColumn_1.ResponsiveFacetColumn));
exports.ResponsiveFacets = ResponsiveFacets;
/***/ }),
/***/ 182:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(4);
var DynamicFacetRequestBuilder = /** @class */ (function () {
function DynamicFacetRequestBuilder(request) {
this.request = request;
}
DynamicFacetRequestBuilder.prototype.buildBaseRequestForQuery = function () {
return __assign({}, this.request, { filterFacetCount: determineFilterFacetCount(this.request) });
};
return DynamicFacetRequestBuilder;
}());
exports.DynamicFacetRequestBuilder = DynamicFacetRequestBuilder;
function determineFilterFacetCount(options) {
var filterFacetCount = options.filterFacetCount;
return Utils_1.Utils.isUndefined(filterFacetCount) ? true : filterFacetCount;
}
exports.determineFilterFacetCount = determineFilterFacetCount;
/***/ }),
/***/ 183:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
__webpack_require__(568);
var Dom_1 = __webpack_require__(1);
var Strings_1 = __webpack_require__(6);
var SVGIcons_1 = __webpack_require__(12);
var SVGDom_1 = __webpack_require__(16);
var DynamicFacetHeaderButton_1 = __webpack_require__(506);
var DynamicFacetHeaderCollapseToggle_1 = __webpack_require__(569);
var AccessibilityUtils_1 = __webpack_require__(48);
function getDynamicFacetHeaderId(facetId) {
return facetId + "-facet-heading";
}
exports.getDynamicFacetHeaderId = getDynamicFacetHeaderId;
var DynamicFacetHeader = /** @class */ (function () {
function DynamicFacetHeader(options) {
this.options = options;
this.element = Dom_1.$$('div', { className: 'coveo-dynamic-facet-header' }).el;
this.title = this.createTitle();
Dom_1.$$(this.element).append(this.title.el);
Dom_1.$$(this.element).append(this.createWaitAnimation());
Dom_1.$$(this.element).append(this.createClearButton());
this.options.enableCollapse && this.enableCollapse();
}
DynamicFacetHeader.prototype.createClearButton = function () {
var _this = this;
this.clearButton = new DynamicFacetHeaderButton_1.DynamicFacetHeaderButton({
label: Strings_1.l('Clear'),
ariaLabel: Strings_1.l('Clear', this.options.title),
className: 'coveo-dynamic-facet-header-clear',
shouldDisplay: false,
action: function () { return _this.options.clear(); }
});
return this.clearButton.element;
};
DynamicFacetHeader.prototype.createCollapseToggle = function () {
this.collapseToggle = new DynamicFacetHeaderCollapseToggle_1.DynamicFacetHeaderCollapseToggle(this.options);
return this.collapseToggle.element;
};
DynamicFacetHeader.prototype.enableCollapse = function () {
var _this = this;
Dom_1.$$(this.element).append(this.createCollapseToggle());
Dom_1.$$(this.title).addClass('coveo-clickable');
Dom_1.$$(this.title).on('click', function () { return _this.options.toggleCollapse(); });
};
DynamicFacetHeader.prototype.toggleCollapse = function (isCollapsed) {
this.options.enableCollapse && this.collapseToggle.toggleButton(isCollapsed);
};
DynamicFacetHeader.prototype.createTitle = function () {
return Dom_1.$$(AccessibilityUtils_1.getHeadingTag(this.options.headingLevel), {
className: 'coveo-dynamic-facet-header-title',
ariaLabel: "" + Strings_1.l('FacetTitle', this.options.title),
id: getDynamicFacetHeaderId(this.options.id)
}, Dom_1.$$('span', { ariaHidden: true, title: this.options.title }, this.options.title));
};
DynamicFacetHeader.prototype.createWaitAnimation = function () {
this.waitAnimation = Dom_1.$$('div', { className: 'coveo-dynamic-facet-header-wait-animation' }, SVGIcons_1.SVGIcons.icons.loading);
SVGDom_1.SVGDom.addClassToSVGInContainer(this.waitAnimation.el, 'coveo-dynamic-facet-header-wait-animation-svg');
this.waitAnimation.toggle(false);
return this.waitAnimation.el;
};
DynamicFacetHeader.prototype.toggleClear = function (visible) {
this.clearButton.toggle(visible);
};
DynamicFacetHeader.prototype.showLoading = function () {
var _this = this;
clearTimeout(this.showLoadingTimeout);
this.showLoadingTimeout = window.setTimeout(function () { return _this.waitAnimation.toggle(true); }, DynamicFacetHeader.showLoadingDelay);
};
DynamicFacetHeader.prototype.hideLoading = function () {
clearTimeout(this.showLoadingTimeout);
this.waitAnimation.toggle(false);
};
DynamicFacetHeader.showLoadingDelay = 2000;
return DynamicFacetHeader;
}());
exports.DynamicFacetHeader = DynamicFacetHeader;
/***/ }),
/***/ 184:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
* The allowed values for the [`facetType`]{@link IFacetRequest.facetType} property of a [facet request]{@link IFacetRequest}.
*/
var FacetType;
(function (FacetType) {
/**
* Request facet values representing specific values.
*/
FacetType["specific"] = "specific";
/**
* Request facet values representing ranges of numbers.
*/
FacetType["numericalRange"] = "numericalRange";
/**
* Request facet values representing ranges of dates.
*/
FacetType["dateRange"] = "dateRange";
/**
* Request facet values representing a hierarchy.
*/
FacetType["hierarchical"] = "hierarchical";
})(FacetType = exports.FacetType || (exports.FacetType = {}));
/***/ }),
/***/ 215:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Component_1 = __webpack_require__(7);
var _ = __webpack_require__(0);
var ResultListRenderer = /** @class */ (function () {
function ResultListRenderer(resultListOptions, autoCreateComponentsFn) {
this.resultListOptions = resultListOptions;
this.autoCreateComponentsFn = autoCreateComponentsFn;
}
ResultListRenderer.prototype.renderResults = function (resultElements, append, resultDisplayedCallback) {
var _this = this;
if (append === void 0) { append = false; }
return Promise.all([this.getStartFragment(resultElements, append), this.getEndFragment(resultElements, append)]).then(function (_a) {
var startFrag = _a[0], endFrag = _a[1];
var resultsFragment = document.createDocumentFragment();
if (startFrag) {
resultsFragment.appendChild(startFrag);
}
_.each(resultElements, function (resultElement) {
resultsFragment.appendChild(resultElement);
resultDisplayedCallback(Component_1.Component.getResult(resultElement), resultElement);
});
if (endFrag) {
resultsFragment.appendChild(endFrag);
}
_this.resultListOptions.resultsContainer.appendChild(resultsFragment);
});
};
ResultListRenderer.prototype.getStartFragment = function (resultElements, append) {
return Promise.resolve(document.createDocumentFragment());
};
ResultListRenderer.prototype.getEndFragment = function (resultElements, append) {
return Promise.resolve(document.createDocumentFragment());
};
return ResultListRenderer;
}());
exports.ResultListRenderer = ResultListRenderer;
/***/ }),
/***/ 216:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
__webpack_require__(536);
var QueryEvents_1 = __webpack_require__(11);
var Logger_1 = __webpack_require__(9);
var Strings_1 = __webpack_require__(6);
var Dom_1 = __webpack_require__(1);
var Utils_1 = __webpack_require__(4);
var Component_1 = __webpack_require__(7);
var SearchInterface_1 = __webpack_require__(19);
var ResponsiveComponents_1 = __webpack_require__(55);
var ResponsiveComponentsManager_1 = __webpack_require__(62);
var ResponsiveComponentsUtils_1 = __webpack_require__(131);
var ResponsiveDropdown_1 = __webpack_require__(124);
var ResponsiveDropdownContent_1 = __webpack_require__(94);
var ResponsiveDropdownHeader_1 = __webpack_require__(136);
var underscore_1 = __webpack_require__(0);
var ComponentsTypes_1 = __webpack_require__(47);
var ResponsiveDropdownModalContent_1 = __webpack_require__(537);
var FacetsMobileMode_1 = __webpack_require__(86);
var FacetsMobileModeEvents_1 = __webpack_require__(538);
var ResponsiveFacetColumn = /** @class */ (function () {
function ResponsiveFacetColumn(coveoRoot, ID, options, responsiveDropdown) {
this.coveoRoot = coveoRoot;
this.ID = ID;
this.componentsInFacetColumn = [];
this.preservePositionOriginalValues = [];
this.searchInterface = Component_1.Component.get(this.coveoRoot.el, SearchInterface_1.SearchInterface, false);
this.dropdownHeaderLabel = this.getDropdownHeaderLabel();
this.dropdown = this.buildDropdown(responsiveDropdown);
this.bindDropdownContentEvents();
this.bindFacetsMobileModeEvents();
this.registerOnCloseHandler();
this.registerQueryEvents();
this.initializeBreakpoint(options.responsiveBreakpoint);
}
ResponsiveFacetColumn.init = function (responsiveComponentConstructor, root, component, options, ID) {
var column = this.findColumn(root);
if (!column) {
return;
}
ResponsiveComponentsManager_1.ResponsiveComponentsManager.register(ResponsiveFacetColumn, Dom_1.$$(root), 'ResponsiveFacetColumn', component, options);
ResponsiveComponentsManager_1.ResponsiveComponentsManager.register(responsiveComponentConstructor, Dom_1.$$(root), ID, component, options);
};
ResponsiveFacetColumn.findColumn = function (root) {
var column = Dom_1.$$(root).find('.coveo-facet-column');
if (!column) {
this.logger.info('No element with class coveo-facet-column. Responsive facets cannot be enabled');
}
return column;
};
Object.defineProperty(ResponsiveFacetColumn.prototype, "facetsMobileModeComponent", {
get: function () {
return this.searchInterface ? this.searchInterface.getComponents(FacetsMobileMode_1.FacetsMobileMode.ID)[0] : null;
},
enumerable: true,
configurable: true
});
Object.defineProperty(ResponsiveFacetColumn.prototype, "facetsMobileModeOptions", {
get: function () {
var facetsMobileModeComponent = this.facetsMobileModeComponent;
if (!facetsMobileModeComponent) {
ResponsiveFacetColumn.logger.warn('The "FacetsMobileMode" component did not load properly, disabling the ResponsiveFacets modal.');
return {
isModal: false,
preventScrolling: false,
displayOverlayWhileOpen: true
};
}
return facetsMobileModeComponent.options;
},
enumerable: true,
configurable: true
});
ResponsiveFacetColumn.prototype.registerComponent = function (accept) {
this.componentsInFacetColumn.push(accept);
this.preservePositionOriginalValues.push(accept.options.preservePosition);
return true;
};
ResponsiveFacetColumn.prototype.needDropdownWrapper = function () {
return this.needSmallMode();
};
ResponsiveFacetColumn.prototype.handleResizeEvent = function () {
if (this.needSmallMode() && !ResponsiveComponentsUtils_1.ResponsiveComponentsUtils.isSmallFacetActivated(this.coveoRoot)) {
this.changeToSmallMode();
}
else if (!this.needSmallMode() && ResponsiveComponentsUtils_1.ResponsiveComponentsUtils.isSmallFacetActivated(this.coveoRoot)) {
this.changeToLargeMode();
}
if (this.dropdown.isOpened) {
this.dropdown.dropdownContent.positionDropdown();
}
};
ResponsiveFacetColumn.prototype.dismissFacetSearches = function () {
underscore_1.each(this.componentsInFacetColumn, function (component) {
if (component.facetSearch && component.facetSearch.currentlyDisplayedResults) {
component.facetSearch.dismissSearchResults();
}
});
};
ResponsiveFacetColumn.prototype.needSmallMode = function () {
if (!this.searchInterface) {
return (this.coveoRoot.width() <=
(Utils_1.Utils.isNullOrUndefined(this.breakpoint) ? new ResponsiveComponents_1.ResponsiveComponents().getMediumScreenWidth() : this.breakpoint));
}
switch (this.searchInterface.responsiveComponents.getResponsiveMode()) {
case 'small':
case 'medium':
return true;
case 'auto':
return (this.coveoRoot.width() <=
(Utils_1.Utils.isNullOrUndefined(this.breakpoint) ? this.searchInterface.responsiveComponents.getMediumScreenWidth() : this.breakpoint));
default:
return false;
}
};
ResponsiveFacetColumn.prototype.changeToSmallMode = function () {
this.dropdown.close();
this.disableFacetPreservePosition();
Dom_1.$$(this.coveoRoot.find("." + ResponsiveComponentsManager_1.ResponsiveComponentsManager.DROPDOWN_HEADER_WRAPPER_CSS_CLASS)).append(this.dropdown.dropdownHeader.element.el);
ResponsiveComponentsUtils_1.ResponsiveComponentsUtils.activateSmallFacet(this.coveoRoot);
};
ResponsiveFacetColumn.prototype.changeToLargeMode = function () {
this.restoreFacetPreservePositionValue();
this.dropdown.cleanUp();
ResponsiveComponentsUtils_1.ResponsiveComponentsUtils.deactivateSmallFacet(this.coveoRoot);
};
ResponsiveFacetColumn.prototype.buildDropdown = function (responsiveDropdown) {
var dropdownContent = this.buildDropdownContent();
var dropdownHeader = this.buildDropdownHeader();
var dropdown = responsiveDropdown ? responsiveDropdown : new ResponsiveDropdown_1.ResponsiveDropdown(dropdownContent, dropdownHeader, this.coveoRoot);
if (!this.facetsMobileModeOptions.displayOverlayWhileOpen) {
dropdown.disablePopupBackground();
}
if (this.facetsMobileModeOptions.preventScrolling) {
dropdown.enableScrollLocking(this.facetsMobileModeOptions.scrollContainer);
}
return dropdown;
};
ResponsiveFacetColumn.prototype.buildDropdownContent = function () {
var _this = this;
var dropdownContentElement = Dom_1.$$(this.coveoRoot.find('.coveo-facet-column'));
var filterByContainer = Dom_1.$$('div', { className: 'coveo-facet-header-filter-by-container', style: 'display: none' });
var filterBy = Dom_1.$$('div', { className: 'coveo-facet-header-filter-by' });
filterBy.text(Strings_1.l('Filter by:'));
filterByContainer.append(filterBy.el);
dropdownContentElement.prepend(filterByContainer.el);
if (this.facetsMobileModeOptions.isModal) {
return new ResponsiveDropdownModalContent_1.ResponsiveDropdownModalContent('facet', dropdownContentElement, Strings_1.l('CloseFiltersDropdown'), function () { return _this.dropdown.close(); });
}
return new ResponsiveDropdownContent_1.ResponsiveDropdownContent('facet', dropdownContentElement, this.coveoRoot, ResponsiveFacetColumn.DROPDOWN_MIN_WIDTH, ResponsiveFacetColumn.DROPDOWN_WIDTH_RATIO);
};
ResponsiveFacetColumn.prototype.buildDropdownHeader = function () {
var dropdownHeaderElement = Dom_1.$$('a');
var content = Dom_1.$$('p');
content.text(this.dropdownHeaderLabel);
dropdownHeaderElement.el.appendChild(content.el);
var dropdownHeader = new ResponsiveDropdownHeader_1.ResponsiveDropdownHeader('facet', dropdownHeaderElement);
return dropdownHeader;
};
ResponsiveFacetColumn.prototype.initializeBreakpoint = function (defaultBreakpoint) {
var facetsMobileModeBreakpoint = this.facetsMobileModeOptions.breakpoint;
this.breakpoint = Utils_1.Utils.isNullOrUndefined(facetsMobileModeBreakpoint) ? defaultBreakpoint : facetsMobileModeBreakpoint;
};
ResponsiveFacetColumn.prototype.registerOnCloseHandler = function () {
this.dropdown.registerOnCloseHandler(this.dismissFacetSearches, this);
};
ResponsiveFacetColumn.prototype.registerQueryEvents = function () {
var _this = this;
this.coveoRoot.on(QueryEvents_1.QueryEvents.noResults, function () { return _this.handleNoResults(); });
this.coveoRoot.on(QueryEvents_1.QueryEvents.querySuccess, function (e, data) { return _this.handleQuerySuccess(data); });
this.coveoRoot.on(QueryEvents_1.QueryEvents.queryError, function () { return _this.handleQueryError(); });
};
ResponsiveFacetColumn.prototype.bindDropdownContentEvents = function () {
var _this = this;
this.dropdown.dropdownContent.element.on('scroll', underscore_1.debounce(function () {
underscore_1.each(_this.componentsInFacetColumn, function (component) {
var facetSearch = component.facetSearch;
if (facetSearch && facetSearch.currentlyDisplayedResults && !_this.isFacetSearchScrolledIntoView(facetSearch.search)) {
component.facetSearch.positionSearchResults(_this.dropdown.dropdownContent.element.el);
}
else if (facetSearch && component.facetSearch.currentlyDisplayedResults) {
component.facetSearch.positionSearchResults();
}
});
}, ResponsiveFacetColumn.DEBOUNCE_SCROLL_WAIT));
};
ResponsiveFacetColumn.prototype.bindFacetsMobileModeEvents = function () {
var facetsMobileModeComponent = this.facetsMobileModeComponent;
if (facetsMobileModeComponent) {
this.dropdown.registerOnOpenHandler(function () { return Dom_1.$$(facetsMobileModeComponent.element).trigger(FacetsMobileModeEvents_1.FacetsMobileModeEvents.popupOpened); }, facetsMobileModeComponent);
this.dropdown.registerOnCloseHandler(function () { return Dom_1.$$(facetsMobileModeComponent.element).trigger(FacetsMobileModeEvents_1.FacetsMobileModeEvents.popupClosed); }, facetsMobileModeComponent);
}
};
ResponsiveFacetColumn.prototype.restoreFacetPreservePositionValue = function () {
var _this = this;
underscore_1.each(this.componentsInFacetColumn, function (component, index) {
if (component.options) {
component.options.preservePosition = _this.preservePositionOriginalValues[index];
}
});
};
ResponsiveFacetColumn.prototype.disableFacetPreservePosition = function () {
underscore_1.each(this.componentsInFacetColumn, function (component) {
if (component.options) {
component.options.preservePosition = false;
}
});
};
ResponsiveFacetColumn.prototype.isFacetSearchScrolledIntoView = function (facetSearchElement) {
var facetTop = facetSearchElement.getBoundingClientRect().top;
var facetBottom = facetSearchElement.getBoundingClientRect().bottom;
var dropdownTop = this.dropdown.dropdownContent.element.el.getBoundingClientRect().top;
var dropdownBottom = this.dropdown.dropdownContent.element.el.getBoundingClientRect().bottom;
dropdownTop = dropdownTop >= 0 ? dropdownTop : 0;
return facetTop >= dropdownTop && facetBottom <= dropdownBottom;
};
ResponsiveFacetColumn.prototype.getDropdownHeaderLabel = function () {
var dropdownHeaderLabel;
ComponentsTypes_1.ComponentsTypes.getAllFacetInstancesFromElement(this.coveoRoot.find('.coveo-facet-column')).forEach(function (facet) {
var options = facet.options;
if (!dropdownHeaderLabel && options.dropdownHeaderLabel) {
dropdownHeaderLabel = options.dropdownHeaderLabel;
}
});
if (!dropdownHeaderLabel) {
dropdownHeaderLabel = Strings_1.l(ResponsiveFacetColumn.DROPDOWN_HEADER_LABEL_DEFAULT_VALUE);
}
return dropdownHeaderLabel;
};
ResponsiveFacetColumn.prototype.handleNoResults = function () {
this.dropdown.dropdownHeader.hide();
};
ResponsiveFacetColumn.prototype.handleQueryError = function () {
this.dropdown.dropdownHeader.hide();
};
ResponsiveFacetColumn.prototype.handleQuerySuccess = function (data) {
if (data.results.totalCount === 0) {
this.dropdown.dropdownHeader.hide();
}
else {
this.dropdown.dropdownHeader.show();
}
};
ResponsiveFacetColumn.DEBOUNCE_SCROLL_WAIT = 250;
ResponsiveFacetColumn.logger = new Logger_1.Logger('ResponsiveFacets');
ResponsiveFacetColumn.DROPDOWN_MIN_WIDTH = 280;
ResponsiveFacetColumn.DROPDOWN_WIDTH_RATIO = 0.35; // Used to set the width relative to the coveo root.
ResponsiveFacetColumn.DROPDOWN_HEADER_LABEL_DEFAULT_VALUE = 'Filters';
return ResponsiveFacetColumn;
}());
exports.ResponsiveFacetColumn = ResponsiveFacetColumn;
/***/ }),
/***/ 217:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/// <reference path='../ui/Facet/Facet.ts' />
Object.defineProperty(exports, "__esModule", { value: true });
var ExpressionBuilder_1 = __webpack_require__(75);
var Utils_1 = __webpack_require__(4);
var FacetSearchParameters_1 = __webpack_require__(173);
var Assert_1 = __webpack_require__(5);
var FacetUtils_1 = __webpack_require__(40);
var _ = __webpack_require__(0);
var QueryBuilderExpression_1 = __webpack_require__(185);
var FacetQueryController = /** @class */ (function () {
function FacetQueryController(facet, shouldEscapeValueInFieldExpression) {
if (shouldEscapeValueInFieldExpression === void 0) { shouldEscapeValueInFieldExpression = true; }
this.facet = facet;
this.shouldEscapeValueInFieldExpression = shouldEscapeValueInFieldExpression;
}
/**
* Reset the expression for the facet search, used when a new query is triggered
*/
FacetQueryController.prototype.prepareForNewQuery = function () {
this.lastGroupByRequestIndex = undefined;
this.expressionToUseForFacetSearch = undefined;
this.constantExpressionToUseForFacetSearch = undefined;
};
/**
* Compute the filter expression that the facet needs to output for the query
* @returns {string}
*/
FacetQueryController.prototype.computeOurFilterExpression = function () {
var _this = this;
var builder = new ExpressionBuilder_1.ExpressionBuilder();
var selected = this.facet.values.getSelected();
if (selected.length > 0) {
if (this.facet.options.useAnd) {
_.each(selected, function (value) {
builder.addFieldExpression(_this.facet.options.field, '==', [value.value], _this.shouldEscapeValueInFieldExpression);
});
}
else {
builder.addFieldExpression(this.facet.options.field, '==', _.map(selected, function (value) { return value.value; }), this.shouldEscapeValueInFieldExpression);
}
}
var excluded = this.facet.values.getExcluded();
if (excluded.length > 0) {
builder.addFieldNotEqualExpression(this.facet.options.field, _.map(excluded, function (value) { return value.value; }), true);
}
if (Utils_1.Utils.isNonEmptyString(this.facet.options.additionalFilter)) {
builder.add(this.facet.options.additionalFilter);
}
return builder.build();
};
/**
* Build the group by request for the facet, and insert it in the query builder
* @param queryBuilder
*/
FacetQueryController.prototype.putGroupByIntoQueryBuilder = function (queryBuilder) {
Assert_1.Assert.exists(queryBuilder);
var allowedValues = this.createGroupByAllowedValues();
var groupByRequest = this.createBasicGroupByRequest(allowedValues);
var queryOverrideObject = this.createGroupByQueryOverride(queryBuilder);
if (!Utils_1.Utils.isNullOrUndefined(queryOverrideObject) || !QueryBuilderExpression_1.QueryBuilderExpression.isEmpty(queryOverrideObject)) {
groupByRequest.queryOverride = queryOverrideObject.basic;
groupByRequest.advancedQueryOverride = queryOverrideObject.advanced;
groupByRequest.constantQueryOverride = queryOverrideObject.constant;
this.expressionToUseForFacetSearch = queryOverrideObject.withoutConstant;
this.basicExpressionToUseForFacetSearch = queryOverrideObject.basic;
this.advancedExpressionToUseForFacetSearch = queryOverrideObject.advanced;
this.constantExpressionToUseForFacetSearch = queryOverrideObject.constant;
}
else {
var parts = queryBuilder.computeCompleteExpressionParts();
this.expressionToUseForFacetSearch = parts.withoutConstant == null ? '' : parts.withoutConstant;
this.basicExpressionToUseForFacetSearch = parts.basic == null ? '' : parts.basic;
this.advancedExpressionToUseForFacetSearch = parts.advanced;