@abcagency/hc-ui-components 1.3.21 → 1.3.23

package/src/contexts/mapListContext.tsx

@@ -1,311 +0,0 @@
-import React, { createContext, useState, useEffect, useContext, ReactNode } from 'react';
-
-import { generateFilterOptions, applyFilters, filterListingsByLocation } from '~/util/filterUtil';
-import { getStorageObject, setStorageObject } from '~/util/localStorageUtil';
-import { updateURLWithFilters, filtersFromURL } from '~/util/urlFilterUtil';
-
-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[];
-  setFiltersUrl?:boolean;
-}
-
-export const MapListProvider: React.FC<MapListProviderProps> = ({
-	children,
-	siteConfig,
-	resetFilters,
-	navigateToDetails,
-	navigateToEasyApply,
-	Link,
-	linkFormat,
-	trackEvent,
-	listings = [],
-	setFiltersUrl
-}) => {
-	const firstLoadFilters = () =>{
-		let urlFilters = filtersFromURL(window.location)?.filters;
-		return  (setFiltersUrl === true && urlFilters && Object.keys(urlFilters).length > 0) ? urlFilters  : getStorageObject('selectedFilters', {}) || {}
-	}
-	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 ? {} : firstLoadFilters());
-	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;
-						}
-					}
-				}
-			} 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[];
-			let tempSelectedFilters = selectedFilters;
-			let tempQuery = query;
-
-			const { mapItems, filteredListings: tempFilteredListings } = applyFilters(
-				allListings,
-				tempSelectedFilters,
-				tempQuery,
-				listingEntities,
-				favorites,
-				siteConfig
-			);
-			filteredListings = tempFilteredListings;
-
-			if (filterByFavorites) {
-				filteredListings = filteredListings.filter((x: Listing) => favorites.includes(x.id));
-			}
-			setNewFilteredListings(filteredListings);
-			if (firstLoad && tempSelectedFilters) {
-				// Update URL with filters if needed
-			} else if (Object.keys(tempSelectedFilters).length === 0 && !firstLoad) {
-				localStorage.removeItem('selectedFilters');
-			} else if (!firstLoad) {
-				setStorageObject('selectedFilters', tempSelectedFilters);
-			}
-			if(setFiltersUrl === true)
-			{
-				updateURLWithFilters(tempSelectedFilters, window.location, tempQuery);
-			}
-			tempQuery != null ? localStorage.setItem('query', tempQuery) : localStorage.removeItem('query');
-			setMapItems(mapItems);
-
-			if (tempSelectedFilters) {
-				const keys = Object.keys(tempSelectedFilters);
-				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/contexts/placesContext.js

@@ -1,102 +0,0 @@
-import React, { createContext, useContext, useEffect, useState } from 'react';
-
-import { markerIconProps } from '~/util/mapIconUtil';
-
-import { useMap } from '~/contexts/mapContext';
-
-import { searchNearbyPlaces } from '~/services/googlePlacesNearbyService';
-
-const PlacesContext = createContext();
-
-export const usePlaces = () => useContext(PlacesContext);
-
-export const PlacesProvider = ({ children, placeMappings, markerColors }) => {
-	const { selectedPlaces, zoom, center } = useMap();
-	const [poiMarkers, setPoiMarkers] = useState({ markers: [], icon: null });
-	const [currentCenter, setCurrentCenter] = useState(center);
-	const [currentZoom, setCurrentZoom] = useState(zoom);
-	const [placesWindow, setPlacesWindow] = useState(false);
-	const [selectedPlaceMarker, setSelectedPlaceMarker] = useState(null);
-
-	const getRadiusForZoom = () => {
-		if (currentZoom >= 18) return 1000;
-		if (currentZoom <= 10) return 0;
-
-		let tempZoom = Math.pow(19 - currentZoom, 4.85);
-		let radius = tempZoom;
-		let minRadius = 1500;
-		let maxRadius = 800000;
-
-		if (radius < minRadius) radius = minRadius;
-		else if (radius > maxRadius) radius = maxRadius;
-
-		return radius;
-	};
-
-	useEffect(() => {
-		if (!selectedPlaces || (!selectedPlaces.length > 0) || !center || currentZoom < 12) {
-			setPoiMarkers({ markers: [], icon: null });
-			return;
-		}
-		const fetchPlaces = async () => {
-			let poiTypes = [];
-			const selectedPOICategories = selectedPlaces;
-			selectedPOICategories.forEach(pointOfInterest => {
-				poiTypes = poiTypes.concat(placeMappings[pointOfInterest]);
-			});
-
-			const radius = getRadiusForZoom();
-			const location = { latitude: currentCenter.lat, longitude: currentCenter.lng };
-
-			try {
-				const response = await searchNearbyPlaces(poiTypes, location, radius);
-				const newMarkers = response.places.map(place => {
-					const getParentCategory = types => {
-						const selectedTypes = selectedPOICategories.reduce((acc, category) => {
-							return acc.concat(placeMappings[category]);
-						}, []);
-
-						for (const type of types) {
-							if (!selectedTypes.includes(type)) continue;
-							for (const category in placeMappings) {
-								if (placeMappings[category].includes(type)) {
-									return category;
-								}
-							}
-
-						}
-					};
-
-					const icon = markerIconProps(markerColors.placeMarkers, getParentCategory(place.types));
-
-					return {
-						position: { lat: place.location.latitude, lng: place.location.longitude },
-						title: place.displayName.text,
-						icon: icon
-					};
-				});
-				setPoiMarkers({ markers: newMarkers, icon: null });
-			} catch (error) {
-				console.error('Failed to fetch places:', error);
-			}
-		};
-
-		fetchPlaces();
-	}, [selectedPlaces, currentZoom, currentCenter]);
-
-	return (
-		<PlacesContext.Provider value={{
-			poiMarkers,
-			setCurrentCenter,
-			currentCenter,
-			setCurrentZoom,
-			currentZoom,
-			placesWindow,
-			setPlacesWindow,
-			selectedPlaceMarker,
-			setSelectedPlaceMarker
-		}}>
-			{children}
-		</PlacesContext.Provider>
-	);
-};

package/src/contexts/trackEventContext.js

@@ -1,14 +0,0 @@
-import React, { createContext, useContext } from 'react';
-import { eventTypes } from '~/constants/eventTypes';
-
-const TrackEventContext = createContext();
-
-export const useTrackEvent = () => useContext(TrackEventContext);
-
-export const TrackEventProvider = ({ children, trackEvent }) => {
-	return (
-		<TrackEventContext.Provider value={{ trackEvent, eventTypes }}>
-			{children}
-		</TrackEventContext.Provider>
-	);
-};

package/src/enums/SectionType.ts

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

package/src/hooks/useList.js

@@ -1,89 +0,0 @@
-import { useEffect, useState, useRef } from 'react';
-
-import { getStorageObject } from '~/util/localStorageUtil';
-
-const getDefaultItemId = () => {
-	let item = getStorageObject("selectedListItem");
-	if (item?.expanded == true) {
-		return item.id;
-	} else {
-		return null;
-	}
-};
-
-const useListLogic = filteredListings => {
-	const [itemLimit, setItemLimit] = useState(100);
-	const [expandedId] = useState(getDefaultItemId());
-	const [sortSetting, setSortSetting] = useState(getStorageObject('sortSetting', null));
-	const [scrollPosition, setScrollPosition] = useState(getStorageObject('scrollPosition', 0));
-	const loader = useRef(null);
-	const scrollContainerRef = useRef(null);
-	const itemRefs = useRef({});
-	const observer = useRef(null);
-
-	useEffect(() => {
-		observer.current = new IntersectionObserver(handleObserver, {
-			root: scrollContainerRef.current,
-			rootMargin: "100px 0px",
-			threshold: 0.5
-		});
-		const { current } = loader;
-		if (current) {
-			observer.current.observe(current);
-		}
-		return () => {
-			if (observer.current && current) {
-				observer.current.unobserve(current);
-			}
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [filteredListings.length, itemLimit]);
-
-	useEffect(() => {
-		localStorage.setItem('scrollPosition', scrollPosition.toString());
-	}, [scrollPosition]);
-
-	useEffect(() => {
-		const savedScrollPosition = scrollPosition;
-		if (parseInt(savedScrollPosition) > 3000) {
-			setItemLimit(savedScrollPosition / 10);
-		}
-		if (savedScrollPosition && scrollContainerRef.current) {
-			setTimeout(() => {
-				scrollContainerRef.current.scrollTop = parseInt(savedScrollPosition, 10);
-			}, 300);
-		}
-	}, []);
-
-	useEffect(() => {
-		const { current } = scrollContainerRef;
-		if (current) {
-			current.addEventListener('scroll', handleScroll);
-		}
-		return () => {
-			if (current) {
-				current.removeEventListener('scroll', handleScroll);
-			}
-		};
-	}, []);
-
-	const handleObserver = entities => {
-		const target = entities[0];
-		if (!target.isIntersecting) return;
-		if (filteredListings.length > itemLimit) {
-			setItemLimit(prevLimit => prevLimit + 100);
-		} else if (observer.current) {
-			observer.current.disconnect();
-		}
-	};
-
-	const handleScroll = () => {
-		if (scrollContainerRef.current) {
-			setScrollPosition(scrollContainerRef.current.scrollTop);
-		}
-	};
-
-	return { itemLimit, expandedId, sortSetting, scrollPosition, loader, scrollContainerRef, itemRefs, setSortSetting, setScrollPosition, filteredListings };
-};
-
-export default useListLogic;

package/src/index.js

@@ -1,3 +0,0 @@
-import HireControlMap from '~/components/HireControlMap';
-
-export { HireControlMap };

package/src/services/configService.ts

@@ -1,16 +0,0 @@
-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.ts

@@ -1,42 +0,0 @@
-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 as string,
-		'X-Goog-FieldMask': 'places.location,places.displayName,places.types'
-	};
-	const data = {
-		includedTypes: typesArray,
-		maxResultCount: 20,
-		locationRestriction: {
-			circle: {
-				center: location,
-				radius: radius
-			}
-		}
-	};
-
-	try {
-		const response = await fetch(url, {
-			method: 'POST',
-			headers: headers,
-			body: JSON.stringify(data)
-		});
-		if (!response.ok) {
-			throw new Error(`HTTP error! status: ${response.status}`);
-		}
-		return await response.json();
-	} catch (error) {
-		console.error('Error making the Nearby Search request:', error);
-		throw error;
-	}
-};

package/src/services/listingAggregatorService.ts

@@ -1,76 +0,0 @@
-import { getListings } from '~/services/listingService';
-import { getRecruiters } from '~/services/recruiterService';
-import { getListingEntities } from '~/services/listingEntityService';
-
-import { getDistinctItemsByProximity } from '~/util/mapUtil';
-import { Listing } from '~/types/Listings';
-import { Recruiter } from '~/types/Recruiter';
-import { ListingEntity } from '~/types/ListingEntity';
-import { MapConfig } from '~/types/config/MapConfig';
-//import { ICommuteLocation } from '~/interfaces/ICommute';
-
-interface SiteConfig {
-  companyId: number;
-}
-
-interface FetchListingsResult {
-  listingsResult: Listing[];
-  fetchedRecruiters: Recruiter[];
-  fetchedEntities: Record<number, ListingEntity>;
-  distinctItems: any; // Update this type based on the return type of getDistinctItemsByProximity
-}
-
-const fetchListings = async (
-	query: string,
-	siteConfig: MapConfig,
-	commuteLocation: any | null = null
-): Promise<FetchListingsResult> => {
-	try {
-		const listingsResult = await getListings(
-
-		);
-
-		const recruiterIds: number[] = [
-			...new Set(listingsResult.map(listing => listing.recruiterId))
-		] as number[];
-
-		const fetchedRecruiters = await getRecruiters(recruiterIds);
-
-		const distinctEntityIds: number[] = [
-			...new Set(listingsResult.map(listing => listing.entityId))
-		] as number[];
-
-		const fetchedEntities = !commuteLocation
-			? await getListingEntities(distinctEntityIds)
-			: await getListingEntities(
-				distinctEntityIds,
-				`${commuteLocation.lat}, ${commuteLocation.lng}`
-			);
-		for (let i = 0; i < listingsResult.length; i++) {
-			const listing = listingsResult[i];
-			if (listing.entityId && listing.entityId !== -1 && listing.fields) {
-				const entity = fetchedEntities[listing.entityId];
-				if (entity) {
-					listing.fields.travelTime = entity.travelTime;
-				}
-			}
-		}
-
-		const distinctItems = getDistinctItemsByProximity(
-			listingsResult,
-			fetchedEntities
-		);
-
-		return {
-			listingsResult,
-			fetchedRecruiters,
-			fetchedEntities,
-			distinctItems
-		};
-	} catch (error) {
-		console.error("Error fetching listings:", error);
-		throw error;
-	}
-};
-
-export default fetchListings;

package/src/services/listingEntityService.ts

@@ -1,16 +0,0 @@
-import api from '~/apis/hcApi';
-import { ListingEntity } from '~/types/ListingEntity';
-
-export const getListingEntities = async (entityIds: number[], origin = ''): Promise<ListingEntity[]> => {
-	try {
-		const response = await api.post<ListingEntity[]>(`/ListingEntities?origin=${origin}`, entityIds);
-		return response;
-	} catch (error) {
-		console.error("Error fetching listing entities:", error);
-		throw error;
-	}
-};
-
-export default {
-	getListingEntities
-};