@abcagency/hc-ui-components 1.3.18 → 1.3.19

package/src/components/modules/maps/map-list.js

@@ -1,74 +1,74 @@
-import React from 'react';
-
-import List from '~/components/modules/maps/list';
-import Map from '~/components/modules/maps/map';
-import Tabs from '~/components/modules/maps/tabs';
-import Filter from '~/components/modules/filter';
-
-const MapList = ({
-	loading = false,
-	mapDetails,
-	markerConfigs,
-	itemExpandedContent,
-	fieldsShown,
-	specialFeatures,
-	fieldNames,
-	showMap,
-	placeMappings
-}) => {
-
-	const listProps = {
-		fieldsShown: fieldsShown,
-		fieldNames: fieldNames,
-		itemExpandedContent: itemExpandedContent,
-		loading: loading,
-		showMap: showMap,
-		specialFeatures: specialFeatures
-	};
-
-	const mapProps = {
-		mapDetails: mapDetails,
-		markerConfigs: markerConfigs,
-		placeMappings: placeMappings,
-		clusterGridSize: 60,
-		showMap: showMap
-	};
-
-	// useEffect(() => {
-	// 	if (selectedItem !== null) {
-	// 		trackEvent("Map", "View Location", selectedItem[titlePropName]);
-	// 	}
-	// 	// eslint-disable-next-line react-hooks/exhaustive-deps
-	// }, []);
-	const map = <Map {...mapProps} />;
-	return (
-		<>
-			<div
-				className={`
-					${showMap == false ? "md:hc-grid-rows-[100vh]" : "md:hc-grid-rows-[50vh_50vh]"}
-					md:hc-grid md:hc-pt-4 hc-overflow-hidden hc-relative bg-gray-100
-				`}
-			>
-				<div>
-					<List {...listProps} />
-				</div>
-				<div>{showMap && map}</div>
-			</div>
-			<div className="md:hc-hidden">
-				<Tabs
-					showMap={showMap}
-					list={<List {...listProps} />}
-					map={!loading && showMap && map}
-					filter={
-						<Filter
-							showMap={showMap}
-							className="md:hc-hidden"
-						/>
-					}
-				/>
-			</div>
-		</>
-	);
-};
-
-export default MapList;
+import React from 'react';
+
+import List from '~/components/modules/list';
+import Map from '~/components/modules/maps/map';
+import Tabs from '~/components/modules/maps/tabs';
+import Filter from '~/components/modules/filter';
+
+const MapList = ({
+	loading = false,
+	mapDetails,
+	markerConfigs,
+	itemExpandedContent,
+	fieldsShown,
+	specialFeatures,
+	fieldNames,
+	showMap,
+	placeMappings
+}) => {
+
+	const listProps = {
+		fieldsShown: fieldsShown,
+		fieldNames: fieldNames,
+		itemExpandedContent: itemExpandedContent,
+		loading: loading,
+		showMap: showMap,
+		specialFeatures: specialFeatures
+	};
+
+	const mapProps = {
+		mapDetails: mapDetails,
+		markerConfigs: markerConfigs,
+		placeMappings: placeMappings,
+		clusterGridSize: 60,
+		showMap: showMap
+	};
+
+	// useEffect(() => {
+	// 	if (selectedItem !== null) {
+	// 		trackEvent("Map", "View Location", selectedItem[titlePropName]);
+	// 	}
+	// 	// eslint-disable-next-line react-hooks/exhaustive-deps
+	// }, []);
+	const map = <Map {...mapProps} />;
+	return (
+		<>
+			<div
+				className={`
+					${showMap == false ? "md:hc-grid-rows-[100vh]" : "md:hc-grid-rows-[50vh_50vh]"}
+					md:hc-grid md:hc-pt-4 hc-overflow-hidden hc-relative bg-gray-100
+				`}
+			>
+				<div>
+					<List {...listProps} />
+				</div>
+				<div>{showMap && map}</div>
+			</div>
+			<div className="md:hc-hidden">
+				<Tabs
+					showMap={showMap}
+					list={<List {...listProps} />}
+					map={!loading && showMap && map}
+					filter={
+						<Filter
+							showMap={showMap}
+							className="md:hc-hidden"
+						/>
+					}
+				/>
+			</div>
+		</>
+	);
+};
+
+export default MapList;

package/src/contexts/mapContext.tsx

