348 lines
8.4 KiB
TypeScript
348 lines
8.4 KiB
TypeScript
import React, {
|
|
ReactNode,
|
|
ComponentType,
|
|
useState,
|
|
useRef,
|
|
useEffect,
|
|
} from "react";
|
|
import styles from "./OrganizedContent.module.css";
|
|
|
|
export interface LinkProps {
|
|
className?: string;
|
|
id: string;
|
|
children: ReactNode;
|
|
}
|
|
|
|
type Link = ComponentType<LinkProps>;
|
|
|
|
interface Section {
|
|
id: string;
|
|
title: string;
|
|
Content: ComponentType;
|
|
}
|
|
|
|
const READ_ALL_TITLE = "Read All";
|
|
export const READ_ALL_ID = "read-all";
|
|
|
|
interface Props {
|
|
sections: Section[];
|
|
currentId: string;
|
|
pageTitle: string;
|
|
link: Link;
|
|
}
|
|
|
|
export function OrganizedContent(props: Props) {
|
|
const sections = createSections(props.sections);
|
|
const currentIndex = sections.findIndex(({ id }) => id === props.currentId);
|
|
const [open, setOpen] = useState(false);
|
|
|
|
if (currentIndex < 0) {
|
|
throw new Error(`Section with ID ${props.currentId} was not found`);
|
|
}
|
|
|
|
const section = sections[currentIndex];
|
|
const isReadAll = section.id === READ_ALL_ID;
|
|
|
|
useEffect(() => {
|
|
open
|
|
? (document.body.style.overflow = "hidden")
|
|
: (document.body.style.overflow = "visible");
|
|
}, [open]);
|
|
|
|
const ref = useRef<HTMLDivElement>(null);
|
|
const isVisible = useOnScreen(ref);
|
|
|
|
return (
|
|
<div className={styles.wrapper} ref={ref}>
|
|
<Nav sections={sections} currentIndex={currentIndex} link={props.link} />
|
|
<div className={styles.content}>
|
|
{isReadAll ? (
|
|
<section.Content />
|
|
) : (
|
|
<>
|
|
<div>
|
|
<h1>{section.title}</h1>
|
|
<section.Content />
|
|
</div>
|
|
<Footer
|
|
sections={sections}
|
|
currentIndex={currentIndex}
|
|
link={props.link}
|
|
/>
|
|
</>
|
|
)}
|
|
</div>
|
|
<MobileWrapper
|
|
open={open}
|
|
setOpen={setOpen}
|
|
sections={sections}
|
|
currentIndex={currentIndex}
|
|
link={props.link}
|
|
pageTitle={props.pageTitle}
|
|
componentIsVisible={isVisible}
|
|
/>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
interface NavProps {
|
|
sections: Section[];
|
|
currentIndex: number;
|
|
link: Link;
|
|
pageTitle?: string;
|
|
}
|
|
|
|
function Nav({ sections, currentIndex, link: Link, pageTitle }: NavProps) {
|
|
return (
|
|
<div className={styles.nav}>
|
|
{pageTitle && <h1 className={styles.mobileNavTitle}>{pageTitle}</h1>}
|
|
{sections.map((section, index) => {
|
|
const classNames = [styles.navItem];
|
|
|
|
if (index === currentIndex) {
|
|
classNames.push(styles.selected);
|
|
}
|
|
|
|
if (section.id === READ_ALL_ID) {
|
|
classNames.push(styles.readAll);
|
|
}
|
|
|
|
return (
|
|
<Link
|
|
className={classNames.join(" ")}
|
|
id={section.id}
|
|
key={section.id}
|
|
>
|
|
<span className={styles.marker} />
|
|
<div>{section.title}</div>
|
|
</Link>
|
|
);
|
|
})}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
interface FooterProps {
|
|
sections: Section[];
|
|
currentIndex: number;
|
|
link: Link;
|
|
}
|
|
|
|
function Footer({ sections, currentIndex, link: Link }: FooterProps) {
|
|
const prevSection =
|
|
currentIndex > 0 && sections[currentIndex - 1].id !== READ_ALL_ID
|
|
? sections[currentIndex - 1]
|
|
: undefined;
|
|
const nextSection =
|
|
currentIndex < sections.length - 1 &&
|
|
sections[currentIndex + 1].id !== READ_ALL_ID
|
|
? sections[currentIndex + 1]
|
|
: undefined;
|
|
|
|
return (
|
|
<div className={styles.footer}>
|
|
{prevSection && (
|
|
<Link className={styles.previous} id={prevSection.id}>
|
|
<Arrow direction="left" />
|
|
<div>
|
|
<div>Previous</div>
|
|
<div className={styles.arrowHeading}>{prevSection.title}</div>
|
|
</div>
|
|
</Link>
|
|
)}
|
|
{nextSection && (
|
|
<Link className={styles.next} id={nextSection.id}>
|
|
<div>
|
|
<div>Next</div>
|
|
<div className={styles.arrowHeading}>{nextSection.title}</div>
|
|
</div>
|
|
<Arrow direction="right" />
|
|
</Link>
|
|
)}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
interface MobileProps {
|
|
open: boolean;
|
|
setOpen: React.Dispatch<React.SetStateAction<boolean>>;
|
|
sections: Section[];
|
|
currentIndex: number;
|
|
link: Link;
|
|
pageTitle: string;
|
|
componentIsVisible: boolean;
|
|
}
|
|
|
|
function MobileWrapper(mobileProps: MobileProps) {
|
|
const wrapperRef = useRef<HTMLDivElement>(null);
|
|
useOutsideAlerter(wrapperRef, mobileProps.setOpen);
|
|
|
|
return (
|
|
<div ref={wrapperRef}>
|
|
<Burger {...mobileProps} />
|
|
<Menu {...mobileProps} />
|
|
</div>
|
|
);
|
|
}
|
|
|
|
interface BurgerProps {
|
|
open: boolean;
|
|
setOpen: React.Dispatch<React.SetStateAction<boolean>>;
|
|
componentIsVisible: boolean;
|
|
}
|
|
|
|
const Burger = ({ open, setOpen, componentIsVisible }: BurgerProps) => {
|
|
const [prevScrollPos, setPrevScrollPos] = useState(0);
|
|
const [burgerVisible, setBurgerVisible] = useState(true);
|
|
const debouncedPrevScrollPos = useDebounce<number>(prevScrollPos, 100);
|
|
|
|
useEffect(() => {
|
|
const handleScroll = () => {
|
|
// find current scroll position
|
|
const currentScrollPos = window.pageYOffset;
|
|
// set state based on location info (explained in more detail below)
|
|
setBurgerVisible(
|
|
componentIsVisible &&
|
|
((debouncedPrevScrollPos > currentScrollPos &&
|
|
debouncedPrevScrollPos - currentScrollPos > 70) ||
|
|
currentScrollPos < 10)
|
|
);
|
|
|
|
// set state to new scroll position
|
|
setPrevScrollPos(currentScrollPos);
|
|
};
|
|
window.addEventListener("scroll", handleScroll);
|
|
|
|
return () => window.removeEventListener("scroll", handleScroll);
|
|
}, [componentIsVisible, debouncedPrevScrollPos, burgerVisible]);
|
|
|
|
return (
|
|
<div
|
|
className={
|
|
styles.burger + " " + (burgerVisible ? "" : styles.hiddenBurger)
|
|
}
|
|
onClick={() => setOpen(!open)}
|
|
>
|
|
<div>
|
|
<div />
|
|
<div />
|
|
<div />
|
|
</div>
|
|
</div>
|
|
);
|
|
};
|
|
|
|
interface MenuProps {
|
|
open: boolean;
|
|
sections: Section[];
|
|
currentIndex: number;
|
|
link: Link;
|
|
pageTitle: string;
|
|
}
|
|
|
|
const Menu = ({ open, sections, currentIndex, link, pageTitle }: MenuProps) => {
|
|
const mobileNav = open
|
|
? styles.mobileNav
|
|
: styles.mobileNav + " " + styles.mobileNavClosed;
|
|
return (
|
|
<div className={mobileNav}>
|
|
<Nav
|
|
sections={sections}
|
|
currentIndex={currentIndex}
|
|
link={link}
|
|
pageTitle={pageTitle}
|
|
/>
|
|
</div>
|
|
);
|
|
};
|
|
|
|
function useOutsideAlerter(
|
|
ref: React.RefObject<HTMLDivElement>,
|
|
setOpen: React.Dispatch<React.SetStateAction<boolean>>
|
|
) {
|
|
useEffect(() => {
|
|
const handleClickOutside = (event: Event) => {
|
|
if (ref.current && !ref.current.contains(event.target as Node)) {
|
|
setOpen(false);
|
|
}
|
|
};
|
|
|
|
document.addEventListener("mousedown", handleClickOutside);
|
|
return () => {
|
|
document.removeEventListener("mousedown", handleClickOutside);
|
|
};
|
|
}, [ref, setOpen]);
|
|
}
|
|
|
|
function useDebounce<T>(value: T, delay?: number): T {
|
|
const [debouncedValue, setDebouncedValue] = useState<T>(value);
|
|
|
|
useEffect(() => {
|
|
const timer = setTimeout(() => setDebouncedValue(value), delay || 500);
|
|
|
|
return () => {
|
|
clearTimeout(timer);
|
|
};
|
|
}, [value, delay]);
|
|
|
|
return debouncedValue;
|
|
}
|
|
|
|
function createSections(sections: Section[]) {
|
|
return [
|
|
{
|
|
id: READ_ALL_ID,
|
|
title: READ_ALL_TITLE,
|
|
Content() {
|
|
return (
|
|
<>
|
|
{sections.map(({ id, title, Content: SectionContent }) => (
|
|
<div key={id}>
|
|
<h1>{title}</h1>
|
|
<SectionContent />
|
|
</div>
|
|
))}
|
|
</>
|
|
);
|
|
},
|
|
},
|
|
...sections,
|
|
];
|
|
}
|
|
|
|
function Arrow({ direction }: { direction: "left" | "right" }) {
|
|
return (
|
|
<svg
|
|
xmlns="http://www.w3.org/2000/svg"
|
|
width="14"
|
|
height="9"
|
|
viewBox="0 0 14 9"
|
|
className={`${styles.arrow} ${
|
|
direction === "left" ? styles.prevArrow : styles.nextArrow
|
|
}`}
|
|
>
|
|
<path d="M6.24407 8.12713C6.64284 8.58759 7.35716 8.58759 7.75593 8.12713L13.3613 1.65465C13.9221 1.00701 13.4621 0 12.6053 0H1.39467C0.537918 0 0.0778675 1.00701 0.638743 1.65465L6.24407 8.12713Z" />
|
|
</svg>
|
|
);
|
|
}
|
|
|
|
function useOnScreen(ref: React.RefObject<HTMLDivElement>) {
|
|
const [isIntersecting, setIntersecting] = useState(false);
|
|
|
|
useEffect(() => {
|
|
const observer = new IntersectionObserver(([entry]) =>
|
|
setIntersecting(entry.isIntersecting)
|
|
);
|
|
|
|
if (ref.current) {
|
|
observer.observe(ref.current);
|
|
}
|
|
// Remove the observer as soon as the component is unmounted
|
|
return () => {
|
|
observer.disconnect();
|
|
};
|
|
}, [ref]);
|
|
|
|
return isIntersecting;
|
|
}
|