@abcagency/hc-ui-components 1.3.23 → 1.3.25

package/src/util/mapUtil.js

@@ -0,0 +1,91 @@
+export const getDistinctItemsByProximity = (items, listingEntitiesDetails) => {
+	const clusters = {};
+
+	if (!listingEntitiesDetails) return [];
+
+	const closeItemPairs = findCloseItems(listingEntitiesDetails);
+	if (closeItemPairs.length > 0) {
+		listingEntitiesDetails = adjustItemPositions(
+			listingEntitiesDetails,
+			closeItemPairs
+		);
+	}
+
+	items?.forEach(item => {
+		if(item.entityId !== -1){
+
+			const entityDetails = listingEntitiesDetails[item.entityId];
+
+			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 = itemsObj => {
+	const closeItems = [];
+	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
+			) {
+				closeItems.push({ item1: items[i], item2: items[j] });
+			}
+		}
+	}
+
+	return closeItems;
+};
+
+export const adjustItemPositions = (itemsObj, closeItemPairs) => {
+	const adjustmentValue = 0.0001;
+	const adjustedItems = { ...itemsObj }; // Create a shallow copy of the object
+
+	closeItemPairs.forEach(pair => {
+		if (adjustedItems[pair.item1.id] && adjustedItems[pair.item2.id]) {
+			adjustedItems[pair.item2.id].latitude += adjustmentValue;
+			adjustedItems[pair.item2.id].longitude += adjustmentValue;
+		}
+	});
+
+	return adjustedItems;
+};
+
+export const clusterOptions = (clusterGridSize, fillColor) => {
+	return {
+		gridSize: clusterGridSize,
+		styles:[{
+			url: createSvgDataUri(fillColor),
+			textColor:'white',
+			height: 40,
+			width: 40
+		}]
+	};
+};
+
+function createSvgDataUri(fillColor) {
+	const svg = `<svg width="50" height="50" xmlns="http://www.w3.org/2000/svg">
+	  <circle cx="25" cy="25" r="20" fill="${fillColor}" />
+	</svg>`;
+	return `data:image/svg+xml;base64,${btoa(svg)}`;
+}

package/src/util/sortUtil.js

@@ -0,0 +1,33 @@
+export const dynamicSort = (items, fieldName, order = "asc") => {
+	if (!items || !items.length) {
+		return [];
+	}
+
+	const inferType = value => {
+		if (!isNaN(Date.parse(value)) && isNaN(value)) {
+			return "date";
+		} else if (!isNaN(parseFloat(value)) && isFinite(value)) {
+			return "number";
+		} else {
+			return "string";
+		}
+	};
+
+	const dataType = inferType(items[0].fields[fieldName]);
+
+	return items.sort((a, b) => {
+		let valA = a.fields[fieldName];
+		let valB = b.fields[fieldName];
+		if (!valA || !valB) return;
+		let comparison = 0;
+
+		if (dataType === "string") {
+			comparison = valA.localeCompare(valB);
+		} else if (dataType === "number") {
+			comparison = valA - valB;
+		} else if (dataType === "date") {
+			comparison = new Date(valA) - new Date(valB);
+		}
+		return order === "desc" ? comparison * -1 : comparison;
+	});
+};

package/src/util/stringUtils.js

@@ -0,0 +1,6 @@
+export const capitalize = str => {
+	if (str && typeof str === "string") {
+		return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+	}
+	return str;
+};

package/src/util/urlFilterUtil.js

@@ -0,0 +1,85 @@
+export const updateURLWithFilters = (filters, location, query) => {
+	const searchParams = new URLSearchParams(location.search);
+
+	for (const key of searchParams.keys()) {
+	  if (key.includes('.') || key === 'query') {
+			searchParams.delete(key);
+	  }
+	}
+
+	if (query) {
+	  searchParams.set('query', query);
+	}
+
+	for (const category in filters) {
+	  for (const filter in filters[category]) {
+			const key = `${category}.${filter}`;
+			if (filters[category][filter]) {
+		  searchParams.set(key, 'true');
+			}
+	  }
+	}
+
+	const newUrl = `${location.pathname}?${searchParams.toString()}`;
+	window.history.replaceState({}, '', newUrl);
+};
+
+function notifyParentOfUrlChange() {
+	setTimeout(() => {
+		var message = {
+			type: 'URL_CHANGE',
+			url: window.location.href
+		};
+		window.parent.postMessage(message, "*");
+	}, 500);
+}
+
+export const parseQueryParams = search => {
+	const queryParams = {};
+	if (!search) return queryParams;
+	let queryString = search.split('?')[1];
+	if (!queryString) {
+		return queryParams;
+	}
+	queryString = queryString.replaceAll('+', ' ');
+	queryString.split('&').forEach(param => {
+		const [key, value] = param.split('=');
+		queryParams[decodeURIComponent(key)] = decodeURIComponent(value);
+	});
+	return queryParams;
+};
+
+export const filtersFromURL = location => {
+	if (!location || !location.search) return;
+	const filters = {};
+	let queryParam = null;
+	const queryParams = parseQueryParams(location.search);
+	if (!queryParams) return;
+	Object.keys(queryParams).forEach(key => {
+		if (key && key.includes('.')) {
+			const [category, filter] = key.split('.');
+			if (!filters[category]) {
+				filters[category] = {};
+			}
+			filters[category][filter] = queryParams[key] === 'true';
+		} else if (key === 'query') {
+			queryParam = queryParams[key];
+		}
+	});
+
+	return { filters, query: queryParam };
+};
+
+export const hasFiltersInURL = location => {
+	if (!location || !location.search) return;
+	const queryParams = parseQueryParams(location.search);
+	if (!queryParams) return;
+	return Object.keys(queryParams).some(key => key.includes('.'));
+};
+
+export const hasQueryInUrl = location => {
+	if (!location || !location.search) return;
+	const queryParams = parseQueryParams(location.search);
+	if (!queryParams) return;
+	return Object.keys(queryParams).includes('query');
+};