MarekZeman91

type AbortCallback = (err: any) => void;
type SetAbort = (abortCallback: AbortCallback) => void;

export const delay = (ms: number, setAbort?: SetAbort) => {
  return new Promise((resolve, reject) => {
    const timeout = setTimeout(resolve, ms);
    setAbort(err => {
      clearTimeout(timeout);
      reject(err);
    });

MarekZeman91

import { MutableRefObject, RefCallback, RefObject } from 'react';

export const setRef = <T>(...refs: (RefCallback<T> | RefObject<T> | MutableRefObject<T> | undefined | null)[]) => {
  return (instance: T | null) => {
    for (const ref of refs) {
      if (!ref) continue;

      if (typeof ref === 'function') {
        ref(instance);
      }

MarekZeman91

import { CancelTokenSource } from 'axios';
import { useCallback, useRef } from 'react';
import { newCancelTokenSource } from '../network/api/Network';
import { delay } from '../utils/FlowUtils';
import { useOnComponentUnmount } from './useOnComponentUnmount';
import { useScope } from './useScope';

// when your callback returns usePoolingCallback.RETRY, it retries after delay
export const usePoolingCallback = <R, D>(
  callback: (cancelTokenSource: CancelTokenSource, data: D) => Promise<R | typeof usePoolingCallback.RETRY>,

MarekZeman91

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

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

export const useThrottler = <T extends UseThrottlerCallback>(callback: T, delay: number): T & { clear: () => void } => {
  const scope = useScope({ callback, delay });
  const timeout = useRef<number>(0);

  return useMemo(() => {

MarekZeman91

import { useMemo, useRef } from 'react';

export type UseValuesChangeWatcherResult<T extends Record<string, unknown>> = {
  [K in keyof T]?: {
    oldValue: unknown;
    newValue: unknown;
  };
};

const compareFn = <T extends [string, unknown]>(a: T, b: T) => a[0].localeCompare(b[0]);

MarekZeman91

import { createElement, CSSProperties, FC } from 'react';

export type CSSBoxProps = CSSProperties & { className?: string };
export const CSSBox: FC<CSSBoxProps> = ({ children, className, ...style }) => {
  return createElement('div', { className, style }, children);
};

MarekZeman91

class ExpandedPromise<T> extends Promise<T> {
    resolve: (value: T | PromiseLike<T>) => void;
    reject: (reason?: any) => void;

    status: 'pending' | 'fulfilled' | 'rejected' = 'pending';

    constructor() {
        const callbacks: {
            resolve?: ExpandedPromise<T>['resolve'],
            reject?: ExpandedPromise<T>['reject'],

MarekZeman91

const setText = (input: HTMLInputElement, value: string): void =>  {
  const prototype = Object.getPrototypeOf(input);
  const valueSetter = Object.getOwnPropertyDescriptor(prototype, 'value').set;

  valueSetter.call(input, value);

  const init = { bubbles: true, cancelable: true };
  input.dispatchEvent(new Event('change', init));
};

MarekZeman91

import { createRef, ForwardedRef, forwardRef, useImperativeHandle, useRef } from 'react';

interface ForwardedHandlers<T> {
  getValue(): T;
}

interface ForwardedProps<T> {
  value: T;
  children?: never;
}

MarekZeman91

const triggerDownload = (blob: Blob, filename: string) => {
  const url = window.URL.createObjectURL(blob);
  const link = document.createElement('a');
  link.download = filename;
  link.href = url;

  document.body.appendChild(link);

  link.dispatchEvent(new MouseEvent('click', {
    bubbles: true,