louis-young

import javascript from "@eslint/js";
import { defineConfig } from "eslint/config";

import { FILE_EXTENSION_GLOB_PATTERNS } from "../constants/glob-patterns";
import { flattenFilesArrays } from "../utilities/flatten-files-arrays";

export const javascriptConfig = defineConfig({
  extends: [javascript.configs.recommended],
  files: flattenFilesArrays(
    FILE_EXTENSION_GLOB_PATTERNS.javascript,

louis-young

import { expect, test } from "vitest";
import { wordWrapString } from ".";

// characterLimitPerLine = -1 / 5.5

test.each([
  {
    stringToWordWrap: "Hello World",
    characterLimitPerLine: 20,
    expectedWordWrappedString: "Hello World",

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(