louis-young

import type { ReactNode } from "react";

export type ObjectWithIdentifier = {
  id: number;
};

export type ListProps<TItem> = {
  items: TItem[];
  render: (item: TItem) => ReactNode;
};

louis-young

export function invariant(condition: unknown, message: string): asserts condition {
  if (!condition) {
    throw new Error(message);
  }
}

louis-young

import { forwardRef, useImperativeHandle, useRef } from "react";

export interface VideoProps {
  source: string;
}

export interface VideoRef {
  play: () => void;
  pause: () => void;
}

louis-young

import { type Context, useContext } from "react";
import { invariant } from "../invariant";

export const createSafeContextHook = <TContextValue>(
  context: Context<TContextValue>,
  displayName: string
) => {
  return () => {
    const contextValue = useContext(context);

louis-young

import { useEffect } from "react";
import type { UseIntersectionObserverParameters } from "./types";

export const useIntersectionObserver = ({
  observableRef,
  callback,
  options,
}: UseIntersectionObserverParameters) => {
  useEffect(() => {
    const intersectionObserver = new IntersectionObserver(

louis-young

import { useRef } from "react";
import { useIntersectionObserver } from "../../hooks/useIntersectionObserver";
import type { InfiniteScrollProps } from "./types";

export const InfiniteScroll = ({
  loadMoreFunction,
  isLoadingMore,
  loadingMoreMessage,
  hasLoadedEverything,
  loadedEverythingMessage,

louis-young

import { useEffect, useState } from "react";

export const useDebouncedValue = <TValue>(value: TValue, delay: number) => {
  const [debouncedValue, setDebouncedValue] = useState(value);

  useEffect(() => {
    const timeout = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

louis-young

import type { ReactNode } from "react";

interface AsynchronousComponentProps<TData> {
  children: (data: NonNullable<TData>) => ReactNode;
  data: TData;
  isLoading: boolean;
  loadingFallback: ReactNode;
  hasError: boolean;
  errorFallback: ReactNode;
}

louis-young

/**
 * https://markheath.net/post/lunchtime-linq-challenge
 */

interface GetSecondsFromMinutesAndSecondsParameters {
  minutes: number;
  seconds: number;
}

const getSecondsFromMinutesAndSeconds = ({

louis-young

const singleOrDefault = <TElement, TDefaultValue>(
  array: ReadonlyArray<TElement>,
  predicate: (element: TElement) => boolean,
  defaultValue: TDefaultValue
): TElement | TDefaultValue => {
  if (array.length === 0) {
    throw new Error("The source sequence is empty.");
  }

  const element = array.find(predicate);