@@ -0,0 +1,129 @@
+import React, { createContext, useState, useContext, useEffect, useRef, ReactNode } from 'react';
+import { getStorageObject, setStorageObject } from '~/util/localStorageUtil';
+import { Listing } from '~/types/Listings';
+import { LatLng } from '~/types/LatLng';
+interface IMapContext {
+  selectedListItem: Listing | null;
+  setSelectedListItem: (item: Listing | null) => void;
+  location: any | null;
+  setLocation: (location: LatLng | null) => void;
+  center: LatLng;
+  setCenter: (center: LatLng) => void;
+  zoom: number;
+  setZoom: (zoom: number) => void;
+  selectedPlaces: string[];
+  setSelectedPlaces: (places: string[]) => void;
+  mapInteracted: boolean;
+  setMapInteracted: (interacted: boolean) => void;
+  userSetZoom: React.MutableRefObject<boolean>;
+  firstLoadListItem: any;
+  selectItem: (item: Listing, itemLocation: LatLng | null, zoom: number, center: LatLng) => void;
+  filterReset: () => void;
+  selectLocationEntity: (location: LatLng) => void;
+}
+
+const MapContext = createContext<IMapContext | undefined>(undefined);
+
+export const useMap = () => {
+	const context = useContext(MapContext);
+	if (!context) {
+		throw new Error("useMap must be used within a MapProvider");
+	}
+	return context;
+};
+
+interface MapProviderProps {
+  children: ReactNode;
+  resetFilters: boolean;
+}
+
+export const MapProvider: React.FC<MapProviderProps> = ({ children, resetFilters }) => {
+	const [selectedListItem, setSelectedListItem] = useState<Listing | null>(getStorageObject('selectedListItem'));
+	const [location, setLocation] = useState<any>(getStorageObject('location'));
+	const [center, setCenter] = useState<LatLng>(getStorageObject("center", { lat: 39.8283, lng: -98.5795 }) || { lat: 39.8283, lng: -98.5795 });
+	const [zoom, setZoom] = useState<number>(getStorageObject("zoom", 10) || 10);
+	const [selectedPlaces, setSelectedPlaces] = useState<string[]>([]);
+	const [mapInteracted, setMapInteracted] = useState<boolean>(false);
+	const [firstLoadListItem] = useState<any>(getStorageObject('selectedListItem', { id: "defaultId" }));
+	const userSetZoom = useRef<boolean>(true);
+
+	useEffect(() => {
+		setStorageObject("selectedListItem", selectedListItem);
+	}, [selectedListItem]);
+
+	useEffect(() => {
+		localStorage.setItem("zoom", zoom.toString());
+	}, [zoom]);
+
+	useEffect(() => {
+		if (location == null) {
+			localStorage.removeItem("location");
+		} else {
+			setStorageObject("location", location);
+		}
+	}, [location]);
+
+	useEffect(() => {
+		setStorageObject("center", center);
+	}, [center]);
+
+	const selectItem = (item: Listing, itemLocation: LatLng | null, zoom: number, center: LatLng) => {
+		setSelectedListItem(item);
+		if (mapInteracted === false && itemLocation != null) {
+			setLocation(itemLocation);
+		}
+		if (mapInteracted === false || itemLocation != null) {
+			setLocation(itemLocation);
+			setCenter(center);
+		}
+		if (mapInteracted === false) {
+			setZoom(zoom);
+		}
+	};
+
+	const filterReset = () => {
+		setSelectedPlaces([]);
+		setSelectedListItem(null);
+		setLocation(null);
+		setZoom(8);
+		setMapInteracted(false);
+	};
+
+	useEffect(() => {
+		if (resetFilters === true) {
+			filterReset();
+		}
+	}, [resetFilters]);
+
+	const selectLocationEntity = (location: LatLng) => {
+		localStorage.removeItem("selectedListItem");
+		setTimeout(() => setLocation(location), 200);
+		setSelectedListItem(null);
+	};
+
+	return (
+		<MapContext.Provider
+			value={{
+				selectedListItem,
+				setSelectedListItem,
+				location,
+				center,
+				setCenter,
+				zoom,
+				setZoom,
+				selectItem,
+				setSelectedPlaces,
+				selectedPlaces,
+				selectLocationEntity,
+				setLocation,
+				setMapInteracted,
+				mapInteracted,
+				userSetZoom,
+				firstLoadListItem,
+				filterReset
+			}}
+		>
+			{children}
+		</MapContext.Provider>
+	);
+};

