gReact Hooks

React hooks that answer questions nobody sensible has asked.

gReact Hooks is a React 19-compatible collection of technically functional abstractions with wildly inconsistent reasons to exist.

Highlights

• Zero-footprint bundle: tree-shakeable ESM/CJS builds with type definitions out of the box.
• Hooks ranging from the occasionally defensible useInterval to useZeroZero, which returns the number JavaScript already had.
• No promise that installing this package will improve a project.

Installation

# npm
npm install greact-hooks

# pnpm
pnpm add greact-hooks

# yarn
yarn add greact-hooks

Quick Start

import { useSameSame, useZeroZero } from "greact-hooks";

function UnnecessaryArithmetic() {
  const zero = useZeroZero();
  const sameZero = useSameSame(zero);

  return <output>{sameZero}</output>;
}

API Reference

useInterval(callback: () => void, delay: number | null)

• Runs callback on a stable cadence and cleans up automatically when the component unmounts or delay changes.
• Pass null to pause the interval without removing the hook.

useInterval(() => setTick((n) => n + 1), 1000);

useDramaticPause(delay?: number): boolean

Declares a dramatic pause whenever the pointer has stayed still for long enough. It cannot tell whether anyone is actually thinking; it simply promotes every quiet cursor to a suspenseful plot point.

function useDramaticPause(delay?: number): boolean;

import { useDramaticPause } from "greact-hooks";

function IndecisiveButton() {
  const isDramatic = useDramaticPause(1_500);

  return <button>{isDramatic ? "..." : "Make a decision"}</button>;
}

• Parameter: delay is the number of milliseconds without a pointermove event before the pause becomes dramatic. It defaults to 1000; negative and non-finite values become 0 for an immediate overreaction.
• Returns: true while the current pointer silence has reached that delay, otherwise false.
• APIs and permissions: uses window pointermove events and a timer. It needs no permission and reads no pointer coordinates.
• Effects and compatibility: while mounted, it installs one global pointer listener and timer, both removed on cleanup. It returns false during SSR or when the required event-listener APIs are unavailable. Pointer Events are supported by current evergreen browsers.

Use it when a hesitant cursor deserves an unnecessary orchestral swell instead of sensible product design.

useTabJealousy(options?: UseTabJealousyOptions): string | null

Lets a browser tab issue a calm, entirely unjustified reproach after the visitor comes back from another tab.

interface UseTabJealousyOptions {
  messages?: readonly string[];
  document?: Document | null;
}

function useTabJealousy(options?: UseTabJealousyOptions): string | null;

import { useTabJealousy } from "greact-hooks";

function GuiltyDashboard() {
  const gossip = useTabJealousy({
    messages: ["Oh, you are back.", "The DOM says it is not upset."],
  });

  return <p>{gossip ?? "This tab is pretending to be fine."}</p>;
}

• Parameters: messages is the ordered, looping list of reproaches; an empty list keeps the hook quiet. document optionally supplies the document to monitor (for example, one from an iframe); it defaults to the current document, and null disables monitoring.
• Returns: the next message only after that document goes from hidden to visible, otherwise null.
• APIs and permissions: uses the Document Visibility API (visibilitychange and visibilityState). It needs no permission, network access, or knowledge of where the visitor went.
• Effects and compatibility: it attaches one document listener while mounted and removes it on cleanup or when the monitored document changes. It returns null without a usable document or listener APIs. It works in browsers that support the Document Visibility API and is inert during SSR.

Use it when your interface needs to guilt-trip a multitasker instead of respecting their healthy tab-switching habits.

useKeyMashExcuse(options?: UseKeyMashExcuseOptions): string | null

Turns a hurried burst of typing into a calm, professionally unserious excuse. Your keyboard may be frantic, but this hook keeps the alibi polished.

interface UseKeyMashExcuseOptions {
  threshold?: number;
  pause?: number;
  messages?: readonly string[];
  document?: Document | null;
}

function useKeyMashExcuse(options?: UseKeyMashExcuseOptions): string | null;

import { useKeyMashExcuse } from "greact-hooks";

function TypingIncidentReport() {
  const excuse = useKeyMashExcuse({
    threshold: 4,
    messages: ["That was an experimental keyboard solo."],
  });

  return <p>{excuse ?? "Everything is under control."}</p>;
}

• Parameters: threshold is the number of printable, non-repeating key presses required to trigger an excuse; it defaults to 4, and finite values are rounded down with a minimum of 1. pause is the milliseconds of keyboard silence that forget an unfinished mash; it defaults to 500, while negative and non-finite values become 0 and 500 respectively. messages is the ordered, looping list of excuses; an empty list keeps the hook quiet. document optionally supplies the document to monitor and defaults to the current document; null disables monitoring.
• Returns: the next configured excuse after a qualifying key mash, otherwise null.
• APIs and permissions: uses keydown events and a timer. It needs no permission, network access, or knowledge of what the frantic typing actually meant.
• Effects and compatibility: while mounted, it installs one document keyboard listener and may hold one reset timer; both are removed on cleanup or when its document, threshold, or pause changes. It is inert during SSR or when the required document listener APIs are unavailable. It works in browsers with standard keyboard events.

Use it when “asdfjkl;” deserves a formal incident report instead of a backspace key.

useDoomScrollOracle(options?: UseDoomScrollOracleOptions): string | null

Treats each stretch of scrolling as hard evidence that the page can predict a visitor's future. It cannot; it only counts scroll milestones and becomes increasingly confident anyway.

interface UseDoomScrollOracleOptions {
  distance?: number;
  messages?: readonly string[];
  window?: Window | null;
}

function useDoomScrollOracle(
  options?: UseDoomScrollOracleOptions,
): string | null;

import { useDoomScrollOracle } from "greact-hooks";

function EndlessArticle() {
  const prophecy = useDoomScrollOracle({
    distance: 800,
    messages: ["You will discover another paragraph."],
  });

  return <aside>{prophecy ?? "Your fate is currently above the fold."}</aside>;
}

