@abcagency/hc-ui-components 1.9.35 → 1.9.37

package/src/util/filterUtil.js

@@ -1,35 +1,13 @@
 /* eslint-disable no-undef */
 import { getDistinctItemsByProximity } from '~/util/mapUtil';
-import { isAlgoliaAvailable, isAlgoliaInitializing, filterListingsByAlgoliaSearch } from '~/util/algoliaSearchUtil';
 
 import Fuse from 'fuse.js';
 
-// Helper function to get field value from either fields or customFields
-export const getFieldValue = (listing, fieldKey) => {
-	// First check in fields
-	if (listing.fields && listing.fields[fieldKey] !== undefined && listing.fields[fieldKey] !== null) {
-		return listing.fields[fieldKey];
-	}
-	
-	// Then check in customFields array
-	if (listing.customFields && Array.isArray(listing.customFields)) {
-		const customField = listing.customFields.find(
-			cf => cf.id === fieldKey || cf.name === fieldKey
-		);
-		if (customField) {
-			return customField.value;
-		}
-	}
-	
-	return undefined;
-};
-
-export const getFilterOptions = (listings, filteredListings, field, excludeZeroCount = false) => {
+export const getFilterOptions = (listings, filteredListings, field, excludeZeroCount = null) => {
 	const options = new Set();
 	listings.forEach(listing => {
-		const value = getFieldValue(listing, field);
-		if (value) {
-			options.add(value);
+		if (listing.fields[field]) {
+			options.add(listing.fields[field]);
 		}
 	});
 
@@ -39,150 +17,48 @@ export const getFilterOptions = (listings, filteredListings, field, excludeZeroC
 	});
 
 	filteredListings.forEach(listing => {
-		const value = getFieldValue(listing, field);
-		if (value && Object.prototype.hasOwnProperty.call(optionCounts, value)) {
+		const value = listing.fields[field];
+		if (value && optionCounts.hasOwnProperty(value)) {
 			optionCounts[value] += 1;
 		}
 	});
 
-	let result = Array.from(options)
-		.filter(option => option != null && option !== '') // Filter out null/empty values
+	return Array.from(options)
+		.sort()
 		.map(option => ({
 			name: option,
 			count: optionCounts[option] || 0
 		}))
 		.filter(option => !(excludeZeroCount === true && option.count === 0));
-
-	// Sort alphabetically
-	result.sort((a, b) => a.name.localeCompare(b.name));
-
-	return result;
 };
 
-export const getSpecialFeatureOptions = (listings, filteredListings, siteConfig, favorites, filterConfig = {}) => {
+export const getSpecialFeatureOptions = (listings, filteredListings, siteConfig, favorites) => {
 	const specialFeatures = siteConfig.specialFeatures;
-	const allOptions = [];
-
-	Object.entries(specialFeatures).forEach(([featureKey, featureName]) => {
-		// Check if this field is in regular fields or custom fields
-		const hasRegularField = listings.some(listing => 
-			listing.fields && listing.fields[featureKey] !== undefined
-		);
-
-		if (hasRegularField) {
-			// Get all distinct values for this regular field
-			const distinctValues = new Set();
-			listings.forEach(listing => {
-				const value = getFieldValue(listing, featureKey);
-				if (value != null && value !== '' && value !== undefined) {
-					distinctValues.add(String(value));
-				}
-			});
-
-			// Check if it's boolean-like
-			const booleanValues = new Set(['true', 'false', '1', '0', 'yes', 'no', 'True', 'False']);
-			const allBooleanLike = Array.from(distinctValues).every(val => 
-				booleanValues.has(val) || val === '1' || val === '0'
-			) && distinctValues.size <= 2;
-
-			if (allBooleanLike) {
-				// Handle as boolean field
-				let count = 0;
-				filteredListings.forEach(listing => {
-					const value = getFieldValue(listing, featureKey);
-					if (value == 1 || value === 1 || value === '1' || value === 'true' || value === true) {
-						count += 1;
-					}
-				});
-				allOptions.push({ name: featureName, count });
-			} else {
-				// Handle as multi-value regular field - add each distinct value as separate option
-				distinctValues.forEach(value => {
-					let count = 0;
-					filteredListings.forEach(listing => {
-						const listingValue = getFieldValue(listing, featureKey);
-						if (String(listingValue) === value) {
-							count += 1;
-						}
-					});
-					allOptions.push({ 
-						name: `${featureName}: ${value}`, 
-						count
-					});
-				});
-			}
-		} else {
-			// Check if it's in custom fields
-			const hasCustomField = listings.some(listing => 
-				listing.customFields && Array.isArray(listing.customFields) &&
-				listing.customFields.some(cf => cf.id === featureKey || cf.name === featureKey)
-			);
+	const featureCounts = Object.keys(specialFeatures).sort().reduce((acc, key) => {
+		acc[specialFeatures[key]] = 0;
+		return acc;
+	}, {});
 
-			if (hasCustomField) {
-				// Get all distinct values for this custom field
-				const distinctValues = new Set();
-				listings.forEach(listing => {
-					const value = getFieldValue(listing, featureKey);
-					if (value != null && value !== '' && value !== undefined) {
-						distinctValues.add(String(value));
-					}
-				});
-
-				// Check if it's boolean-like
-				const booleanValues = new Set(['true', 'false', '1', '0', 'yes', 'no', 'True', 'False']);
-				const allBooleanLike = Array.from(distinctValues).every(val => 
-					booleanValues.has(val)
-				) && distinctValues.size <= 2;
-
-				if (allBooleanLike) {
-					// Handle as boolean custom field
-					let count = 0;
-					filteredListings.forEach(listing => {
-						const value = getFieldValue(listing, featureKey);
-						if (value === '1' || value === 'true' || value === 'True' || value === true || value === 1) {
-							count += 1;
-						}
-					});
-					allOptions.push({ name: featureName, count });
-				} else {
-					// Handle as multi-value custom field - add each distinct value as separate option
-					distinctValues.forEach(value => {
-						let count = 0;
-						filteredListings.forEach(listing => {
-							const listingValue = getFieldValue(listing, featureKey);
-							if (listingValue === value) {
-								count += 1;
-							}
-						});
-						allOptions.push({ 
-							name: `${featureName}: ${value}`, 
-							count
-						});
-					});
-				}
+	filteredListings.forEach(listing => {
+		Object.entries(specialFeatures).forEach(([featureKey, featureName]) => {
+			if (listing.fields[featureKey] == 1) {
+				featureCounts[featureName] += 1;
 			}
-		}
+		});
 	});
 
-	// Update favorite count
-	for (let option of allOptions) {
+	const specialFeatureOptions = Object.entries(featureCounts).map(([name, count]) => ({
+		name,
+		count
+	}));
+
+	for (let option of specialFeatureOptions) {
 		if (option.name === 'Favorite') {
 			option.count = filteredListings.filter(x => favorites.includes(x.id)).length;
 		}
 	}
 
-	// Hide favorites if filterConfig.showFavorites is false
-	let finalOptions = allOptions;
-	if (filterConfig.showFavorites === false) {
-		finalOptions = finalOptions.filter(option => option.name !== 'Favorite');
-	}
-
-	// Hide zero results if filterConfig.hideZeroResults is true
-	if (filterConfig.hideZeroResults === true) {
-		finalOptions = finalOptions.filter(option => option.count > 0);
-	}
-
-	return finalOptions;
+	return specialFeatureOptions;
 };
 
 const getPointsOfInterestOptions = pointsOfInterestNames => {
@@ -199,76 +75,52 @@ export const generateFilterOptions = (
 	filterOptions,
 	parentField,
 	favorites,
-	selectedFilters,
-	filterConfig = {
-		hideZeroResults: false,
-		dynamicCounts: true,
-		showFavorites: true,
-		collapsedByDefault: false,
-		sortAlphabetically: false
-	}
+	selectedFilters
 ) => {
 	if (allListings.length > 0) {
-		// Determine which listings to use for counts based on dynamicCounts setting
-		const countListings = filterConfig.dynamicCounts ? filteredListings : allListings;
-
 		const dynamicFilters = siteConfig.fieldFiltersShown.map(fieldName => {
 			if (fieldName === parentField && filterOptions?.filters) {
 				return filterOptions.filters.find(filter => filter.id === fieldName);
 			}
-			if(fieldName == 'category'){
-				// For category counts, exclude specialFeatures from the filter calculation
-				// so that toggling specialFeatures updates category counts
-				let categoryCountListings = countListings;
-				if (filterConfig.dynamicCounts && selectedFilters.specialFeatures) {
-					categoryCountListings = allListings.filter(listing => {
-						return Object.entries(selectedFilters).every(([key, value]) => {
-							if (key === 'specialFeatures') return true; // Exclude specialFeatures
-							const fieldValue = getFieldValue(listing, key);
-							if (value && typeof value === 'object' && value[fieldValue] === true) {
-								return true;
-							}
-							return false;
-						});
-					});
-				}
+			if(fieldName == 'categoryClass'){
 				return {
 					id: fieldName,
 					title: siteConfig.fieldNames[fieldName],
-					items: getFilterOptions(allListings, categoryCountListings, fieldName, filterConfig.hideZeroResults)
+					items: getFilterOptions(allListings, allListings, fieldName)
 				};
 			}
-			if(fieldName == 'subCategory' && selectedFilters.category){
-				const categoryKeys = Object.keys(selectedFilters.category);
-				const filteredByCategory = allListings.filter(
-					x => categoryKeys.includes(x.fields?.category)
+			if(fieldName == 'category' && selectedFilters.categoryClass){
+				const categoryClassKeys = Object.keys(selectedFilters.categoryClass);
+				const filteredListings = allListings.filter(
+					x => categoryClassKeys.includes(x.fields?.categoryClass)
 				);
 				return {
 					id: fieldName,
 					title: siteConfig.fieldNames[fieldName],
-					items: getFilterOptions(allListings, filteredByCategory, fieldName, filterConfig.hideZeroResults)
+					items: getFilterOptions(allListings, filteredListings, fieldName, false)
 				};
 			}
 			if (fieldName == "specialFeatures") {
 				return {
 					id: fieldName,
 					title: siteConfig.fieldNames[fieldName],
-					items: getSpecialFeatureOptions(allListings, countListings, siteConfig, favorites, filterConfig)
+					items: getSpecialFeatureOptions(allListings, filteredListings, siteConfig, favorites).sort()
 				};
 			}
-		return {
-			id: fieldName,
-			title: siteConfig.fieldNames[fieldName],
-			items: getFilterOptions(allListings, countListings, fieldName, filterConfig.hideZeroResults)
-		};
-	});		const locations =
+			return {
+				id: fieldName,
+				title: siteConfig.fieldNames[fieldName],
+				items: getFilterOptions(allListings, filteredListings, fieldName)
+			};
+		});
+
+		const locations =
 			siteConfig.locationFiltersShown.map((fieldName, index) => {
 				let locationFilteredListings = allListings;
 				locationFilteredListings = allListings.filter(listing => {
 					return Object.entries(selectedFilters).every(([key, value]) => {
 						if (siteConfig.locationFiltersShown.includes(key)) return true;
-						const fieldValue = getFieldValue(listing, key);
-						if (value && typeof value === 'object' && value[fieldValue] === true) {
+						if (value && typeof value === 'object' && value[listing.fields[key]] === true) {
 							return true;
 						}
 						return false;
@@ -333,24 +185,9 @@ export const generateFilterOptions = (
 			)
 		};
 
-		// Filter out null filters and ensure items arrays don't contain undefined values
-		const cleanFilters = dynamicFilters
-			.filter(f => f != null && f.items != null)
-			.map(f => ({
-				...f,
-				items: f.items.filter(item => item != null && item.name != null)
-			}));
-
-		const cleanLocations = locations
-			.filter(l => l != null && l.items != null)
-			.map(l => ({
-				...l,
-				items: l.items.filter(item => item != null && item.name != null)
-			}));
-
 		return {
-			filters: cleanFilters,
-			locations: cleanLocations,
+			filters: dynamicFilters,
+			locations: locations,
 			pointsOfInterest: pointsOfInterest
 		};
 	}
@@ -358,14 +195,13 @@ export const generateFilterOptions = (
 	return null;
 };
 
-export const applyFilters = async (
+export const applyFilters = (
 	allListings,
 	selectedFilters,
 	query,
 	listingEntities,
 	favorites,
-	siteConfig,
-	isFirstLoad = false
+	siteConfig
 ) => {
 	let results = allListings;
 	let invertedSpecialFeaturesMap;
@@ -392,60 +228,18 @@ export const applyFilters = async (
 		if (field === "specialFeatures" && invertedSpecialFeaturesMap && Object.keys(filterItems).length > 0) {
 			results = results.filter(listing => {
 				return Object.entries(filterItems).some(([filterName, filterValue]) => {
-					if (!filterValue) return false;
-					
-					// Check if this is a multi-value filter (has a colon in the name)
-					if (filterName.includes(': ')) {
-						const [baseFeatureName, expectedValue] = filterName.split(': ');
-						// Find the field key for this feature
-						const listingFieldName = Object.entries(siteConfig.specialFeatures).find(
-							([key, displayName]) => displayName === baseFeatureName
-						)?.[0];
-						
-						if (listingFieldName) {
-							const value = getFieldValue(listing, listingFieldName);
-							return value === expectedValue;
-						}
-						return false;
-					} else {
-						// Handle boolean special features
-						const listingFieldName = invertedSpecialFeaturesMap[filterName];
-						const value = getFieldValue(listing, listingFieldName);
-						// Support both numeric (1/0) and string ("true"/"false") boolean values
-						return value == 1 || value === 1 || value === '1' || value === 'true' || value === true;
-					}
+					const listingFieldName = invertedSpecialFeaturesMap[filterName];
+					return filterValue && listing.fields[listingFieldName] == 1;
 				});
 			});
 		} else if (Object.keys(filterItems).length > 0) {
-			results = results.filter(listing => {
-				const value = getFieldValue(listing, formattedField);
-				return Object.prototype.hasOwnProperty.call(filterItems, value);
-			});
+			results = results.filter(listing =>
+				filterItems.hasOwnProperty(listing.fields[formattedField])
+			);
 		}
 	}
 	if (query) {
-		// Wait for Algolia to finish initializing ONLY on first load (from URL/localStorage)
-		// Don't wait on subsequent manual searches to avoid slowing down the interface
-		if (isFirstLoad && isAlgoliaInitializing()) {
-			// Wait up to 500ms for Algolia to initialize on first load
-			let attempts = 0;
-			while (isAlgoliaInitializing() && attempts < 10) {
-				await new Promise(resolve => setTimeout(resolve, 50));
-				attempts++;
-			}
-		}
-		
-		// Use Algolia if available, otherwise fall back to Fuse.js
-		if (isAlgoliaAvailable()) {
-			try {
-				results = await filterListingsByAlgoliaSearch(results, query);
-			} catch (error) {
-				console.error('Algolia search failed, falling back to Fuse.js:', error);
-				results = searchResults(results, query);
-			}
-		} else {
-			results = searchResults(results, query);
-		}
+		results = searchResults(results, query);
 	}
 	const distinctItems = getDistinctItemsByProximity(results, listingEntities);
 	if (hasFavorite) {
@@ -461,9 +255,9 @@ function searchResults(results, query) {
 		'fields.posted',
 		'fields.subtitle',
 		'fields.education',
-		'fields.title',
+		'fields.position',
 		'fields.category',
-		'fields.subCategory',
+		'fields.categoryclass',
 		'fields.shift',
 		'fields.citystate',
 		'fields.city',
@@ -509,7 +303,7 @@ export const filterListingsByLocation = (
 	let results = allListings;
 	if (selectedLocation !== null) {
 		results = results.filter(item =>
-			Object.prototype.hasOwnProperty.call(selectedLocation.items, item.id)
+			selectedLocation.items.hasOwnProperty(item.id)
 		);
 	}
 	const mapItems = getDistinctItemsByProximity(results, listingEntities);

package/src/util/mapUtil.js

@@ -1,66 +1,54 @@
-export const getDistinctItemsByProximity = (items, listingEntitiesDetailsInput) => {
+export const getDistinctItemsByProximity = (items, listingEntitiesDetails) => {
 	const clusters = {};
 
-	if (!listingEntitiesDetailsInput) {
-		console.log('getDistinctItemsByProximity: No listingEntitiesDetailsInput');
-		return [];
-	}
-
-	const listingEntitiesDetails = Array.isArray(listingEntitiesDetailsInput)
-		? listingEntitiesDetailsInput.reduce((acc, entity) => {
-			if (entity?.entityKey) acc[entity.entityKey.toLowerCase()] = entity;
-			return acc;
-		  }, {})
-		: Object.keys(listingEntitiesDetailsInput).reduce((acc, key) => {
-			acc[key.toLowerCase()] = listingEntitiesDetailsInput[key];
-			return acc;
-		  }, {});
-
-	console.log('getDistinctItemsByProximity: Processing', items?.length, 'items with', Object.keys(listingEntitiesDetails).length, 'entities');
-	console.log('Entity keys:', Object.keys(listingEntitiesDetails));
+	if (!listingEntitiesDetails) return [];
 
 	const closeItemPairs = findCloseItems(listingEntitiesDetails);
 	if (closeItemPairs.length > 0) {
-		const adjusted = adjustItemPositions(listingEntitiesDetails, closeItemPairs);
-		Object.assign(listingEntitiesDetails, adjusted);
+		listingEntitiesDetails = adjustItemPositions(
+			listingEntitiesDetails,
+			closeItemPairs
+		);
 	}
 
 	items?.forEach(item => {
-		const entityKey = item?.fields?.entityKey;
-		if (!entityKey || entityKey === '-1') return;
-		const entityDetails = listingEntitiesDetails[entityKey.toLowerCase()];
-		if (!entityDetails) {
-			console.error(`Details not found for entityKey: "${entityKey}" (looking for "${entityKey.toLowerCase()}")`);
-			console.error('Available entity keys:', Object.keys(listingEntitiesDetails));
-			return;
-		}
+		if(item.entityId !== -1){
 
-		item.mapDetails = entityDetails;
+			const entityDetails = listingEntitiesDetails[item.entityId];
 
-		const normalizedEntityKey = entityKey.toLowerCase();
-		if (!clusters[normalizedEntityKey]) {
-			clusters[normalizedEntityKey] = {
-				...entityDetails,
-				items: { [item.id]: item }
-			};
-		} else {
-			clusters[normalizedEntityKey].items[item.id] = item;
-		}
+			if (!entityDetails) {
+				console.error(`Details not found for entityId: ${item.entityId}`);
+				return;
+			}
+
+			item.mapDetails = entityDetails;
+
+			if (!clusters[item.entityId]) {
+				clusters[item.entityId] = {
+					...item.mapDetails,
+					items: { [item.id]: item }
+				};
+			} else {
+				clusters[item.entityId].items[item.id] = item;
+			}}
 	});
 
 	return Object.values(clusters);
 };
 
-export const findCloseItems = entitiesByKey => {
+export const findCloseItems = itemsObj => {
 	const closeItems = [];
-	const items = Object.values(entitiesByKey); // Convert object to array
+	const items = Object.values(itemsObj); // Convert object to array for iteration
 	const proximityThreshold = 0.0001;
 
 	for (let i = 0; i < items.length; i++) {
 		for (let j = i + 1; j < items.length; j++) {
 			const distanceLat = Math.abs(items[i].latitude - items[j].latitude);
 			const distanceLng = Math.abs(items[i].longitude - items[j].longitude);
-			if (distanceLat < proximityThreshold && distanceLng < proximityThreshold) {
+			if (
+				distanceLat < proximityThreshold &&
+				distanceLng < proximityThreshold
+			) {
 				closeItems.push({ item1: items[i], item2: items[j] });
 			}
 		}
@@ -69,18 +57,14 @@ export const findCloseItems = entitiesByKey => {
 	return closeItems;
 };
 
-export const adjustItemPositions = (entitiesByKey, closeItemPairs) => {
+export const adjustItemPositions = (itemsObj, closeItemPairs) => {
 	const adjustmentValue = 0.0001;
-	const adjustedItems = { ...entitiesByKey };
+	const adjustedItems = { ...itemsObj }; // Create a shallow copy of the object
 
 	closeItemPairs.forEach(pair => {
-		const key2 = pair.item2.entityKey;
-		if (adjustedItems[key2]) {
-			adjustedItems[key2] = {
-				...adjustedItems[key2],
-				latitude: adjustedItems[key2].latitude + adjustmentValue,
-				longitude: adjustedItems[key2].longitude + adjustmentValue
-			};
+		if (adjustedItems[pair.item1.id] && adjustedItems[pair.item2.id]) {
+			adjustedItems[pair.item2.id].latitude += adjustmentValue;
+			adjustedItems[pair.item2.id].longitude += adjustmentValue;
 		}
 	});
 
@@ -90,15 +74,13 @@ export const adjustItemPositions = (entitiesByKey, closeItemPairs) => {
 export const clusterOptions = (clusterGridSize, fillColor) => {
 	return {
 		gridSize: clusterGridSize,
-		maxZoom: 15,
-		styles: [
-			{
-				url: createSvgDataUri(fillColor),
-				textColor: 'white',
-				height: 40,
-				width: 40
-			}
-		]
+		maxZoom:15,
+		styles:[{
+			url: createSvgDataUri(fillColor),
+			textColor:'white',
+			height: 40,
+			width: 40
+		}]
 	};
 };
 

package/src/util/urlFilterUtil.js

@@ -53,7 +53,6 @@ export const filtersFromURL = location => {
 	if (!location || !location.search) return;
 	const filters = {};
 	let queryParam = null;
-	let lsIgnore = false;
 	const queryParams = parseQueryParams(location.search);
 	if (!queryParams) return;
 	Object.keys(queryParams).forEach(key => {
@@ -65,12 +64,10 @@ export const filtersFromURL = location => {
 			filters[category][filter] = queryParams[key] === 'true';
 		} else if (key === 'query') {
 			queryParam = queryParams[key];
-		} else if (key === 'ls-ignore') {
-			lsIgnore = queryParams[key] === 'true';
 		}
 	});
 
-	return { filters, query: queryParam, lsIgnore };
+	return { filters, query: queryParam };
 };
 
 export const hasFiltersInURL = location => {