MarekZeman91

export function useArrayHash<T>(array: T[], key: keyof T): string {
  return array.map((x) => x[key]).join("");
}

MarekZeman91

import type { Dispatch } from "react";
import { useState } from "react";

export function useAutoResetState<S>(
  initialState: S | (() => S),
): [S, Dispatch<S>] {
  const [state, setState] = useState(initialState);
  return [
    state,
    (temporaryState: S) => {

MarekZeman91

export function el<K extends keyof HTMLElementTagNameMap>(
  nodeName: K,
  props?: Record<string, unknown>,
  children?: (string | number | boolean | Node)[],
): HTMLElementTagNameMap[K];

export function el<T extends HTMLElement>(
  nodeName: string,
  props?: Record<string, unknown>,
  children?: (string | number | boolean | Node)[],

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,

MarekZeman91

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

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

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

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

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(() => {