package/src/contexts/mapListContext.tsx

@@ -0,0 +1,297 @@
+import React, { createContext, useState, useEffect, useContext, ReactNode } from 'react';
+
+import { generateFilterOptions, applyFilters, filterListingsByLocation } from '~/util/filterUtil';
+import { getStorageObject, setStorageObject } from '~/util/localStorageUtil';
+
+import { getListingEntities } from "~/services/listingEntityService";
+import fetchListings from '~/services/listingAggregatorService';
+
+import { Listing } from '~/types/Listings';
+import { ListingEntity } from '~/types/ListingEntity';
+import { Recruiter } from '~/types/Recruiter';
+import { MapConfig, MapConfig as SiteConfig } from '~/types/config/MapConfig';
+
+interface MapListContextProps {
+  loading: boolean;
+  allListings: Listing[];
+  filteredListings: Listing[];
+  mapItems: any;
+  query: string | null;
+  setNewFilteredListings: (filteredListings: Listing[]) => void;
+  setQuery: (query: string | null) => void;
+  listingEntities: Record<number, ListingEntity> | null;
+  selectedFilters: Record<string, any>;
+  setSelectedFilters: (filters: Record<string, any>) => void;
+  filterOptions: any;
+  recruiters: Record<number, Recruiter>;
+  handleFilterListingsByLocation: (selectedLocation: any) => void;
+  filterDialogIsOpen: boolean;
+  setFilterDialogIsOpen: (isOpen: boolean) => void;
+  setMobileTab: (tab: string) => void;
+  mobileTab: string;
+  siteConfig: SiteConfig;
+  favorites: number[];
+  handleSettingFavorites: (favorites: number[] | null) => void;
+  setFilterByFavorites: (filter: boolean) => void;
+  filterByFavorites: boolean;
+  commuteLocation: any | null;
+  setCommuteLocation: (location: any | null) => void;
+  navigateToDetails: (id: number) => void;
+  navigateToEasyApply: (id: number) => void;
+  Link: React.ComponentType<any>;
+  linkFormat: string;
+  sortSetting: { field: string; type: string };
+  setSortSetting: (setting: { field: string; type: string }) => void;
+  trackEvent: (event: string) => void;
+}
+
+const MapListContext = createContext<MapListContextProps | undefined>(undefined);
+
+export const useMapList = () => {
+	const context = useContext(MapListContext);
+	if (!context) {
+		throw new Error('useMapList must be used within a MapListProvider');
+	}
+	return context;
+};
+
+const getQuery = (): string | null => {
+	let query: string | null = null;
+	if (typeof window !== 'undefined') {
+		query = localStorage.getItem('query');
+	}
+	return query;
+};
+
+interface MapListProviderProps {
+  children: ReactNode;
+  siteConfig: MapConfig;
+  resetFilters: boolean;
+  navigateToDetails: (id: number) => void;
+  navigateToEasyApply: (id: number) => void;
+  Link: React.ComponentType<any>;
+  linkFormat: string;
+  trackEvent: (event: string) => void;
+  listings?: Listing[];
+}
+
+export const MapListProvider: React.FC<MapListProviderProps> = ({
+	children,
+	siteConfig,
+	resetFilters,
+	navigateToDetails,
+	navigateToEasyApply,
+	Link,
+	linkFormat,
+	trackEvent,
+	listings = []
+}) => {
+	const [allListings, setAllListings] = useState<Listing[]>(getStorageObject("listings", listings) || []);
+	const [filteredListings, setFilteredListings] = useState<Listing[]>([]);
+	const [loading, setLoading] = useState<boolean>(false);
+	const [mapItems, setMapItems] = useState<any>(getStorageObject('mapItems', []) || []);
+	const [query, setQuery] = useState<string | null>(() => resetFilters ? null : getQuery());
+	const [sortSetting, setSortSetting] = useState<{ field: string; type: string }>(getStorageObject('sortSetting', { field: 'position', type: 'asc' }) || { field: 'position', type: 'asc' });
+	const [listingEntities, setListingEntities] = useState<Record<number, ListingEntity> | null>(getStorageObject("listingEntities", null));
+	const [firstLoad, setFirstLoad] = useState<boolean>(true);
+	const [commuteLocation, setCommuteLocation] = useState<any | null>(getStorageObject('commuteLocation'));
+	const [selectedFilters, setSelectedFilters] = useState<Record<string, any>>(() => resetFilters ? {} : getStorageObject('selectedFilters', {}) || {});
+	const [filterOptions, setFilterOptions] = useState<any>();
+	const [recruiters, setRecruiters] = useState<Record<number, Recruiter>>(getStorageObject("recruiters", {}) || {});
+	const [filterDialogIsOpen, setFilterDialogIsOpen] = useState<boolean>(false);
+	const [mobileTab, setMobileTab] = useState<string>("listTab");
+	const [favorites, setFavorites] = useState<number[]>([]);
+	const [filterByFavorites, setFilterByFavorites] = useState<boolean>(false);
+
+	const setNewFilteredListings = (filteredListings: Listing[]) => {
+		setFilteredListings(filteredListings);
+	};
+
+	useEffect(() => {
+		if (!sortSetting) return;
+		localStorage.setItem('sortSetting', JSON.stringify(sortSetting));
+		setNewFilteredListings(filteredListings);
+	}, [sortSetting]);
+
+	useEffect(() => {
+		const loadedFavorites = JSON.parse(localStorage.getItem('favorites') || '[]');
+		setFavorites(loadedFavorites);
+	}, []);
+
+	useEffect(() => {
+		setStorageObject("commuteLocation", commuteLocation);
+	}, [commuteLocation]);
+
+	useEffect(() => {
+		if (!commuteLocation) return;
+
+		async function fetchEntities() {
+			const distinctEntityIds = [
+				...new Set(allListings.map(listing => listing.entityId ?? -1))
+			];
+			try {
+				const fetchedEntities = await getListingEntities(
+					distinctEntityIds,
+					`${commuteLocation.lat}, ${commuteLocation.lng}`
+				);
+				setListingEntities(fetchedEntities);
+				const newFilteredListings: Listing[] = [...filteredListings] ?? [];
+				for (let i = 0; i < allListings.length; i++) {
+					const listing = newFilteredListings[i];
+					if (
+						listing &&
+						listing.fields &&
+						listing.entityId !== undefined &&
+						listing.entityId !== -1
+					) {
+						const entityId = listing.entityId;
+						const travelTime = fetchedEntities[entityId]?.travelTime;
+
+						if (travelTime !== undefined && listing.fields) {
+							listing.fields.travelTime = travelTime;
+						}
+					}
+				}
+
+				setNewFilteredListings(newFilteredListings);
+			} catch (error) {
+				console.error("Failed to fetch listing entities:", error);
+			}
+		}
+
+		fetchEntities();
+	}, [commuteLocation, allListings, siteConfig.companyId]);
+
+	useEffect(() => {
+		const handleFetchListings = async () => {
+			if (!getStorageObject('listings') ?? [].length) {
+				setLoading(true);
+			}
+
+			try {
+				const {
+					listingsResult,
+					fetchedRecruiters,
+					fetchedEntities,
+					distinctItems
+				} = await fetchListings(query ?? '', siteConfig, commuteLocation);
+				setAllListings(listingsResult);
+				setRecruiters(fetchedRecruiters);
+				setListingEntities(fetchedEntities);
+				setMapItems(distinctItems);
+				setStorageObject("mapItems", distinctItems);
+				setStorageObject("listingEntities", fetchedEntities);
+				setStorageObject("recruiters", fetchedRecruiters);
+				setStorageObject("listings", listingsResult);
+			} catch (error) {
+				console.log(error);
+			}
+			setLoading(false);
+		};
+		handleFetchListings();
+	}, [query, siteConfig]);
+
+	useEffect(() => {
+		const processListings = () => {
+			let filteredListings: Listing[];
+			const { mapItems, filteredListings: tempFilteredListings } = applyFilters(
+				allListings,
+				selectedFilters,
+				query,
+				listingEntities,
+				favorites,
+				siteConfig
+			);
+			filteredListings = tempFilteredListings;
+
+			if (filterByFavorites) {
+				filteredListings = filteredListings.filter((x: Listing) => favorites.includes(x.id));
+			}
+			setNewFilteredListings(filteredListings);
+			if (firstLoad && selectedFilters) {
+				// Update URL with filters if needed
+			} else if (Object.keys(selectedFilters).length === 0 && !firstLoad) {
+				localStorage.removeItem('selectedFilters');
+			} else if (!firstLoad) {
+				setStorageObject('selectedFilters', selectedFilters);
+			}
+			query != null ? localStorage.setItem('query', query) : localStorage.removeItem('query');
+			setMapItems(mapItems);
+
+			if (selectedFilters) {
+				const keys = Object.keys(selectedFilters);
+				const lastKey = keys[keys.length - 1];
+				const options = generateFilterOptions(
+					firstLoad ? allListings : filteredListings,
+					allListings,
+					siteConfig,
+					filterOptions,
+					lastKey,
+					favorites
+				);
+				if (options) {
+					setFilterOptions(options);
+					if (firstLoad) setFirstLoad(false);
+				}
+			}
+		};
+
+		processListings();
+	}, [selectedFilters, query, listingEntities, filterByFavorites, favorites]);
+
+	const handleFilterListingsByLocation = (selectedLocation: any) => {
+		const { filteredListings } = filterListingsByLocation(
+			allListings,
+			selectedLocation,
+			listingEntities
+		);
+		setNewFilteredListings(filteredListings);
+	};
+
+	const handleSettingFavorites = (newFavorites: number[] | null) => {
+		if (newFavorites == null) {
+			localStorage.removeItem('favorites');
+		} else {
+			setFavorites(newFavorites);
+			localStorage.setItem('favorites', JSON.stringify(newFavorites));
+		}
+	};
+
+	return (
+		<MapListContext.Provider value={{
+			loading,
+			allListings,
+			filteredListings,
+			mapItems,
+			query,
+			setNewFilteredListings,
+			setQuery,
+			listingEntities,
+			selectedFilters,
+			setSelectedFilters,
+			filterOptions,
+			recruiters,
+			handleFilterListingsByLocation,
+			filterDialogIsOpen,
+			setFilterDialogIsOpen,
+			setMobileTab,
+			mobileTab,
+			siteConfig,
+			favorites,
+			handleSettingFavorites,
+			setFilterByFavorites,
+			filterByFavorites,
+			commuteLocation,
+			setCommuteLocation,
+			navigateToDetails,
+			navigateToEasyApply,
+			Link,
+			linkFormat,
+			sortSetting,
+			setSortSetting,
+			trackEvent
+		}}>
+			{children}
+		</MapListContext.Provider>
+	);
+};

