fix(results): remove lodash looping over objects

[Haroenv]

Closes #639

This was a quite complicated effort, because most iterations could be of either type.

Migrations done:

• remove lodash.map
• remove lodash.get (just a small side effect)
• remove map / reduce / trim / pickBy in generateHierarchicalTree
• add some more typing via jsDoc (typescript reads it), but not everywhere
• went through every usage for every lodash function in SearchResults
• did some small moves here and there to remove a function's usage fully

This fixes a bug when a facet value can be length, causing lodash to interpret it as an array

[francoischalifour]

Nice effort!

We could have used this pass to rename the parameters in the modified higher-order functions (e.g. f → filter).

[Haroenv]

From reading

algoliasearch-helper-js/src/SearchResults/index.js

Lines 363 to 538 in e111b85

	this.facets = [];
	var disjunctiveFacets = state.getRefinedDisjunctiveFacets();
	var facetsIndices = getIndices(state.facets);
	var disjunctiveFacetsIndices = getIndices(state.disjunctiveFacets);
	var nextDisjunctiveResult = 1;
	var self = this;
	// 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, {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 hierarchicalFacet = state.getHierarchicalFacetByName(disjunctiveFacet);
	// There should be only item in facets.
	Object.keys(result.facets).forEach(function(dfacet) {
	var facetResults = result.facets[dfacet];
	var position;
	if (hierarchicalFacet) {
	position = findIndex(state.hierarchicalFacets, {name: hierarchicalFacet.name});
	var attributeIndex = findIndex(self.hierarchicalFacets[position], {attribute: dfacet});
	// previous refinements and no results so not able to find it
	if (attributeIndex === -1) {
	return;
	}
	self.hierarchicalFacets[position][attributeIndex].data = merge(
	{},
	self.hierarchicalFacets[position][attributeIndex].data,
	facetResults
	);
	} else {
	position = disjunctiveFacetsIndices[dfacet];
	var dataFromMainRequest = mainSubResponse.facets && mainSubResponse.facets[dfacet] || {};
	self.disjunctiveFacets[position] = {
	name: dfacet,
	data: defaults({}, facetResults, dataFromMainRequest),
	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(refinementValue) > -1) {
	self.disjunctiveFacets[position].data[refinementValue] = 0;
	}
	});
	}
	}
	});
	nextDisjunctiveResult++;
	});
	// if we have some root 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;
	}
	var result = results[nextDisjunctiveResult];
	Object.keys(result.facets).forEach(function(dfacet) {
	var facetResults = result.facets[dfacet];
	var position = findIndex(state.hierarchicalFacets, {name: hierarchicalFacet.name});
	var attributeIndex = findIndex(self.hierarchicalFacets[position], {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)
	var defaultData = {};
	if (currentRefinement.length > 0) {
	var root = currentRefinement[0].split(separator)[0];
	defaultData[root] = self.hierarchicalFacets[position][attributeIndex].data[root];
	}
	self.hierarchicalFacets[position][attributeIndex].data = defaults(
	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: mainSubResponse.facets[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;
	});
	});

, it's always available

[Haroenv]

removing lodash.includes brought it from 35.2 → 35 kB