@abcagency/hc-ui-components 1.9.35 → 1.9.36

package/src/contexts/mapListContext.tsx

@@ -1,9 +1,11 @@
-import React, { createContext, useState, useEffect, useContext, useRef, ReactNode, JSX } from 'react';
+import React, { createContext, useState, useEffect, useContext, ReactNode } from 'react';
 
-import { generateFilterOptions, applyFilters, filterListingsByLocation, getFieldValue } from '~/util/filterUtil';
+import { generateFilterOptions, applyFilters, filterListingsByLocation } from '~/util/filterUtil';
 import { getStorageObject, setStorageObject } from '~/util/localStorageUtil';
 import { updateURLWithFilters, filtersFromURL } from '~/util/urlFilterUtil';
-import { useMap } from '~/contexts/mapContext';
+
+import { getListingEntities } from "~/services/listingEntityService";
+import fetchListings from '~/services/listingAggregatorService';
 
 import { Listing } from '~/types/Listings';
 import { ListingEntity } from '~/types/ListingEntity';
@@ -30,7 +32,6 @@ interface MapListContextProps {
   setMobileTab: (tab: string) => void;
   mobileTab: string;
   siteConfig: SiteConfig;
-  googleMapsApiKey?: string;
   favorites: number[];
   resetEntityFilter: () => void;
   handleSettingFavorites: (favorites: number[] | null) => void;
@@ -38,7 +39,6 @@ interface MapListContextProps {
   filterByFavorites: boolean;
   commuteLocation: any | null;
   setCommuteLocation: (location: any | null) => void;
-  setMapBounds: (bounds: google.maps.LatLngBounds | null) => void;
   navigateToDetails: (id: number) => void;
   navigateToEasyApply: (id: number) => void;
   Link: React.ComponentType<any>;
@@ -53,30 +53,6 @@ interface MapListContextProps {
   hiddenFilters?: string[];
   containerStyle?: any;
   ExpandListComponent?: React.ComponentType<{ listing: any }> | ((listing: any) => JSX.Element) | null;
-  mobileDetailsCallback?: ((item: any) => void) | null;
-  noEntities?: boolean;
-  filterConfig?: {
-    hideZeroResults?: boolean;
-    dynamicCounts?: boolean;
-    showFavorites?: boolean;
-    collapsedByDefault?: boolean;
-    sortAlphabetically?: boolean;
-    classNames?: {
-      filterContainer?: string;
-      filterContent?: string;
-      filterAccordion?: string;
-      filterAccordionHeader?: string;
-      filterAccordionContent?: string;
-      filterItem?: string;
-      filterItemLabel?: string;
-      filterItemCheckbox?: string;
-      filterItemCount?: string;
-      searchInput?: string;
-      resetButton?: string;
-      showJobsButton?: string;
-      filterFooter?: string;
-    };
-  };
 }
 
 const MapListContext = createContext<MapListContextProps | undefined>(undefined);
@@ -100,7 +76,6 @@ const getQuery = (localStorageKey: string = ''): string | null => {
 interface MapListProviderProps {
   children: ReactNode;
   siteConfig: MapConfig;
-  googleMapsApiKey?: string;
   resetFilters: boolean;
   navigateToDetails: (id: number) => void;
   navigateToEasyApply: (id: number) => void;
@@ -118,40 +93,13 @@ interface MapListProviderProps {
   defaultFilters?: Record<string, any>;
   containerStyle?: any;
 	localStorageKey: string;
-	getListingEntitiesCallback?: (origin?: string) => Promise<any>;
+	getListingEntitiesCallback?: (entityIds: number[], origin?: string) => Promise<ListingEntity[]>;
   ExpandListComponent?: React.ComponentType<{ listing: Listing }> | ((listing: Listing) => JSX.Element) | null;
-  mobileDetailsCallback?: ((item: any) => void) | null;
-  hideMap?: boolean;
-  hideFilters?: boolean;
-  noEntities?: boolean;
-  filterConfig?: {
-    hideZeroResults?: boolean;
-    dynamicCounts?: boolean;
-    showFavorites?: boolean;
-    collapsedByDefault?: boolean;
-    sortAlphabetically?: boolean;
-    classNames?: {
-      filterContainer?: string;
-      filterContent?: string;
-      filterAccordion?: string;
-      filterAccordionHeader?: string;
-      filterAccordionContent?: string;
-      filterItem?: string;
-      filterItemLabel?: string;
-      filterItemCheckbox?: string;
-      filterItemCount?: string;
-      searchInput?: string;
-      resetButton?: string;
-      showJobsButton?: string;
-      filterFooter?: string;
-    };
-  };
 }
 
 export const MapListProvider: React.FC<MapListProviderProps> = ({
 	children,
 	siteConfig,
-	googleMapsApiKey,
 	resetFilters,
 	navigateToDetails,
 	navigateToEasyApply,
@@ -169,119 +117,41 @@ export const MapListProvider: React.FC<MapListProviderProps> = ({
 	defaultFilters,
 	containerStyle,
 	ExpandListComponent,
-	mobileDetailsCallback = null,
 	getListingEntitiesCallback,
-	localStorageKey,
-	hideMap = false,
-	hideFilters = false,
-	noEntities = false,
-	filterConfig = {
-		hideZeroResults: false,
-		dynamicCounts: true,
-		showFavorites: true,
-		collapsedByDefault: false,
-		sortAlphabetically: false,
-		classNames: {
-			filterContainer: '',
-			filterContent: '',
-			filterAccordion: '',
-			filterAccordionHeader: '',
-			filterAccordionContent: '',
-			filterItem: '',
-			filterItemLabel: '',
-			filterItemCheckbox: '',
-			filterItemCount: '',
-			searchInput: '',
-			resetButton: '',
-			showJobsButton: '',
-			filterFooter: ''
-		}
-	}
+	localStorageKey
 }) => {
 	const firstLoadFilters = () =>{
-		if (typeof window === 'undefined') {
-			return getStorageObject(localStorageKey + 'selectedFilters', {}) || {};
-		}
-		let urlData = filtersFromURL(window.location);
-		let urlFilters = urlData?.filters;
-
-		// If ls-ignore=true is in URL, don't load from localStorage
-		if (urlData?.lsIgnore) {
-			return urlFilters || {};
-		}
-
+		let urlFilters = filtersFromURL(window.location)?.filters;
 		return  (setFiltersUrl === true && urlFilters && Object.keys(urlFilters).length > 0) ? urlFilters  : getStorageObject(localStorageKey + 'selectedFilters', {}) || {}
 	}
-
+	
 	const firstLoadQuery = (): string | null => {
 		if (resetFilters) return null;
-		if (typeof window === 'undefined') return getQuery(localStorageKey);
 		// Check URL first
 		const urlData = filtersFromURL(window.location);
-
-		// If ls-ignore=true is in URL, ONLY use URL query (don't fall back to localStorage)
-		if (urlData?.lsIgnore) {
-			return urlData?.query || null;
-		}
-
-		// If setFiltersUrl is enabled and there's a query in URL, use it
 		if (setFiltersUrl === true && urlData?.query) {
 			return urlData.query;
 		}
-
-		// Only fall back to localStorage if there's NO query param in URL
-		// This prevents localStorage from overriding empty query params
-		if (setFiltersUrl === true && typeof urlData?.query !== 'undefined') {
-			return null; // URL has query param but it's empty/null
-		}
-
-		// Fall back to localStorage only if URL has no query param at all
+		// Fall back to localStorage
 		return getQuery(localStorageKey);
 	}
-
+	
 	const [allListings, setAllListings] = useState<Listing[]>([]);
 	const [filteredListings, setFilteredListings] = useState<Listing[]>([]);
 	const [loading, setLoading] = useState<boolean>(false);
-	const [mapItems, setMapItems] = useState<any>([]);
-	const [query, setQuery] = useState<string | null>(null);
-	const [sortSetting, setSortSetting] = useState<{ field: string; type: string }>({ field: 'position', type: 'asc' });
+	const [mapItems, setMapItems] = useState<any>(getStorageObject(localStorageKey + 'mapItems', []) || []);
+	const [query, setQuery] = useState<string | null>(() => firstLoadQuery());
+	const [sortSetting, setSortSetting] = useState<{ field: string; type: string }>(getStorageObject(localStorageKey + 'sortSetting', { field: 'position', type: 'asc' }) || { field: 'position', type: 'asc' });
 	const [listingEntities, setListingEntities] = useState<Record<number, ListingEntity> | null>({});
 	const [firstLoad, setFirstLoad] = useState<boolean>(true);
-	const [commuteLocation, setCommuteLocation] = useState<any | null>(null);
-	const [selectedFilters, setSelectedFilters] = useState<Record<string, any>>({});
-	const [hasMounted, setHasMounted] = useState(false);
-
-	// Load from localStorage/URL after mount to avoid hydration mismatch
-	useEffect(() => {
-		if (typeof window !== 'undefined') {
-			const storedMapItems = getStorageObject(localStorageKey + 'mapItems', []) || [];
-			const storedSortSetting = getStorageObject(localStorageKey + 'sortSetting', { field: 'position', type: 'asc' }) || { field: 'position', type: 'asc' };
-			const storedCommuteLocation = getStorageObject(localStorageKey + 'commuteLocation');
-
-			setMapItems(storedMapItems);
-			setSortSetting(storedSortSetting);
-			if (storedCommuteLocation) setCommuteLocation(storedCommuteLocation);
-
-			// Load filters and query
-			if (!resetFilters) {
-				setSelectedFilters(firstLoadFilters());
-				setQuery(firstLoadQuery());
-			}
-
-			setHasMounted(true);
-		}
-	}, [localStorageKey]);
+	const [commuteLocation, setCommuteLocation] = useState<any | null>(getStorageObject('commuteLocation'));
+	const [selectedFilters, setSelectedFilters] = useState<Record<string, any>>(() => resetFilters ? {} : firstLoadFilters());
 	const [filterOptions, setFilterOptions] = useState<any>();
 	const [recruiters, setRecruiters] = useState<Record<number, Recruiter>>({});
 	const [filterDialogIsOpen, setFilterDialogIsOpen] = useState<boolean>(false);
 	const [mobileTab, setMobileTab] = useState<string>("listTab");
 	const [favorites, setFavorites] = useState<number[]>([]);
 	const [filterByFavorites, setFilterByFavorites] = useState<boolean>(false);
-	const entitiesInitialized = useRef<boolean>(false);
-	const [mapBounds, setMapBounds] = useState<google.maps.LatLngBounds | null>(null);
-	const [baseFilteredListings, setBaseFilteredListings] = useState<Listing[]>([]); // Store listings before bounds filtering
-	const isApplyingBoundsFilter = useRef<boolean>(false);
-	const boundsDebounceTimer = useRef<NodeJS.Timeout | null>(null);
 
 	const setNewFilteredListings = (filteredListings: Listing[]) => {
 		setFilteredListings(filteredListings);
@@ -289,13 +159,11 @@ export const MapListProvider: React.FC<MapListProviderProps> = ({
 
 	useEffect(() => {
 		if (!sortSetting) return;
-		if (typeof window !== 'undefined') {
-			localStorage.setItem(localStorageKey + 'sortSetting', JSON.stringify(sortSetting));
-		}
+		localStorage.setItem(localStorageKey + 'sortSetting', JSON.stringify(sortSetting));
+		setNewFilteredListings(filteredListings);
 	}, [sortSetting, localStorageKey]);
 
 	useEffect(() => {
-		if (typeof window === 'undefined') return;
 		const loadedFavorites = JSON.parse(localStorage.getItem(localStorageKey + 'favorites') || '[]');
 		setFavorites(loadedFavorites);
 	}, [localStorageKey]);
@@ -304,157 +172,103 @@ export const MapListProvider: React.FC<MapListProviderProps> = ({
 		setStorageObject(localStorageKey + "commuteLocation", commuteLocation);
 	}, [commuteLocation, localStorageKey]);
 
-
 	useEffect(() => {
-		if (!commuteLocation || noEntities) return;
+		if (!commuteLocation) return;
 
 		async function fetchEntities() {
+			const distinctEntityIds = [
+				...new Set(allListings.map(listing => listing.entityId ?? -1))
+			];
 			try {
-				// Only fetch if callback is provided
-				if (!getListingEntitiesCallback) {
-					return;
-				}
-
-				const fetchedEntities = await getListingEntitiesCallback(`${commuteLocation.lat}, ${commuteLocation.lng}`);
-				console.log('Fetched entities with travel times:', fetchedEntities);
+				console.log(getListingEntitiesCallback);
+				console.log("fetching entities")
+				const fetchedEntities = getListingEntitiesCallback !== null && getListingEntitiesCallback !== undefined ? await getListingEntitiesCallback(distinctEntityIds,
+					`${commuteLocation.lat}, ${commuteLocation.lng}`) : await getListingEntities(
+					distinctEntityIds,
+					`${commuteLocation.lat}, ${commuteLocation.lng}`
+				);
 				setListingEntities(fetchedEntities);
-
-				// Update travelTime on ALL listings (both allListings and filteredListings)
-				const updatedAllListings = allListings.map(listing => {
+				const newFilteredListings: Listing[] = [...filteredListings] ?? [];
+				for (let i = 0; i < allListings.length; i++) {
+					const listing = newFilteredListings[i];
 					if (
 						listing &&
 						listing.fields &&
-						listing.fields.entityKey &&
-						listing.fields.entityKey !== ''
+						listing.entityId !== undefined &&
+						listing.entityId !== -1
 					) {
-						const entityKey = listing.fields.entityKey;
-						// Try exact match first, then lowercase match for case-insensitive lookup
-						const travelTime = (fetchedEntities[entityKey] || fetchedEntities[entityKey.toLowerCase()])?.travelTime;
-						if (travelTime !== undefined) {
-							return {
-								...listing,
-								fields: {
-									...listing.fields,
-									travelTime
-								}
-							};
+						const entityId = listing.entityId;
+						const travelTime = fetchedEntities[entityId]?.travelTime;
+
+						if (travelTime !== undefined && listing.fields) {
+							listing.fields.travelTime = travelTime;
 						}
 					}
-					return listing;
-				});
-
-				console.log('Updated listings with travel times:', updatedAllListings.slice(0, 2));
-				setAllListings(updatedAllListings);
+				}
 			} catch (error) {
 				console.error("Failed to fetch listing entities:", error);
 			}
 		}
 
 		fetchEntities();
-	}, [commuteLocation, noEntities]);
+	}, [commuteLocation, allListings, siteConfig.companyId]);
 
-	// Set listingEntities from passed-in entities (only once on initial load)
-	// Entities should be an object: { "rochester, mn": {...}, "albuquerque, nm": {...} }
-	// Note: Commute location changes will fetch updated entities with travel times via separate useEffect
 	useEffect(() => {
-		if (!entities || entitiesInitialized.current) return;
-
-		entitiesInitialized.current = true;
-
-		// Handle both object (production format) and array (for backwards compatibility)
-		if (Array.isArray(entities)) {
-			// Convert array to object
-			const entitiesObj: Record<string, any> = {};
-			entities.forEach((entity: any) => {
-				if (entity.entityKey) {
-					entitiesObj[entity.entityKey.toLowerCase()] = entity;
-				}
-			});
-			console.log('Set listingEntities from entities array:', entitiesObj);
-			setListingEntities(entitiesObj);
-		} else if (typeof entities === 'object') {
-			// Normalize keys to lowercase for production format
-			const normalizedEntities: Record<string, any> = {};
-			Object.keys(entities).forEach(key => {
-				normalizedEntities[key.toLowerCase()] = entities[key];
-			});
-			console.log('Set listingEntities from entities object:', normalizedEntities);
-			setListingEntities(normalizedEntities);
-		}
-	// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, []); // Empty deps - only run once on mount, entities are static data
-
-	// Set listings from passed-in data
-	useEffect(() => {
-		if (!listings || listings.length === 0) {
-			setLoading(false);
-			return;
-		}
-
-		setLoading(true);
+		const handleFetchListings = async () => {
+			if (!getStorageObject(localStorageKey + 'listings') ?? [].length) {
+				setLoading(true);
+			}
 
-		try {
-			// Apply default filters if provided
-			let processedListings = listings;
-			if (defaultFilters) {
-				processedListings = listings.filter(listing => {
-				return Object.keys(defaultFilters).every(filterKey => {
-					const filterValues = defaultFilters[filterKey as keyof typeof defaultFilters];
-					const listingValue = getFieldValue(listing, filterKey);
-					return filterValues.includes(listingValue);
+			try {
+				const {
+					listingsResult,
+					fetchedEntities,
+					distinctItems
+				} = await fetchListings(commuteLocation, entities, listings, getListingEntitiesCallback);
+				if (defaultFilters) {
+					const filteredListings = listingsResult.filter(listing => {
+					if (!listing.fields) return false;
+
+					return Object.keys(defaultFilters).every(filterKey => {
+						const filterValues = defaultFilters[filterKey as keyof typeof defaultFilters];
+						const listingValue = listing.fields ? listing.fields[filterKey as keyof typeof listing.fields] : null;
+						return filterValues.includes(listingValue);
+					});
 				});
-			});
-		}
-
-		setAllListings(processedListings);
-		console.log('Set allListings to', processedListings.length, 'items');
-		
-		// Map items will be set when entities are processed
-		// For now, just set empty object - will be populated when entities arrive
-		setMapItems({});
-	} catch (error) {
-		console.error('Error processing listings:', error);
-	}
-	
-	setLoading(false);
-}, [listings]);
-
-useEffect(() => {
-	const processListings = async () => {
-		// Don't process if allListings hasn't been loaded yet
-		if (allListings.length === 0) {
-			console.log('processListings: Skipping - allListings is empty');
-			return;
-		}
-
-		let filteredListings: Listing[];
-		let tempSelectedFilters = selectedFilters;
-		let tempQuery = query;
+				setAllListings(filteredListings);
+			} else {
+				setAllListings(listingsResult);
+			}
+				setListingEntities(fetchedEntities);
+				setMapItems(distinctItems);
+			} catch (error) {
+				console.log(error);
+			}
+			setLoading(false);
+		};
+		handleFetchListings();
+	}, [query, siteConfig, commuteLocation]);
 
-		console.log('processListings: Running with query:', tempQuery, 'and', allListings.length, 'listings');
+	useEffect(() => {
+		const processListings = () => {
+			let filteredListings: Listing[];
+			let tempSelectedFilters = selectedFilters;
+			let tempQuery = query;
 
-		const { mapItems, filteredListings: tempFilteredListings } = await applyFilters(
+			const { mapItems, filteredListings: tempFilteredListings } = applyFilters(
 				allListings,
 				tempSelectedFilters,
 				tempQuery,
 				listingEntities,
 				favorites,
-				siteConfig,
-				firstLoad
+				siteConfig
 			);
 			filteredListings = tempFilteredListings;
 
 			if (filterByFavorites) {
 				filteredListings = filteredListings.filter((x: Listing) => favorites.includes(x.id));
 			}
-
-			// Store the base filtered listings (before bounds filtering)
-			setBaseFilteredListings(filteredListings);
-
-			// Batch state updates together
 			setNewFilteredListings(filteredListings);
-			setMapItems(mapItems);
-
 			if (firstLoad && tempSelectedFilters) {
 				// Update URL with filters if needed
 			} else if (Object.keys(tempSelectedFilters).length === 0 && !firstLoad) {
@@ -462,42 +276,16 @@ useEffect(() => {
 			} else if (!firstLoad) {
 				setStorageObject(localStorageKey + 'selectedFilters', tempSelectedFilters);
 			}
-			if(setFiltersUrl === true && typeof window !== 'undefined')
+			if(setFiltersUrl === true)
 			{
 				updateURLWithFilters(tempSelectedFilters, window.location, tempQuery, handleUrlUpdate);
 			}
-			if (typeof window !== 'undefined') {
-				tempQuery != null ? localStorage.setItem(localStorageKey + 'query', tempQuery) : localStorage.removeItem(localStorageKey + 'query');
-			}
+			tempQuery != null ? localStorage.setItem(localStorageKey + 'query', tempQuery) : localStorage.removeItem(localStorageKey + 'query');
+			setMapItems(mapItems);
 
 			if (tempSelectedFilters) {
 				const keys = Object.keys(tempSelectedFilters);
 				const lastKey = keys[keys.length - 1];
-
-				// Ensure all filterConfig properties have values
-				const normalizedFilterConfig = {
-					hideZeroResults: filterConfig?.hideZeroResults ?? false,
-					dynamicCounts: filterConfig?.dynamicCounts ?? true,
-					showFavorites: filterConfig?.showFavorites ?? true,
-					collapsedByDefault: filterConfig?.collapsedByDefault ?? false,
-					sortAlphabetically: filterConfig?.sortAlphabetically ?? false,
-					classNames: {
-						filterContainer: filterConfig?.classNames?.filterContainer ?? '',
-						filterContent: filterConfig?.classNames?.filterContent ?? '',
-						filterAccordion: filterConfig?.classNames?.filterAccordion ?? '',
-						filterAccordionHeader: filterConfig?.classNames?.filterAccordionHeader ?? '',
-						filterAccordionContent: filterConfig?.classNames?.filterAccordionContent ?? '',
-						filterItem: filterConfig?.classNames?.filterItem ?? '',
-						filterItemLabel: filterConfig?.classNames?.filterItemLabel ?? '',
-						filterItemCheckbox: filterConfig?.classNames?.filterItemCheckbox ?? '',
-						filterItemCount: filterConfig?.classNames?.filterItemCount ?? '',
-						searchInput: filterConfig?.classNames?.searchInput ?? '',
-						resetButton: filterConfig?.classNames?.resetButton ?? '',
-						showJobsButton: filterConfig?.classNames?.showJobsButton ?? '',
-						filterFooter: filterConfig?.classNames?.filterFooter ?? ''
-					}
-				};
-
 				const options = generateFilterOptions(
 					filteredListings,
 					allListings,
@@ -505,8 +293,7 @@ useEffect(() => {
 					filterOptions,
 					lastKey,
 					favorites,
-					tempSelectedFilters,
-					normalizedFilterConfig
+					tempSelectedFilters
 				);
 				if (options) {
 					setFilterOptions(options);
@@ -516,76 +303,7 @@ useEffect(() => {
 		};
 
 		processListings();
-	}, [selectedFilters, query, filterByFavorites, favorites, allListings]);
-
-	// Separate effect for map bounds filtering with debouncing to avoid infinite loops
-	useEffect(() => {
-		// Clear any existing timer
-		if (boundsDebounceTimer.current) {
-			clearTimeout(boundsDebounceTimer.current);
-		}
-
-		// Don't filter if feature is disabled or no bounds available
-		if (!siteConfig.filterByMapBounds || !mapBounds || baseFilteredListings.length === 0) {
-			return;
-		}
-
-		// Prevent re-entrant calls
-		if (isApplyingBoundsFilter.current) {
-			return;
-		}
-
-		// Debounce the bounds filtering by 300ms
-		boundsDebounceTimer.current = setTimeout(() => {
-			isApplyingBoundsFilter.current = true;
-			
-			console.log('Applying map bounds filter to', baseFilteredListings.length, 'listings');
-			
-			const boundsFilteredListings = baseFilteredListings.filter((listing: Listing) => {
-				const lat = listing.mapDetails?.latitude;
-				const lng = listing.mapDetails?.longitude;
-				if (!lat || !lng) return false;
-				return mapBounds.contains({ lat, lng });
-			});
-
-			console.log('After bounds filter:', boundsFilteredListings.length, 'listings remain');
-			
-			// Use a flag to prevent this from triggering processListings
-			setFilteredListings(boundsFilteredListings);
-			
-			// Reset the flag after a short delay
-			setTimeout(() => {
-				isApplyingBoundsFilter.current = false;
-			}, 100);
-		}, 300);
-
-		return () => {
-			if (boundsDebounceTimer.current) {
-				clearTimeout(boundsDebounceTimer.current);
-			}
-		};
-	}, [mapBounds, siteConfig.filterByMapBounds]);
-
-	// When baseFilteredListings changes, apply bounds filter if enabled
-	useEffect(() => {
-		if (!siteConfig.filterByMapBounds || !mapBounds || baseFilteredListings.length === 0) {
-			// If bounds filtering is disabled, just set the base listings
-			if (!siteConfig.filterByMapBounds && baseFilteredListings.length > 0) {
-				setFilteredListings(baseFilteredListings);
-			}
-			return;
-		}
-
-		// If bounds filtering is enabled, trigger it
-		const boundsFilteredListings = baseFilteredListings.filter((listing: Listing) => {
-			const lat = listing.mapDetails?.latitude;
-			const lng = listing.mapDetails?.longitude;
-			if (!lat || !lng) return false;
-			return mapBounds.contains({ lat, lng });
-		});
-
-		setFilteredListings(boundsFilteredListings);
-	}, [baseFilteredListings]);
+	}, [selectedFilters, query, listingEntities, filterByFavorites, favorites]);
 
 	const handleFilterListingsByLocation = (selectedLocation: any) => {
 		const { filteredListings } = filterListingsByLocation(
@@ -603,7 +321,6 @@ useEffect(() => {
 	}
 
 	const handleSettingFavorites = (newFavorites: number[] | null) => {
-		if (typeof window === 'undefined') return;
 		if (newFavorites == null) {
 			localStorage.removeItem(localStorageKey + 'favorites');
 		} else {
@@ -632,7 +349,6 @@ useEffect(() => {
 			setMobileTab,
 			mobileTab,
 			siteConfig,
-			googleMapsApiKey,
 			favorites,
 			handleSettingFavorites,
 			resetEntityFilter,
@@ -640,7 +356,6 @@ useEffect(() => {
 			filterByFavorites,
 			commuteLocation,
 			setCommuteLocation,
-			setMapBounds,
 			navigateToDetails,
 			navigateToEasyApply,
 			Link,
@@ -654,9 +369,7 @@ useEffect(() => {
 			defaultFilters,
 			hiddenFilters,
 			containerStyle,
-			ExpandListComponent,
-			mobileDetailsCallback,			noEntities,
-			filterConfig
+			ExpandListComponent
 		}}>
 			{children}
 		</MapListContext.Provider>

package/src/contexts/placesContext.js

@@ -10,7 +10,7 @@ const PlacesContext = createContext();
 
 export const usePlaces = () => useContext(PlacesContext);
 
-export const PlacesProvider = ({ children, placeMappings, markerColors, additionalMapMarkers, googleMapsApiKey, showAtZoomLevel = 12 }) => {
+export const PlacesProvider = ({ children, placeMappings, markerColors, additionalMapMarkers, googleMapsApiKey }) => {
 	const { selectedPlaces, zoom, center } = useMap();
 	const [poiMarkers, setPoiMarkers] = useState({ markers: [], icon: null });
 	const [currentCenter, setCurrentCenter] = useState(center);
@@ -34,7 +34,7 @@ export const PlacesProvider = ({ children, placeMappings, markerColors, addition
 	}, [currentZoom]);
 
 	useEffect(() => {
-		if (!selectedPlaces || selectedPlaces.length === 0 || !center || currentZoom < showAtZoomLevel) {
+		if (!selectedPlaces || (!selectedPlaces.length > 0) || !center || currentZoom < 12) {
 			setPoiMarkers({ markers: [], icon: null });
 			return;
 		}
@@ -82,7 +82,7 @@ export const PlacesProvider = ({ children, placeMappings, markerColors, addition
 		};
 
 		fetchPlaces();
-	}, [selectedPlaces, currentZoom, currentCenter, placeMappings, markerColors.placeMarkers, googleMapsApiKey, getRadiusForZoom, center, showAtZoomLevel]);
+	}, [selectedPlaces, currentZoom, currentCenter, placeMappings, markerColors.placeMarkers, googleMapsApiKey, getRadiusForZoom, center]);
 
 	return (
 		<PlacesContext.Provider value={{