MarekZeman91

import { useRef } from 'react';

export function useScope<T>(values: T): T {
  return Object.assign(useRef({} as T).current, values);
}

MarekZeman91

import { useMemo } from 'react';

export const useConst = <T>(initialStateGetter: () => T) => {
  return useMemo(initialStateGetter, []);
};

MarekZeman91

import { useMemo, useRef } from 'react';
import { useScope } from './useScope';

export type UseDebouncerCallback = (...args: any[]) => void;

export const useDebouncer = <T extends UseDebouncerCallback>(
  callback: T,
  delay: number,
  runFirst?: boolean
): T & { clear: () => void } => {

MarekZeman91

import { DependencyList, useEffect } from 'react';

export type AsyncDestructor = () => void;
export type SetDestructor = (setDestructor: AsyncDestructor) => void;
export type EffectAsyncCallback = (destructor: SetDestructor) => Promise<void>;

export const useEffectAsync = (asyncEffect: EffectAsyncCallback, deps: DependencyList) => {
  useEffect(() => {
    let destructor: AsyncDestructor = () => {};
    asyncEffect(newDestructor => (destructor = newDestructor));

MarekZeman91

import { DependencyList, EffectCallback, useRef } from 'react';
import { useOnComponentUnmount } from './useOnComponentUnmount';

const arrayMatch = (arr1?: DependencyList, arr2?: DependencyList) => {
  if (!arr1 || !arr2) return false;
  if (arr1.length !== arr2.length) return false;
  return arr1.every((_, i) => arr1[i] === arr2[i]);
};

export const useImmediateEffect = (effect: EffectCallback, deps?: DependencyList) => {

MarekZeman91

import { useMemo } from 'react';

export function useMemoDeps<R, D1, D2, D3, D4, D5, D6, D7, D8>(
  factory: (...deps: [D1, D2, D3, D4, D5, D6, D7, D8]) => R,
  deps: [D1, D2, D3, D4, D5, D6, D7, D8]
): R;
export function useMemoDeps<R, D1, D2, D3, D4, D5, D6, D7>(
  factory: (...deps: [D1, D2, D3, D4, D5, D6, D7]) => R,
  deps: [D1, D2, D3, D4, D5, D6, D7]
): R;

MarekZeman91

import { useRef } from 'react';

export const useObject = <T extends Record<string, any | unknown>>(obj: T | undefined): T => {
  const safeObj = (obj || {}) as T;
  const cached = useRef(safeObj);

  const { current } = cached;
  if (current === safeObj) return safeObj;

  const keys = Object.keys({ ...current, ...safeObj });

MarekZeman91

import { EffectCallback, useEffect } from 'react';

export const useOnComponentMount = (onMountFn: EffectCallback) => {
  useEffect(() => onMountFn(), []);
};

MarekZeman91

import { EffectAsyncCallback, useEffectAsync } from './useEffectAsync';

export const useOnComponentMountAsync = (asyncEffect: EffectAsyncCallback) => {
  useEffectAsync(asyncEffect, []);
};

MarekZeman91

import { useEffect } from 'react';

export const useOnComponentUnmount = (onUnmountFn: () => void) => {
  useEffect(() => () => onUnmountFn(), []);
};