louis-young

import { type ChangeEvent, useState } from "react";

type SelectInputOption<TOptionValue> = {
  label: string;
  value: TOptionValue;
};

interface SelectInputProps<TOptionValue> {
  options: Array<SelectInputOption<TOptionValue>>;
  selectedValue: TOptionValue;

louis-young

module.exports = (results) => {
  const byRuleId = results.reduce((map, current) => {
    for (const { column, line, ruleId } of current.messages) {
      if (!map[ruleId]) {
        map[ruleId] = [];
      }

      const occurrence = `${current.filePath}:${line}:${column}`;
      map[ruleId].push(occurrence);
    }

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);

louis-young

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

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

const getSecondsFromMinutesAndSeconds = ({

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

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 { 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 } from "react";
import type { UseIntersectionObserverParameters } from "./types";

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

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 { forwardRef, useImperativeHandle, useRef } from "react";

export interface VideoProps {
  source: string;
}

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