@abcagency/hc-ui-components 1.3.23 → 1.3.24

package/src/hooks/useList.js

@@ -0,0 +1,89 @@
+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

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

package/src/services/configService.ts

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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,16 @@
+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
+};

package/src/services/listingService.ts

@@ -0,0 +1,40 @@
+// listingService.ts
+import { GetListingsParams } from '~/types/GetListingParams';
+import api from '../apis/hcApi';
+import { Listing } from '../types/Listings';
+
+export const getListings = async (params?: GetListingsParams): Promise<Listing[]> => {
+	try {
+		const query = new URLSearchParams();
+
+		if (params) {
+			if (params.location) params.location.forEach(loc => query.append('location', loc));
+			if (params.category) params.category.forEach(cat => query.append('category', cat));
+			if (params.categoryClass) params.categoryClass.forEach(catClass => query.append('categoryClass', catClass));
+			if (params.education) params.education.forEach(edu => query.append('education', edu));
+			if (params.city) params.city.forEach(cty => query.append('city', cty));
+			if (params.state) params.state.forEach(st => query.append('state', st));
+		}
+
+		const response = await api.get(`/Listings?${query.toString()}`);
+		return response as Listing[];
+	} catch (error) {
+		console.error(error);
+		throw error;
+	}
+};
+
+export const getListingDetails = async (listingId: string) => {
+	try {
+		const response = await api.get(`/ListingDetails/${listingId}`);
+		return response;
+	} catch (error) {
+		console.error(error);
+		throw error;
+	}
+};
+
+export default {
+	getListings,
+	getListingDetails
+};

package/src/services/recruiterService.ts

@@ -0,0 +1,18 @@
+import api from '~/apis/hcApi';
+import { Recruiter } from '~/types/Recruiter';
+
+export const getRecruiters = async (recruiterIds: number[]): Promise<Recruiter[]> => {
+	try {
+		const params = recruiterIds.map(id => `recruiterIds=${id}`).join("&");
+
+		const response = await api.get<Recruiter[]>(`/Recruiters?${params}`);
+		return response;
+	} catch (error) {
+		console.error("Error fetching recruiters:", error);
+		throw error;
+	}
+};
+
+export default {
+	getRecruiters
+};

package/src/styles/bundle.css