• Parameters: distance is the positive number of pixels between scroll milestones; it defaults to 1000, and non-finite values use that default while finite values are rounded down with a minimum of 1. messages is the ordered, looping list of prophecies; an empty list keeps the hook quiet. window optionally supplies the window to monitor (for example, an iframe's); it defaults to the current window, and null disables monitoring.
• Returns: the next configured prophecy after scrolling past a new milestone, otherwise null.
• APIs and permissions: uses window scroll events and scrollY. It needs no permission, network access, or actual knowledge of the future.
• Effects and compatibility: it installs one global scroll listener while mounted and removes it on cleanup or when its window or distance changes. A page opened past a milestone starts quietly, and one scroll event produces at most one prophecy even if a programmatic jump crosses several milestones. It is inert during SSR or when the required window listener APIs are unavailable. It works in browsers with standard scrolling events.

Use it when a long page needs a dubious oracle instead of a progress indicator.

useFocusFanfare(options?: UseFocusFanfareOptions): string | null

Treats every focus change like the entrance of a minor royal. It does not play music, notify anyone, or improve accessibility; it merely gives the focus ring far more narrative importance than it deserves.

interface UseFocusFanfareOptions {
  messages?: readonly string[];
  document?: Document | null;
}

function useFocusFanfare(options?: UseFocusFanfareOptions): string | null;

import { useFocusFanfare } from "greact-hooks";

function VeryImportantForm() {
  const fanfare = useFocusFanfare({
    messages: ["The email field has graced us with its presence."],
  });

  return (
    <>
      <input aria-label="Email" type="email" />
      <p>{fanfare ?? "Awaiting a suitably important entrance."}</p>
    </>
  );
}

• Parameters: messages is the ordered, looping list of announcements; an empty list silences the hook. document optionally supplies the document to observe (for example, one from an iframe); it defaults to the current document, and null disables observation.
• Returns: the next configured announcement after a focusin event, otherwise null.
• APIs and permissions: uses the DOM focusin event. It needs no permission, does not read the focused element, and does not make any sound despite its name.
• Effects and compatibility: it installs one document listener while mounted and removes it on cleanup or when the monitored document changes. It is inert during SSR or when the required listener APIs are unavailable. It works in browsers with standard bubbling focus events.

Use it when a form control needs a red-carpet entrance instead of ordinary, respectful focus management.

useClipboardSuspicion(options?: UseClipboardSuspicionOptions): string | null

Treats every copy operation like the opening scene of a low-budget investigation. It never examines the copied text; apparently the existence of a duplicate is evidence enough.

interface UseClipboardSuspicionOptions {
  messages?: readonly string[];
  document?: Document | null;
}

function useClipboardSuspicion(
  options?: UseClipboardSuspicionOptions,
): string | null;

import { useClipboardSuspicion } from "greact-hooks";

function EvidenceBoard() {
  const suspicion = useClipboardSuspicion({
    messages: ["A suspicious duplicate is now at large."],
  });

  return <p>{suspicion ?? "The clipboard currently has an alibi."}</p>;
}

• Parameters: messages is the ordered, looping list of accusations; an empty list clears and silences the hook. document optionally supplies the document to monitor (for example, one from an iframe); it defaults to the current document, and null disables monitoring.
• Returns: the next configured accusation after a copy event, otherwise null.
• APIs and permissions: uses the DOM copy event. It requests no clipboard permission and deliberately does not read, alter, or retain copied content.
• Effects and compatibility: it installs one document listener while mounted and removes it on cleanup or when the monitored document changes. It is inert during SSR or without usable event-listener APIs. Browsers with standard Clipboard Events are supported. Displaying its accusations may annoy users, so do not present them as real security warnings.

Use it when ordinary copy-and-paste needs theatrical suspicion instead of a useful confirmation toast.

useBackButtonRegret(options?: UseBackButtonRegretOptions): string | null

Turns every browser history traversal into melodrama about revisiting old decisions. Despite the name, browsers do not reveal whether a popstate came from Back, Forward, or another history traversal, so the hook judges them all equally.

interface UseBackButtonRegretOptions {
  messages?: readonly string[];
  window?: Window | null;
}

function useBackButtonRegret(
  options?: UseBackButtonRegretOptions,
): string | null;

import { useBackButtonRegret } from "greact-hooks";

function NavigationTherapist() {
  const regret = useBackButtonRegret({
    messages: ["History repeats itself, but with more clicking."],
  });

  return <p>{regret ?? "No navigation decisions have been questioned yet."}</p>;
}

• Parameters: messages is the ordered, looping list of regrets; an empty list clears and silences the hook. window optionally supplies the window to monitor (for example, one from an iframe); it defaults to the current window, and null disables monitoring.
• Returns: the next configured regret after a popstate event, otherwise null.
• APIs and permissions: uses the browser History API's popstate event. It needs no permission and neither reads nor changes history entries.
• Effects and compatibility: it installs one window listener while mounted and removes it on cleanup or when the monitored window changes. It is inert during SSR or without usable event-listener APIs. Browsers with the standard History API are supported. It cannot distinguish Back from Forward, and displaying its regrets may make ordinary navigation unnecessarily judgmental.

Use it when a router needs an unqualified therapist instead of another loading indicator.

useZeroZero(): number

Retourne 0, mais le fait mémoriser par React pour être absolument certain.

function useZeroZero(): number;

import { useZeroZero } from "greact-hooks";

const zero = useZeroZero();

• Paramètres : aucun.
• Retour : le nombre 0, à chaque rendu.
• Alternative raisonnable : écrire directement 0.

Ce hook n'aurait jamais dû exister, car JavaScript savait déjà compter jusque-là.

useSameSame<T>(value: T): T

Retourne exactement la valeur fournie, mais après lui avoir fait visiter useMemo.

function useSameSame<T>(value: T): T;

import { useSameSame } from "greact-hooks";

const sameName = useSameSame("Greg");

• Paramètre : value, la valeur qui n'avait rien demandé.
• Retour : cette même valeur, avec la même référence.
• Alternative raisonnable : utiliser directement value.

Ce hook n'aurait jamais dû exister, car passer une valeur à travers React ne la rend pas plus identique.

useStateWithoutSetter<T>(initialValue: T): T

Crée un état React, puis jette le seul moyen prévu pour le modifier.

function useStateWithoutSetter<T>(initialValue: T): T;

import { useStateWithoutSetter } from "greact-hooks";

const permanentlyInitial = useStateWithoutSetter("still initial");

• Paramètre : initialValue, la valeur condamnée à rester initiale.
• Retour : l'état initial, sans setter et donc sans avenir.
• Alternative raisonnable : utiliser directement initialValue, ou useState si l'état doit réellement changer.

Ce hook n'aurait jamais dû exister, car retirer le setter de useState ne constitue pas une amélioration.

useRefRef<T>(initialValue: T): RefObject<RefObject<T>>

Range une ref React dans une autre ref React, au cas où une seule couche d'indirection semblerait trop directe.

function useRefRef<T>(initialValue: T): RefObject<RefObject<T>>;

import { useRefRef } from "greact-hooks";

const refRef = useRefRef("deeply unnecessary");
const value = refRef.current.current;

• Paramètre : initialValue, la valeur qui sera immobilisée deux niveaux plus loin.
• Retour : une ref stable dont current est une autre ref stable contenant la valeur initiale.
• Alternative raisonnable : utiliser directement useRef(initialValue).

Ce hook n'aurait jamais dû exister, car une ref n'a pas besoin d'une ref pour la surveiller.

useEffectWithoutEffect(): void

Planifie un effet React dont l'effet consiste à n'avoir aucun effet.

function useEffectWithoutEffect(): void;

import { useEffectWithoutEffect } from "greact-hooks";

useEffectWithoutEffect();

• Paramètres : aucun.
• Retour : rien.
• Alternative raisonnable : ne rien faire du tout.

Ce hook n'aurait jamais dû exister, car React n'a pas besoin d'être prévenu quand rien ne doit arriver.

useCallbackCallback<Args extends unknown[], Return>(callback: (...args: Args) => Return): (...args: Args) => Return

Mémorise une fonction, puis mémorise une autre fonction uniquement chargée d'appeler la première.

function useCallbackCallback<Args extends unknown[], Return>(
  callback: (...args: Args) => Return,
): (...args: Args) => Return;

import { useCallbackCallback } from "greact-hooks";

const greetAgain = useCallbackCallback((name: string) => `Hello ${name}`);

• Paramètre : callback, la fonction qui va subir deux couches d'attention.
• Retour : une fonction mémorisée qui appelle la fonction mémorisée.
• Alternative raisonnable : utiliser directement useCallback(callback, [callback]).

Ce hook n'aurait jamais dû exister, car un callback n'a pas besoin d'un callback pour le rappeler.

useTrueTrue(): boolean

Retourne true, mais seulement après avoir demandé confirmation à React.

function useTrueTrue(): boolean;

import { useTrueTrue } from "greact-hooks";

const stillTrue = useTrueTrue();

• Paramètres : aucun.
• Retour : true, obstinément.
• Alternative raisonnable : écrire directement true.

Ce hook n'aurait jamais dû exister, car le booléen était déjà vrai avant d'entrer dans React.

useTransitionWithoutTransition(): boolean

Prépare une transition React, puis jette la fonction indispensable pour la démarrer.

function useTransitionWithoutTransition(): boolean;

import { useTransitionWithoutTransition } from "greact-hooks";

const isNothingPending = useTransitionWithoutTransition();

• Paramètres : aucun.
• Retour : false, puisqu'aucune transition ne peut être lancée.
• Alternative raisonnable : écrire directement false.

Ce hook n'aurait jamais dû exister, car une transition sans moyen de démarrer est seulement une attente qui n'arrivera pas.

useEitherWay<T>(value: T): (either: boolean) => T

Retourne une fonction qui exige un choix booléen, puis renvoie la même valeur dans les deux cas.

function useEitherWay<T>(value: T): (either: boolean) => T;

import { useEitherWay } from "greact-hooks";

const chooseAnswer = useEitherWay("same answer");
const answer = chooseAnswer(false);

• Paramètre : value, la valeur déjà décidée avant le faux choix.
• Retour : une fonction qui retourne value, que son argument soit true ou false.
• Alternative raisonnable : utiliser directement value.

Ce hook n'aurait jamais dû exister, car demander un choix entre deux réponses identiques ne choisit rien.

useSelfCount<T>(value: T): readonly [T, number]

Place une valeur dans une collection où elle est seule, puis compte combien de valeurs cette collection contient.

function useSelfCount<T>(value: T): readonly [T, number];

import { useSelfCount } from "greact-hooks";

const [answer, occurrences] = useSelfCount("alone");

• Paramètre : value, la valeur placée toute seule pour faciliter exagérément le comptage.
• Retour : la valeur et le nombre 1, puisque la collection ne contient rien d'autre.
• Alternative raisonnable : écrire directement [value, 1].

Ce hook n'aurait jamais dû exister, car compter l'unique élément d'une collection créée exprès ne produit aucune information.

useWasteCall(): <T>(callback: () => T) => T

Retourne une fonction qui appelle un callback deux fois, puis gaspille entièrement le résultat du second appel.

function useWasteCall(): <T>(callback: () => T) => T;

import { useWasteCall } from "greact-hooks";

const wasteCall = useWasteCall();
const firstResult = wasteCall(() => calculate());

• Paramètres : aucun.
• Retour : une fonction stable qui appelle callback deux fois et retourne uniquement le premier résultat.
• Alternative raisonnable : appeler directement le callback une seule fois.

Ce hook n'aurait jamais dû exister, car refaire un travail uniquement pour jeter son résultat est strictement moins bien.

useSetterWithoutState<T>(initialValue: T): Dispatch<SetStateAction<T>>

Crée un état React, jette sa valeur et ne conserve que le moyen de modifier cette valeur désormais invisible.

function useSetterWithoutState<T>(
  initialValue: T,
): Dispatch<SetStateAction<T>>;

import { useSetterWithoutState } from "greact-hooks";

const setInvisibleState = useSetterWithoutState("hidden");
setInvisibleState("still hidden");

• Paramètre : initialValue, la première valeur que personne ne pourra lire.
• Retour : le setter stable d'un état volontairement inaccessible.
• Alternative raisonnable : utiliser directement useState et garder la valeur, ou ne rien faire.

Ce hook n'aurait jamais dû exister, car modifier un état impossible à consulter est une activité sans résultat.

useNoChangeReducer<T>(initialValue: T): readonly [T, DispatchWithoutAction]

Crée un reducer dont le dispatch demande un changement, puis reprend exactement le même état.

function useNoChangeReducer<T>(
  initialValue: T,
): readonly [T, DispatchWithoutAction];

import { useNoChangeReducer } from "greact-hooks";

const [value, refuseChange] = useNoChangeReducer("unchanged");
refuseChange();

• Paramètre : initialValue, la valeur que le reducer refusera ensuite de modifier.
• Retour : la valeur initiale et un dispatch stable qui ne change rien.
• Alternative raisonnable : utiliser directement initialValue et ne proposer aucune action.

Ce hook n'aurait jamais dû exister, car une commande incapable de produire le moindre changement est seulement une façon compliquée de ne rien faire.

useRefThenWrap<T>(value: T): { value: T }

Demande à une ref de mémoriser la valeur, ignore cette mémoire, puis enveloppe la valeur courante dans un nouvel objet.

function useRefThenWrap<T>(value: T): { value: T };

import { useRefThenWrap } from "greact-hooks";

const wrapped = useRefThenWrap("already available");

• Paramètre : value, la valeur inutilement confiée à une ref avant d'être utilisée directement.
• Retour : un nouvel objet { value } à chaque rendu.
• Alternative raisonnable : écrire directement { value }.

Ce hook n'aurait jamais dû exister, car oublier une ref avant de fabriquer un objet ordinaire ne constitue pas une abstraction.

useIdLength(): number

Demande un identifiant à React, le jette, puis retourne uniquement son nombre de caractères.

function useIdLength(): number;

import { useIdLength } from "greact-hooks";

const discardedIdLength = useIdLength();

• Paramètres : aucun.
• Retour : la longueur de l'identifiant React qui vient d'être rendu inaccessible.
• Alternative raisonnable : écrire directement useId().length si cette information inutile est vraiment nécessaire.

Ce hook n'aurait jamais dû exister, car compter un identifiant tout en refusant de le fournir est une abstraction sans objet.

useSplitAndRejoin(value: string): readonly [readonly string[], string]

Découpe une chaîne en caractères, puis les rejoint pour récupérer la chaîne déjà fournie.

function useSplitAndRejoin(
  value: string,
): readonly [readonly string[], string];

import { useSplitAndRejoin } from "greact-hooks";

const [characters, pointlesslyRestored] = useSplitAndRejoin("hook");

• Paramètre : value, la chaîne que React doit superviser pendant qu'elle devient brièvement des caractères.
• Retour : ces caractères et la même chaîne reconstruite à partir d'eux.
• Alternative raisonnable : utiliser directement value et [...value].

Ce hook n'aurait jamais dû exister, car découper une chaîne n'est pas un cycle de vie.

useTypeTwice<T>(value: T): () => readonly [string, string]

Retourne un callback qui copie une valeur, vérifie que la copie est l'original, puis annonce deux fois son type déjà évident.

function useTypeTwice<T>(
  value: T,
): () => readonly [string, string];

import { useTypeTwice } from "greact-hooks";

const reportTypeTwice = useTypeTwice("hook");
const redundantTypes = reportTypeTwice();

• Paramètre : value, la valeur dont le type doit attendre un callback React.
• Retour : une fonction qui retourne deux fois le résultat de typeof value.
• Alternative raisonnable : écrire directement typeof value.

Ce hook n'aurait jamais dû exister, car le type d'une valeur n'a besoin ni d'un rendez-vous ni d'un doublon.

usePlusOneProof(value: number): readonly [number, 1]

Ajoute 1 à un nombre, puis retourne aussi le 1 comme preuve inutile de l'opération.

function usePlusOneProof(value: number): readonly [number, 1];

import { usePlusOneProof } from "greact-hooks";

const [incremented, unnecessaryProof] = usePlusOneProof(4);

• Paramètre : value, le nombre qui pouvait être incrémenté sans supervision de React.
• Retour : value + 1 et le littéral 1 qui révèle exactement comment revenir en arrière.
• Alternative raisonnable : écrire directement value + 1.

Ce hook n'aurait jamais dû exister, car une addition n'a pas besoin de fournir sa propre pièce justificative.

useFirstBackwards<T>(values: readonly T[]): T | undefined

Copie un tableau, l'inverse, puis prend son dernier élément pour retrouver le premier élément original.

function useFirstBackwards<T>(values: readonly T[]): T | undefined;

import { useFirstBackwards } from "greact-hooks";

const firstAfterDetour = useFirstBackwards(["first", "second", "third"]);

• Paramètre : values, le tableau qui doit faire demi-tour avant de livrer son premier élément.
• Retour : le premier élément de values, ou undefined si le tableau est vide.
• Alternative raisonnable : écrire directement values[0].

Ce hook n'aurait jamais dû exister, car le début d'un tableau n'est pas plus accessible depuis sa copie inversée.

useAfterLast<T>(values: readonly T[]): readonly [number, T | undefined]

Compte un tableau, puis lit l'élément situé juste après sa fin pour confirmer l'absence déjà garantie.

function useAfterLast<T>(
  values: readonly T[],
): readonly [number, T | undefined];

import { useAfterLast } from "greact-hooks";

const [count, predictablyMissing] = useAfterLast(["first", "second"]);

• Paramètre : values, le tableau dont la fin doit être dépassée avec précision.
• Retour : sa longueur et l'élément à cet index, donc undefined.
• Alternative raisonnable : utiliser directement values.length et ne pas lire après la fin.

Ce hook n'aurait jamais dû exister, car connaître la fin d'un tableau suffit pour ne pas la dépasser.

useCallbackNow<T>(callback: () => T): T

Mémorise un callback pour plus tard, puis l'appelle immédiatement.

function useCallbackNow<T>(callback: () => T): T;

import { useCallbackNow } from "greact-hooks";

const result = useCallbackNow(() => "déjà disponible");

• Paramètre : callback, la fonction qui n'aura finalement pas à attendre.
• Retour : le résultat immédiat de callback.
• Alternative raisonnable : appeler directement callback().

Ce hook n'aurait jamais dû exister, car mémoriser l'avenir ne sert à rien quand on l'exécute tout de suite.

useReadThenErase<T>(value: T): { readonly value: T | undefined }

Retourne la valeur lors de la première lecture de la propriété, puis efface cette réponse.

function useReadThenErase<T>(
  value: T,
): { readonly value: T | undefined };

import { useReadThenErase } from "greact-hooks";

const answer = useReadThenErase("déjà disponible");
const firstRead = answer.value;
const secondRead = answer.value;

• Paramètre : value, la valeur qui n'avait besoin que d'être lue.
• Retour : un objet dont value fournit value une fois, puis undefined.
• Alternative raisonnable : utiliser directement value.

Ce hook n'aurait jamais dû exister, car une propriété n'a aucune raison de s'autodétruire après avoir répondu.

useLowerThenUpper(value: string): string

Transforme une chaîne en minuscules, puis transforme immédiatement le résultat en majuscules. Une personne raisonnable écrirait directement value.toLowerCase().toUpperCase().

function useLowerThenUpper(value: string): string;

import { useLowerThenUpper } from "greact-hooks";

const loud = useLowerThenUpper("MiXeD"); // "MIXED"

• Paramètre : value, la chaîne à faire passer par deux transformations de casse.
• Retour : la chaîne mise en minuscules puis en majuscules.
• Alternative raisonnable : écrire directement value.toLowerCase().toUpperCase().

Ce hook n'aurait jamais dû exister, car React n'améliore pas une transformation de chaîne en la regardant faire un détour.

usePopThenPeek<T>(values: readonly T[]): T | undefined

Copie un tableau uniquement pour en retirer le dernier élément et vous le rendre.

function usePopThenPeek<T>(values: readonly T[]): T | undefined;

import { usePopThenPeek } from "greact-hooks";

const last = usePopThenPeek(["first", "last"]); // "last"

• Paramètre : values, le tableau à copier avant de lui retirer son dernier élément.
• Retour : le dernier élément de values, ou undefined si le tableau est vide.
• Alternative raisonnable : utiliser directement values.at(-1).

Ce hook n'aurait jamais dû exister, car copier un tableau avant de jeter son dernier élément n'améliore pas sa lecture.

useCeilThenFloor(value: number): number

Arrondit un nombre vers le haut, puis arrondit immédiatement le résultat vers le bas. Cela revient exactement à Math.ceil(value).

function useCeilThenFloor(value: number): number;

import { useCeilThenFloor } from "greact-hooks";

const rounded = useCeilThenFloor(1.2); // 2

• Paramètre : value, le nombre à faire passer par deux arrondis incompatibles mais redondants.
• Retour : le résultat de Math.floor(Math.ceil(value)).
• Alternative raisonnable : écrire directement Math.ceil(value).

Ce hook n'aurait jamais dû exister, car arrondir deux fois ne devient pas plus utile parce que React est présent.

useCallbackWithNothing<Args extends unknown[], Return>(callback: (...args: Args) => Return): (...args: Args) => readonly [Return, undefined]

Appelle un callback, puis range son résultat à côté de undefined dans un tuple. Le vide est fourni avec une rigueur mémoïsée.

function useCallbackWithNothing<Args extends unknown[], Return>(
  callback: (...args: Args) => Return,
): (...args: Args) => readonly [Return, undefined];

import { useCallbackWithNothing } from "greact-hooks";

const getResultAndNothing = useCallbackWithNothing(() => "résultat");
const [result, nothing] = getResultAndNothing(); // "résultat", undefined

• Paramètre : callback, la fonction à appeler plus tard.
• Retour : une fonction mémoïsée qui renvoie le résultat du callback et undefined.
• Alternative raisonnable : appeler directement le callback, ou utiliser useCallback sans ajouter le tuple.

Ce hook n'aurait jamais dû exister, car ajouter une case vide à un résultat ne crée pas une information.

useEraseThenReverse(value: string): string

Supprime le dernier caractère d'une chaîne, puis inverse tout ce qui reste. React supervise cette petite marche arrière sans raison.

function useEraseThenReverse(value: string): string;

import { useEraseThenReverse } from "greact-hooks";

const result = useEraseThenReverse("abcd"); // "cba"

• Paramètre : value, la chaîne à raccourcir et à inverser.
• Retour : la chaîne privée de son dernier caractère, puis renversée.
• Alternative raisonnable : écrire directement value.slice(0, -1).split("").reverse().join("").

Ce hook n'aurait jamais dû exister, car une découpe et une inversion ne deviennent pas une responsabilité React.

useNegativeUnlessZero(value: number): { readonly value: number }

Inverse un nombre sauf quand il vaut zéro, puis range le résultat dans un objet dont personne n'avait besoin.

function useNegativeUnlessZero(value: number): { readonly value: number };

import { useNegativeUnlessZero } from "greact-hooks";

const result = useNegativeUnlessZero(4); // { value: -4 }

• Paramètre : value, le nombre qui doit subir une inversion conditionnelle.
• Retour : un objet mémorisé contenant value inchangé pour zéro, ou son opposé dans les autres cas.
• Alternative raisonnable : écrire directement { value: value === 0 ? value : -value }.

Ce hook n'aurait jamais dû exister, car une négation conditionnelle n'a besoin ni de React ni d'un objet cérémoniel.

useArrayThenObject<T>(value: T): { readonly value: T }

Range une valeur dans un tableau à une case, la récupère immédiatement, puis la range encore dans un objet.

function useArrayThenObject<T>(value: T): { readonly value: T };

import { useArrayThenObject } from "greact-hooks";

const result = useArrayThenObject("déjà disponible"); // { value: "déjà disponible" }

• Paramètre : value, la valeur à faire passer par un tableau inutile.
• Retour : un nouvel objet contenant la valeur récupérée du tableau.
• Alternative raisonnable : écrire directement { value }.

Ce hook n'aurait jamais dû exister, car un tableau intermédiaire ne devient pas une abstraction parce qu'il est suivi d'un objet.

useIdFirstCharacter(): string

Demande à React un identifiant, puis conserve uniquement son premier caractère.

function useIdFirstCharacter(): string;

import { useIdFirstCharacter } from "greact-hooks";

const firstCharacter = useIdFirstCharacter(); // ":"

• Paramètre : aucun.
• Retour : le premier caractère de l'identifiant généré par React.
• Alternative raisonnable : écrire directement useId().slice(0, 1).

Ce hook n'aurait jamais dû exister, car jeter presque tout un identifiant ne devient pas une abstraction utile.

useDuplicateResult<Args extends unknown[], Return>(callback: (...args: Args) => Return): (...args: Args) => readonly [Return, Return]

Appelle un callback une seule fois, enregistre puis efface son résultat, et retourne ce résultat deux fois.

function useDuplicateResult<Args extends unknown[], Return>(
  callback: (...args: Args) => Return,
): (...args: Args) => readonly [Return, Return];

import { useDuplicateResult } from "greact-hooks";

const getTwoAnswers = useDuplicateResult(() => ({ answer: 42 }));
const [first, second] = getTwoAnswers();

• Paramètre : callback, la fonction dont le résultat sera enregistré, effacé, puis dupliqué.
• Retour : une fonction qui appelle callback une fois et renvoie deux références identiques au résultat.
• Alternative raisonnable : appeler directement callback(), puis écrire [result, result] si le doublon est vraiment nécessaire.

Ce hook n'aurait jamais dû exister, car une ref n'a aucune raison d'oublier un résultat avant de le rendre deux fois.

useArrayAndElement<T>(value: T): readonly [readonly T[], T]

Range une valeur dans un tableau à une case, la récupère immédiatement, puis retourne le tableau et sa valeur.

function useArrayAndElement<T>(value: T): readonly [readonly T[], T];

import { useArrayAndElement } from "greact-hooks";

const [array, element] = useArrayAndElement("déjà disponible");

• Paramètre : value, la valeur à emballer avant de la relire.
• Retour : le tableau à une case et l'élément extrait de ce tableau.
• Alternative raisonnable : écrire directement const array = [value] et utiliser value.

Ce hook n'aurait jamais dû exister, car exposer un détour intermédiaire ne crée aucune information.

useCopiedEquality<T>(values: readonly [T, T]): { readonly equal: boolean }

Copie une paire uniquement pour comparer ses deux éléments et retourner la preuve booléenne de leur égalité.

function useCopiedEquality<T>(
  values: readonly [T, T],
): { readonly equal: boolean };

import { useCopiedEquality } from "greact-hooks";

const equality = useCopiedEquality([first, second]);

• Paramètre : values, une paire à copier avant de comparer ses deux cases.
• Retour : un objet contenant equal, le résultat de Object.is entre les deux éléments.
• Alternative raisonnable : écrire directement Object.is(values[0], values[1]).

Ce hook n'aurait jamais dû exister, car copier une paire avant de vérifier une égalité ne rend pas la vérification plus exacte.

useDiscardedLength(value: string): number

Découpe une chaîne, jette immédiatement les caractères, puis compte ce qui vient de disparaître.

function useDiscardedLength(value: string): number;

import { useDiscardedLength } from "greact-hooks";

const count = useDiscardedLength("absurd");

• Paramètre : value, la chaîne à transformer en caractères avant de les supprimer.
• Retour : le nombre de caractères supprimés, identique à la longueur de value.
• Alternative raisonnable : écrire directement value.length.

Ce hook n'aurait jamais dû exister, car compter des caractères avant de les jeter n'est pas un travail pour React.

useCallbackArgumentCount<Args extends unknown[], Return>(callback: (...args: Args) => Return): (...args: Args) => number

Appelle le callback, jette son résultat, puis retourne uniquement le nombre d'arguments reçus.

function useCallbackArgumentCount<Args extends unknown[], Return>(
  callback: (...args: Args) => Return,
): (...args: Args) => number;

import { useCallbackArgumentCount } from "greact-hooks";

const countArguments = useCallbackArgumentCount((value: string) => value.length);
const count = countArguments("discarded"); // 1

• Paramètre : callback, la fonction dont le résultat sera ignoré.
• Retour : une fonction qui appelle le callback et renvoie le nombre d'arguments passés.
• Alternative raisonnable : écrire directement un wrapper qui appelle callback(...args) puis retourne args.length.

Ce hook n'aurait jamais dû exister, car sacrifier le résultat d'un callback pour compter ses arguments n'est pas une abstraction React.

useRoundedException(value: number): { readonly value: number }

Arrondit un nombre, sauf lorsqu'il est déjà arrondi : dans ce cas, il lui ajoute 1.

function useRoundedException(value: number): { readonly value: number };

import { useRoundedException } from "greact-hooks";

const result = useRoundedException(2);
// { value: 3 }

• Paramètre : value, le nombre à arrondir avant de contrarier les valeurs déjà entières.
• Retour : un objet contenant le résultat arrondi, augmenté de 1 si l'arrondi était déjà exact.
• Alternative raisonnable : écrire directement Object.is(Math.round(value), value) ? Math.round(value) + 1 : Math.round(value).

Ce hook n'aurait jamais dû exister, car une exception à l'arrondi n'est pas un état React.

useParityPick<T>(values: readonly T[]): T | undefined

Compte les éléments, utilise la parité du total comme index, puis emballe et déballe le résultat choisi.

function useParityPick<T>(values: readonly T[]): T | undefined;

import { useParityPick } from "greact-hooks";

const picked = useParityPick(["first", "second", "third"]);
// "second"

• Paramètre : values, la liste dont la longueur décide quel élément sera choisi.
• Retour : l'élément à l'index values.length % 2, ou undefined si cet index n'existe pas.
• Alternative raisonnable : écrire directement values[values.length % 2].

Ce hook n'aurait jamais dû exister, car la parité d'une longueur n'est pas une raison de fabriquer un hook React.

useUncalledAction<Args extends unknown[], Return>(callback: (...args: Args) => Return): readonly [UncalledAction<Args>, boolean]

Emballe un callback, le copie, puis fournit une action qui ne l'appelle jamais.

function useUncalledAction<Args extends unknown[], Return>(
  callback: (...args: Args) => Return,
): readonly [UncalledAction<Args>, boolean];

import { useUncalledAction } from "greact-hooks";

const [action, isOriginal] = useUncalledAction(() => "ignored");
action(); // rien ne se passe
// isOriginal === false

• Paramètre : callback, une fonction consciencieusement conservée mais jamais appelée.
• Retour : une action mémoïsée sans effet et la preuve qu'elle n'est pas le callback original.
• Alternative raisonnable : ne rien faire du tout.

Ce hook n'aurait jamais dû exister, car une action qui refuse d'agir n'avait pas besoin de passer par React.

useForgetResult<Args extends unknown[], Return>(callback: (...args: Args) => Return): (...args: Args) => void

Appelle un callback, puis jette consciencieusement la valeur qu'il vient de produire.

function useForgetResult<Args extends unknown[], Return>(
  callback: (...args: Args) => Return,
): (...args: Args) => void;

import { useForgetResult } from "greact-hooks";

const forget = useForgetResult(() => "inutile");
forget(); // la valeur est oubliée

• Paramètre : callback, une fonction dont le résultat sera immédiatement abandonné.
• Retour : une fonction mémoïsée qui appelle callback et retourne void.
• Alternative raisonnable : écrire directement void callback(...args).

Ce hook n'aurait jamais dû exister, car oublier une valeur n'est pas une responsabilité de React.

useMemoThenDiscard<T>(value: T): { readonly value: T }

Mémoïse un objet, lit sa propriété, jette l'objet, puis en fabrique un autre identique.

function useMemoThenDiscard<T>(value: T): { readonly value: T };

import { useMemoThenDiscard } from "greact-hooks";

const wrapped = useMemoThenDiscard("already available");

• Paramètre : value, la valeur enfermée dans un objet mémoïsé avant d'être récupérée.
• Retour : un nouvel objet { value } à chaque rendu.
• Alternative raisonnable : écrire directement { value }.

Ce hook n'aurait jamais dû exister, car mémoïser un emballage pour le jeter avant d'en recréer un autre est une perte de temps.

useCompareThenErase<T>(value: T): (candidate: T) => boolean

Conserve la première valeur, compare chaque candidat avec elle, puis efface immédiatement la preuve de la comparaison.

function useCompareThenErase<T>(value: T): (candidate: T) => boolean;

import { useCompareThenErase } from "greact-hooks";

const compareWithFirst = useCompareThenErase(firstValue);
compareWithFirst(candidate); // true ou false, après un effacement inutile

• Paramètre : value, la valeur initiale conservée pour les comparaisons suivantes.
• Retour : une fonction qui compare un candidat à cette valeur avec Object.is.
• Alternative raisonnable : écrire directement Object.is(firstValue, candidate).

Ce hook n'aurait jamais dû exister, car conserver une valeur dans React pour effacer aussitôt la preuve de son égalité est un détour inutile.

useCallbackSelfCheck<Return>(callback: () => Return): boolean

Exécute un callback uniquement pour vérifier si son résultat est exactement ce callback.

function useCallbackSelfCheck<Return>(callback: () => Return): boolean;

import { useCallbackSelfCheck } from "greact-hooks";

const isSelfReturning = useCallbackSelfCheck(() => "not myself");
// false

• Paramètre : callback, la fonction appelée pour examiner son propre résultat.
• Retour : true si le résultat est la même fonction, sinon false.
• Alternative raisonnable : écrire directement Object.is(callback(), callback).

Ce hook n'aurait jamais dû exister, car demander à une fonction si elle s'est retournée elle-même n'est pas une responsabilité de React.

useMiddleSplit(value: string): readonly [string, string]

Découpe une chaîne en deux au milieu, puis efface la variable qui conservait le résultat avant de le retourner.

function useMiddleSplit(value: string): readonly [string, string];

import { useMiddleSplit } from "greact-hooks";

const [left, right] = useMiddleSplit("abcd");
// ["ab", "cd"]

• Paramètre : value, la chaîne à couper en deux.
• Retour : les deux moitiés, la seconde recevant le caractère supplémentaire si la longueur est impaire.
• Alternative raisonnable : écrire directement les deux appels à slice.

Ce hook n'aurait jamais dû exister, car React ne rend pas une découpe de chaîne plus importante.

useDoubledLength<T>(values: readonly T[]): { readonly value: number }

Duplique une liste, compte la liste doublée, puis divise par deux pour retrouver sa longueur d'origine.

function useDoubledLength<T>(
  values: readonly T[],
): { readonly value: number };

import { useDoubledLength } from "greact-hooks";

const result = useDoubledLength(["one", "two"]);
// { value: 2 }

• Paramètre : values, la liste à dupliquer sans raison.
• Retour : un objet dont value est la longueur de la liste originale.
• Alternative raisonnable : écrire directement values.length.

Ce hook n'aurait jamais dû exister, car compter une liste ne s'améliore pas quand on la copie deux fois avant de la compter.

useCountDigits<T>(values: readonly T[]): number

Compte les éléments d'une liste, transforme ce compte en chaîne, puis compte les chiffres de cette chaîne.

function useCountDigits<T>(values: readonly T[]): number;

import { useCountDigits } from "greact-hooks";

const digitCount = useCountDigits(["one", "two", "three"]);
// 1

• Paramètre : values, la liste dont il faut compter les chiffres du compte.
• Retour : le nombre de chiffres nécessaires pour écrire values.length en base dix.
• Alternative raisonnable : écrire directement String(values.length).length.

Ce hook n'aurait jamais dû exister, car compter les chiffres d'un compte ne devient pas plus sérieux avec React.

useLastCharCount(value: string): number

Trouve le dernier caractère d'une chaîne, puis compte combien de fois il apparaît dans cette même chaîne.

function useLastCharCount(value: string): number;

import { useLastCharCount } from "greact-hooks";

const count = useLastCharCount("banana");
// 3

• Paramètre : value, la chaîne dont le dernier caractère doit être compté.
• Retour : le nombre d'apparitions de ce dernier caractère, ou 0 pour une chaîne vide.
• Alternative raisonnable : écrire directement la boucle de comptage.

Ce hook n'aurait jamais dû exister, car React n'a aucune raison de surveiller les fréquentations du dernier caractère.

useDiscardThenReturn<Args extends unknown[], Return>(callback: (...args: Args) => Return): (...args: Args) => (...args: Args) => Return

Appelle le callback, jette son résultat, puis retourne le callback lui-même.

function useDiscardThenReturn<Args extends unknown[], Return>(
  callback: (...args: Args) => Return,
): (...args: Args) => (...args: Args) => Return;

import { useDiscardThenReturn } from "greact-hooks";

const getCallback = useDiscardThenReturn((value: string) => value.length);
const callback = getCallback("hook");

• Paramètre : callback, la fonction qui sera appelée sans que son résultat serve à quoi que ce soit.
• Retour : une fonction qui appelle callback puis retourne callback.
• Alternative raisonnable : écrire directement (...args) => { callback(...args); return callback; }.

Ce hook n'aurait jamais dû exister, car jeter une valeur pour rendre la fonction qui l'a produite ne nécessite pas React.

useDiscardConfirmation<Args extends unknown[], Return>(callback: (...args: Args) => Return): (...args: Args) => boolean

Exécute le callback, met son résultat dans un tableau, le retire immédiatement, puis confirme si la valeur retirée était undefined.

function useDiscardConfirmation<Args extends unknown[], Return>(
  callback: (...args: Args) => Return,
): (...args: Args) => boolean;

import { useDiscardConfirmation } from "greact-hooks";

const wasNothing = useDiscardConfirmation(() => undefined);
wasNothing(); // true

• Paramètre : callback, la fonction dont le résultat sera ajouté puis retiré sans raison.
• Retour : une fonction qui renvoie true si le résultat du callback était undefined, sinon false.
• Alternative raisonnable : écrire directement (...args) => callback(...args) === undefined.

Ce hook n'aurait jamais dû exister, car React n'a pas besoin de certifier le contenu d'un tableau aussitôt vidé.

useReverseReceipt(value: string): { readonly reversed: string }

Inverse une chaîne, puis enferme le résultat dans un objet parce qu'une chaîne seule manquait manifestement de cérémonie.

function useReverseReceipt(value: string): {
  readonly reversed: string;
};

import { useReverseReceipt } from "greact-hooks";

const receipt = useReverseReceipt("dessert");
// { reversed: "tressed" }

• Paramètre : value, la chaîne à inverser pour produire un reçu inutile.
• Retour : un objet contenant la chaîne inversée.
• Alternative raisonnable : écrire directement [...value].reverse().join("").

Ce hook n'aurait jamais dû exister, car React n'améliore pas une inversion de chaîne en la livrant dans un emballage mémorisé.

useReverseThenCount(value: string): number

Inverse une chaîne entière avant de retourner sa longueur inchangée.

function useReverseThenCount(value: string): number;

import { useReverseThenCount } from "greact-hooks";

const length = useReverseThenCount("absurd");
// 6

• Paramètre : value, la chaîne à inverser pour rien.
• Retour : la longueur de la chaîne, après une inversion immédiatement oubliée.
• Alternative raisonnable : écrire directement value.length.

Ce hook n'aurait jamais dû exister, car compter une chaîne ne nécessite pas de la renverser ni d'impliquer React.

useCallbackNameLength<Args extends unknown[], Return>(callback: (...args: Args) => Return): (...args: Args) => number

Appelle le callback, jette son résultat, puis retourne le nombre de caractères de son nom.

function useCallbackNameLength<Args extends unknown[], Return>(
  callback: (...args: Args) => Return,
): (...args: Args) => number;

import { useCallbackNameLength } from "greact-hooks";

const measure = useCallbackNameLength(function namedCallback() {
  return "discarded";
});
measure(); // 13

• Paramètre : callback, la fonction qui sera exécutée uniquement pour que son résultat soit ignoré.
• Retour : une fonction mémorisée qui renvoie la longueur du nom du callback.
• Alternative raisonnable : écrire directement callback(...args); return callback.name.length.

Ce hook n'aurait jamais dû exister, car le nom d'une fonction n'a pas besoin d'un détour par React pour être compté.

useBindThenInvoke<Args extends unknown[], Return>(callback: (...args: Args) => Return): (...args: Args) => Return

Lie le callback à undefined, puis appelle immédiatement la copie liée.

function useBindThenInvoke<Args extends unknown[], Return>(
  callback: (...args: Args) => Return,
): (...args: Args) => Return;

import { useBindThenInvoke } from "greact-hooks";

const invoke = useBindThenInvoke((value: string) => value.length);
invoke("unnecessary"); // 11

• Paramètre : callback, la fonction à transformer en copie liée avant de l'appeler.
• Retour : une fonction mémorisée qui appelle cette copie et renvoie son résultat.
• Alternative raisonnable : écrire directement (...args) => callback(...args).

Ce hook n'aurait jamais dû exister, car lier une fonction à undefined avant de l'appeler ne justifie pas React.

useAppendThenRestore(value: string): readonly [string, string]

Ajoute ! à une chaîne, le retire immédiatement, puis expose les deux étapes.

function useAppendThenRestore(value: string): readonly [string, string];

import { useAppendThenRestore } from "greact-hooks";

const [appended, restored] = useAppendThenRestore("pointless");
// ["pointless!", "pointless"]

• Paramètre : value, la chaîne à modifier puis à restaurer.
• Retour : un tuple contenant la chaîne avec !, puis la chaîne d'origine retrouvée.
• Alternative raisonnable : écrire directement [${value}!, value].

Ce hook n'aurait jamais dû exister, car ajouter un caractère pour le retirer aussitôt ne nécessite pas React.

useSelfDivision(value: number): number

Divise un nombre par lui-même pour vérifier une évidence arithmétique.

function useSelfDivision(value: number): number;

import { useSelfDivision } from "greact-hooks";

const proof = useSelfDivision(42);
// 1

• Paramètre : value, le nombre à confirmer de manière disproportionnée.
• Retour : value / value (NaN pour 0 et les valeurs infinies).
• Alternative raisonnable : écrire directement value / value.

Ce hook n'aurait jamais dû exister, car une division par soi-même ne mérite pas une allocation React.

useSignOfSign(value: number): number

Calcule le signe d'un nombre, puis recalcule le signe de ce signe.

function useSignOfSign(value: number): number;

import { useSignOfSign } from "greact-hooks";

const sign = useSignOfSign(-42);
// -1

• Paramètre : value, le nombre dont le signe sera inutilement signé deux fois.
• Retour : Math.sign(Math.sign(value)), identique à Math.sign(value).
• Alternative raisonnable : écrire directement Math.sign(value).

Ce hook n'aurait jamais dû exister, car signer un signe ne nécessite pas React.

useCallbackThenObject<T>(value: T): { readonly value: T }

Crée un callback mémorisé, l'appelle immédiatement, puis range le résultat dans un nouvel objet.

function useCallbackThenObject<T>(value: T): { readonly value: T };

import { useCallbackThenObject } from "greact-hooks";

const boxed = useCallbackThenObject("already available");
// { value: "already available" }

• Paramètre : value, la valeur à faire transiter par un callback inutile.
• Retour : un nouvel objet contenant cette valeur.
• Alternative raisonnable : écrire directement { value }.

Ce hook n'aurait jamais dû exister, car mémoriser un détour pour fabriquer un emballage frais ne justifie pas React.

useGrandparentPrototype<T extends object>(value: T): object | null

Demande le prototype du prototype de value, parce qu'un seul détour dans la chaîne de prototypes n'était apparemment pas assez long.

function useGrandparentPrototype<T extends object>(value: T): object | null;

import { useGrandparentPrototype } from "greact-hooks";

const prototype = useGrandparentPrototype(Object.create({}));

• Paramètre : value, l'objet dont le grand-parent sera inutilement recherché.
• Retour : le prototype du prototype de value, ou null lorsque la chaîne s'arrête.
• Alternative raisonnable : écrire directement Object.getPrototypeOf(Object.getPrototypeOf(value)) avec un garde-fou pour null.

Ce hook n'aurait jamais dû exister, car parcourir deux prototypes ne nécessite ni React ni une abstraction.

Roadmap

• Additional time-based hooks (timeouts, idle timers).
• Fetching helpers with suspense-first ergonomics.
• More abstractions that would be simpler without hooks.

Contributing

Issues and pull requests are welcome! Run pnpm test and include coverage for new behaviour. For feature discussions, open a GitHub issue so we can design together.

License

MIT © gReact Hooks contributors