AbiirSkincare/Hydrogen/web/app/components/SearchResultsPredictive.tsx

305 lines
8.0 KiB
TypeScript

import {Link, useFetcher, type Fetcher} from 'react-router';
import {Image, Money} from '@shopify/hydrogen';
import React, {useRef, useEffect} from 'react';
import {
getEmptyPredictiveSearchResult,
urlWithTrackingParams,
type PredictiveSearchReturn,
} from '~/lib/search';
import {useAside} from './Aside';
type PredictiveSearchItems = PredictiveSearchReturn['result']['items'];
type UsePredictiveSearchReturn = {
term: React.MutableRefObject<string>;
total: number;
inputRef: React.MutableRefObject<HTMLInputElement | null>;
items: PredictiveSearchItems;
fetcher: Fetcher<PredictiveSearchReturn>;
};
type SearchResultsPredictiveArgs = Pick<
UsePredictiveSearchReturn,
'term' | 'total' | 'inputRef' | 'items'
> & {
state: Fetcher['state'];
closeSearch: () => void;
};
type PartialPredictiveSearchResult<
ItemType extends keyof PredictiveSearchItems,
ExtraProps extends keyof SearchResultsPredictiveArgs = 'term' | 'closeSearch',
> = Pick<PredictiveSearchItems, ItemType> &
Pick<SearchResultsPredictiveArgs, ExtraProps>;
type SearchResultsPredictiveProps = {
children: (args: SearchResultsPredictiveArgs) => React.ReactNode;
};
/**
* Component that renders predictive search results
*/
export function SearchResultsPredictive({
children,
}: SearchResultsPredictiveProps) {
const aside = useAside();
const {term, inputRef, fetcher, total, items} = usePredictiveSearch();
/*
* Utility that resets the search input
*/
function resetInput() {
if (inputRef.current) {
inputRef.current.blur();
inputRef.current.value = '';
}
}
/**
* Utility that resets the search input and closes the search aside
*/
function closeSearch() {
resetInput();
aside.close();
}
return children({
items,
closeSearch,
inputRef,
state: fetcher.state,
term,
total,
});
}
SearchResultsPredictive.Articles = SearchResultsPredictiveArticles;
SearchResultsPredictive.Collections = SearchResultsPredictiveCollections;
SearchResultsPredictive.Pages = SearchResultsPredictivePages;
SearchResultsPredictive.Products = SearchResultsPredictiveProducts;
SearchResultsPredictive.Queries = SearchResultsPredictiveQueries;
SearchResultsPredictive.Empty = SearchResultsPredictiveEmpty;
function SearchResultsPredictiveArticles({
term,
articles,
closeSearch,
}: PartialPredictiveSearchResult<'articles'>) {
if (!articles.length) return null;
return (
<div className="predictive-search-result" key="articles">
<h5>Articles</h5>
<ul>
{articles.map((article) => {
const articleUrl = urlWithTrackingParams({
baseUrl: `/blogs/${article.blog.handle}/${article.handle}`,
trackingParams: article.trackingParameters,
term: term.current ?? '',
});
return (
<li className="predictive-search-result-item" key={article.id}>
<Link onClick={closeSearch} to={articleUrl}>
{article.image?.url && (
<Image
alt={article.image.altText ?? ''}
src={article.image.url}
width={50}
height={50}
/>
)}
<div>
<span>{article.title}</span>
</div>
</Link>
</li>
);
})}
</ul>
</div>
);
}
function SearchResultsPredictiveCollections({
term,
collections,
closeSearch,
}: PartialPredictiveSearchResult<'collections'>) {
if (!collections.length) return null;
return (
<div className="predictive-search-result" key="collections">
<h5>Collections</h5>
<ul>
{collections.map((collection) => {
const collectionUrl = urlWithTrackingParams({
baseUrl: `/collections/${collection.handle}`,
trackingParams: collection.trackingParameters,
term: term.current,
});
return (
<li className="predictive-search-result-item" key={collection.id}>
<Link onClick={closeSearch} to={collectionUrl}>
{collection.image?.url && (
<Image
alt={collection.image.altText ?? ''}
src={collection.image.url}
width={50}
height={50}
/>
)}
<div>
<span>{collection.title}</span>
</div>
</Link>
</li>
);
})}
</ul>
</div>
);
}
function SearchResultsPredictivePages({
term,
pages,
closeSearch,
}: PartialPredictiveSearchResult<'pages'>) {
if (!pages.length) return null;
return (
<div className="predictive-search-result" key="pages">
<h5>Pages</h5>
<ul>
{pages.map((page) => {
const pageUrl = urlWithTrackingParams({
baseUrl: `/pages/${page.handle}`,
trackingParams: page.trackingParameters,
term: term.current,
});
return (
<li className="predictive-search-result-item" key={page.id}>
<Link onClick={closeSearch} to={pageUrl}>
<div>
<span>{page.title}</span>
</div>
</Link>
</li>
);
})}
</ul>
</div>
);
}
function SearchResultsPredictiveProducts({
term,
products,
closeSearch,
}: PartialPredictiveSearchResult<'products'>) {
if (!products.length) return null;
return (
<div className="predictive-search-result" key="products">
<h5>Products</h5>
<ul>
{products.map((product) => {
const productUrl = urlWithTrackingParams({
baseUrl: `/products/${product.handle}`,
trackingParams: product.trackingParameters,
term: term.current,
});
const price = product?.selectedOrFirstAvailableVariant?.price;
const image = product?.selectedOrFirstAvailableVariant?.image;
return (
<li className="predictive-search-result-item" key={product.id}>
<Link to={productUrl} onClick={closeSearch}>
{image && (
<Image
alt={image.altText ?? ''}
src={image.url}
width={50}
height={50}
/>
)}
<div>
<p>{product.title}</p>
<small>{price && <Money data={price} />}</small>
</div>
</Link>
</li>
);
})}
</ul>
</div>
);
}
function SearchResultsPredictiveQueries({
queries,
queriesDatalistId,
}: PartialPredictiveSearchResult<'queries', never> & {
queriesDatalistId: string;
}) {
if (!queries.length) return null;
return (
<datalist id={queriesDatalistId}>
{queries.map((suggestion) => {
if (!suggestion) return null;
return <option key={suggestion.text} value={suggestion.text} />;
})}
</datalist>
);
}
function SearchResultsPredictiveEmpty({
term,
}: {
term: React.MutableRefObject<string>;
}) {
if (!term.current) {
return null;
}
return (
<p>
No results found for <q>{term.current}</q>
</p>
);
}
/**
* Hook that returns the predictive search results and fetcher and input ref.
* @example
* '''ts
* const { items, total, inputRef, term, fetcher } = usePredictiveSearch();
* '''
**/
function usePredictiveSearch(): UsePredictiveSearchReturn {
const fetcher = useFetcher<PredictiveSearchReturn>({key: 'search'});
const term = useRef<string>('');
const inputRef = useRef<HTMLInputElement | null>(null);
if (fetcher?.state === 'loading') {
term.current = String(fetcher.formData?.get('q') || '');
}
// capture the search input element as a ref
useEffect(() => {
if (!inputRef.current) {
inputRef.current = document.querySelector('input[type="search"]');
}
}, []);
const {items, total} =
fetcher?.data?.result ?? getEmptyPredictiveSearchResult();
return {items, total, inputRef, term, fetcher};
}