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

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

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 { 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 { 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 { 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

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 { useEffect } from 'react';

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

MarekZeman91

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

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

MarekZeman91

import { EffectCallback, useEffect } from 'react';

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