@@ -0,0 +1,268 @@
+/* Custom prefixed styles */
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+.hc-bundle html {
+	font-size: 14px;
+  }
+
+  @media (min-width: 768px) {
+	.hc-bundle html {
+	  font-size: 16px;
+	}
+  }
+
+  .hc-bundle .btn:focus, .hc-bundle .btn:active:focus, .hc-bundle .btn-link.nav-link:focus, .hc-bundle .form-control:focus, .hc-bundle .form-check-input:focus {
+	box-shadow: 0 0 0 0.1rem white, 0 0 0 0.25rem #258cfb;
+  }
+
+  .hc-bundle html {
+	position: relative;
+	min-height: 100%;
+  }
+
+  .hc-bundle body {
+	margin-bottom: 60px;
+  }
+
+  .hc-bundle *, .hc-bundle :after, .hc-bundle :before {
+	border: 0 solid #e5e7eb;
+	box-sizing: border-box;
+  }
+
+  .hc-bundle :after, .hc-bundle :before {
+	--tw-content: "";
+  }
+
+  .hc-bundle :host, .hc-bundle html {
+	-webkit-text-size-adjust: 100%;
+	font-feature-settings: normal;
+	-webkit-tap-highlight-color: transparent;
+	font-family: var(--font-roboto-flex), ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+	font-variation-settings: normal;
+	line-height: 1.5;
+	-moz-tab-size: 4;
+	-o-tab-size: 4;
+	tab-size: 4;
+  }
+
+
+  .hc-bundle hr {
+	border-top-width: 1px;
+	color: inherit;
+	height: 0;
+  }
+
+  .hc-bundle abbr:where([title]) {
+	-webkit-text-decoration: underline dotted;
+	text-decoration: underline dotted;
+  }
+
+
+  .hc-bundle a {
+	color: inherit;
+	text-decoration: inherit;
+  }
+
+  .hc-bundle b, .hc-bundle strong {
+	font-weight: bolder;
+  }
+
+  .hc-bundle code, .hc-bundle kbd, .hc-bundle pre, .hc-bundle samp {
+	font-feature-settings: normal;
+	font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, Liberation Mono, Courier New, monospace;
+	font-size: 1em;
+	font-variation-settings: normal;
+  }
+
+  .hc-bundle small {
+	font-size: 80%;
+  }
+
+  .hc-bundle sub, .hc-bundle sup {
+	font-size: 75%;
+	line-height: 0;
+	position: relative;
+	vertical-align: baseline;
+  }
+
+  .hc-bundle sub {
+	bottom: -.25em;
+  }
+
+  .hc-bundle sup {
+	top: -.5em;
+  }
+
+  .hc-bundle table {
+	border-collapse: collapse;
+	border-color: inherit;
+	text-indent: 0;
+  }
+
+  .hc-bundle button, .hc-bundle input, .hc-bundle optgroup, .hc-bundle select, .hc-bundle textarea {
+	font-feature-settings: inherit;
+	color: inherit;
+	font-family: inherit;
+	font-size: 100%;
+	font-variation-settings: inherit;
+	font-weight: inherit;
+	letter-spacing: inherit;
+	line-height: inherit;
+	margin: 0;
+	padding: 0;
+  }
+
+  .hc-bundle button, .hc-bundle select {
+	text-transform: none;
+  }
+
+  .hc-bundle button, .hc-bundle input:where([type=button]), .hc-bundle input:where([type=reset]), .hc-bundle input:where([type=submit]) {
+	-webkit-appearance: button;
+	background-color: transparent;
+	background-image: none;
+  }
+
+  .hc-bundle :-moz-focusring {
+	outline: auto;
+  }
+
+  .hc-bundle :-moz-ui-invalid {
+	box-shadow: none;
+  }
+
+  .hc-bundle progress {
+	vertical-align: baseline;
+  }
+
+  .hc-bundle ::-webkit-inner-spin-button, .hc-bundle ::-webkit-outer-spin-button {
+	height: auto;
+  }
+
+  .hc-bundle [type=search] {
+	-webkit-appearance: textfield;
+	outline-offset: -2px;
+  }
+
+  .hc-bundle ::-webkit-search-decoration {
+	-webkit-appearance: none;
+  }
+
+  .hc-bundle ::-webkit-file-upload-button {
+	-webkit-appearance: button;
+	font: inherit;
+  }
+
+  .hc-bundle summary {
+	display: list-item;
+  }
+
+  .hc-bundle textarea {
+	resize: vertical;
+  }
+
+  .hc-bundle input::-moz-placeholder, .hc-bundle textarea::-moz-placeholder {
+	color: #9ca3af;
+  }
+
+  .hc-bundle input::placeholder, .hc-bundle textarea::placeholder {
+	color: #9ca3af;
+  }
+
+  .hc-bundle [role=button], .hc-bundle button {
+	cursor: pointer;
+  }
+
+  .hc-bundle :disabled {
+	cursor: default;
+  }
+
+  .hc-bundle audio, .hc-bundle canvas, .hc-bundle embed, .hc-bundle iframe, .hc-bundle img, .hc-bundle object, .hc-bundle svg, .hc-bundle video {
+	display: block;
+	vertical-align: middle;
+  }
+
+  .hc-bundle img, .hc-bundle video {
+	height: auto;
+	max-width: 100%;
+  }
+
+  .hc-bundle [hidden] {
+	display: none;
+  }
+
+  .hc-bundle [multiple], .hc-bundle [type=date], .hc-bundle [type=datetime-local], .hc-bundle [type=email], .hc-bundle [type=month], .hc-bundle [type=number], .hc-bundle [type=password], .hc-bundle [type=search], .hc-bundle [type=tel], .hc-bundle [type=text], .hc-bundle [type=time], .hc-bundle [type=url], .hc-bundle [type=week], .hc-bundle input:where(:not([type])), .hc-bundle select, .hc-bundle textarea {
+	--tw-shadow: 0 0 #0000;
+	-webkit-appearance: none;
+	-moz-appearance: none;
+	appearance: none;
+	background-color: #fff;
+	border-color: #6b7280;
+	border-radius: 0;
+	border-width: 1px;
+	font-size: 1rem;
+	line-height: 1.5rem;
+	padding: .5rem .75rem;
+  }
+
+  .hc-bundle [multiple]:focus, .hc-bundle [type=date]:focus, .hc-bundle [type=datetime-local]:focus, .hc-bundle [type=email]:focus, .hc-bundle [type=month]:focus, .hc-bundle [type=number]:focus, .hc-bundle [type=password]:focus, .hc-bundle [type=search]:focus, .hc-bundle [type=tel]:focus, .hc-bundle [type=text]:focus, .hc-bundle [type=time]:focus, .hc-bundle [type=url]:focus, .hc-bundle [type=week]:focus, .hc-bundle input:where(:not([type])):focus, .hc-bundle select:focus, .hc-bundle textarea:focus {
+	--tw-ring-inset: var(--tw-empty, /*!*/ /*!*/);
+	--tw-ring-offset-width: 0px;
+	--tw-ring-offset-color: #fff;
+	--tw-ring-color: #2563eb;
+	--tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
+	--tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color);
+	border-color: #2563eb;
+	box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+	outline: 2px solid transparent;
+	outline-offset: 2px;
+  }
+
+  .hc-bundle input::-moz-placeholder, .hc-bundle textarea::-moz-placeholder {
+	color: #6b7280;
+	opacity: 1;
+  }
+
+  .hc-bundle input::placeholder, .hc-bundle textarea::placeholder {
+	color: #6b7280;
+	opacity: 1;
+  }
+
+  .hc-bundle ::-webkit-datetime-edit-fields-wrapper {
+	padding: 0;
+  }
+
+  .hc-bundle ::-webkit-date-and-time-value {
+	min-height: 1.5em;
+	text-align: inherit;
+  }
+
+  .hc-bundle ::-webkit-datetime-edit {
+	display: inline-flex;
+  }
+
+  .hc-bundle ::-webkit-datetime-edit, .hc-bundle ::-webkit-datetime-edit-day-field, .hc-bundle ::-webkit-datetime-edit-hour-field, .hc-bundle ::-webkit-datetime-edit-meridiem-field, .hc-bundle ::-webkit-datetime-edit-millisecond-field, .hc-bundle ::-webkit-datetime-edit-minute-field, .hc-bundle ::-webkit-datetime-edit-month-field, .hc-bundle ::-webkit-datetime-edit-second-field, .hc-bundle ::-webkit-datetime-edit-year-field {
+	padding-bottom: 0;
+	padding-top: 0;
+  }
+
+  .hc-bundle select {
+	background-image: url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 20 20'%3E%3Cpath stroke='%236b7280' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.5' d='m6 8 4 4 4-4'/%3E%3C/svg%3E");
+	background-position: right .5rem center;
+	background-repeat: no-repeat;
+	background-size: 1.5em 1.5em;
+	padding-right: 2.5rem;
+	-webkit-print-color-adjust: exact;
+	print-color-adjust: exact;
+  }
+
+  .hc-bundle [multiple], .hc-bundle [size]:where(select:not([size="1"])) {
+	background-image: none;
+	background-position: 0 0;
+	background-repeat: unset;
+	background-size: auto auto;
+	background-size: initial;
+	padding-right: .75rem;
+	-webkit-print-color-adjust: unset;
+	print-color-adjust: unset;
+  }