package/src/enums/SectionType.ts

@@ -0,0 +1,9 @@
+export enum SectionType {
+	Default = -1,
+	Company = 1,
+	Category = 2,
+	CategoryClass = 3,
+	Entity = 4,
+	CustomVar = 5,
+	REGION = 7
+  }

package/src/services/{configService.js → configService.ts}

@@ -1,16 +1,16 @@
-import api from '~/apis/hcApi';
-
-export const getMapConfig = async () => {
-
-	try {
-		const response = await api.get(`/MapConfig`);
-		return response;
-	} catch (error) {
-		console.error("Error retrieving map configuration:", error);
-		throw error;
-	}
-};
-
-export default {
-	getMapConfig
-};
+import api from '~/apis/hcApi';
+import { MapConfig } from '~/types/config/MapConfig';
+
+export const getMapConfig = async (): Promise<MapConfig> => {
+	try {
+		const response = await api.get<MapConfig>(`/MapConfig`);
+		return response;
+	} catch (error) {
+		console.error("Error retrieving map configuration:", error);
+		throw error;
+	}
+};
+
+export default {
+	getMapConfig
+};

package/src/services/{googlePlacesNearbyService.js → googlePlacesNearbyService.ts}

@@ -1,8 +1,17 @@
-export const searchNearbyPlaces = async (typesArray, location, radius) => {
+export interface Location {
+	latitude: number;
+	longitude: number;
+}
+
+export const searchNearbyPlaces = async (
+	typesArray: string[],
+	location: Location,
+	radius: number
+): Promise<any> => {
 	const url = 'https://places.googleapis.com/v1/places:searchNearby';
 	const headers = {
 		'Content-Type': 'application/json',
-		'X-Goog-Api-Key': process.env.GOOGLE_MAPS_API_KEY,
+		'X-Goog-Api-Key': process.env.GOOGLE_MAPS_API_KEY as string,
 		'X-Goog-FieldMask': 'places.location,places.displayName,places.types'
 	};
 	const data = {