package/src/styles/index.css

@@ -0,0 +1,24 @@
+@config "../../tailwind.config.js";
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+	html {
+		@apply hc-text-400 hc-text-uiText [scroll-behavior:smooth];
+	}
+}
+
+@layer components {
+	.track * {
+		@apply hc-pointer-events-none;
+	}
+
+	.stretched-link::after {
+		@apply hc-content-[''] hc-absolute hc-inset-0 hc-z-[1] hc-pointer-events-auto hc-bg-transparent;
+	}
+}
+
+.fit-content{
+	height:fit-content;
+}

package/src/types/Address.ts

@@ -0,0 +1,7 @@
+export type Address = {
+	location?: string;
+	street?: string;
+	city?: string;
+	state?: string;
+	zip?: string;
+  }

package/src/types/ContentSection.ts

@@ -0,0 +1,9 @@
+import { SectionType } from '../enums/SectionType';
+
+export type ContentSection = {
+  title?: string;
+  contentFormatted?: string;
+  contentRaw?: string;
+  sectionType: SectionType;
+  sortIndex: number;
+}

package/src/types/GetListingParams.ts

@@ -0,0 +1,8 @@
+export type GetListingsParams = {
+	location?: string[];
+	category?: string[];
+	categoryClass?: string[];
+	education?: string[];
+	city?: string[];
+	state?: string[];
+  };

package/src/types/LatLng.ts

@@ -0,0 +1,4 @@
+export type LatLng = {
+	lat: number;
+	lng: number;
+  }

package/src/types/ListingEntity.ts

@@ -0,0 +1,11 @@
+import { Address } from './Address';
+
+export type ListingEntity = {
+  id: number;
+  listingId: number;
+  latitude: number;
+  longitude: number;
+  entityDisplayName?: string;
+  address?: Address;
+  travelTime?: string;
+}

package/src/types/ListingFields.ts

@@ -0,0 +1,25 @@
+export type ListingFields = {
+	posted?: string;
+	subTitle?: string;
+	education?: string;
+	position?: string;
+	category?: string;
+	categoryClass?: string;
+	shift?: string;
+	custom1?: string;
+	custom2?: string;
+	custom3?: string;
+	custom4?: string;
+	custom5?: string;
+	cityState?: string;
+	city?: string;
+	state?: string;
+	schedule?: string;
+	customFlag1?: number;
+	bonus?: number;
+	remote?: number;
+	useClientJobUrl?: boolean;
+	dateCreated: Date;
+	dateLastEdited?: Date;
+	travelTime?: string;
+  }