RodrigoNovais

import { useEffect, useState } from 'react';

type Callback = (element?: string | number) => void
type TargetKey = string | number | Array<string|number>

const isNumber = (value: unknown): value is number => typeof value === 'number';
const isString = (value: unknown): value is string => typeof value === 'string';

const isNumberArray = (object: unknown): object is number[] =>
    Array.isArray(object) && object.every(e => isNumber(e));

RodrigoNovais

import { useState, useCallback } from 'react'

export type Counter = {
    count: number
    increment: (value?: number | undefined) => void
    decrement: (value?: number | undefined) => void
    reset: (value?: number | undefined) => void
}

export default (initialValue: number = 0): Counter => {

RodrigoNovais

export default <T>(value: T | null | undefined): value is T => !!value

RodrigoNovais

export const hasKey = <T>(object: T, key: keyof any): key is keyof T => key in object

RodrigoNovais

type RequireAtLeastOne<T, Keys extends keyof T = keyof T> =
    Pick<T, Exclude<keyof T, Keys>> 
    & {
        [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>
    }[Keys]

RodrigoNovais

type RequireOnlyOne<T, Keys extends keyof T = keyof T> =
    Pick<T, Exclude<keyof T, Keys>>
    & {
        [K in Keys]-?:
            Required<Pick<T, K>>
            & Partial<Record<Exclude<Keys, K>, undefined>>
    }[Keys]

RodrigoNovais

/**
 * Creates an array of elements split into groups the length of size
 *
 * @template T
 * @param {T[]} input
 * @param {number} size
 * @returns {T[][]}
 */
export const chunk = <T>(input: T[], size: number): T[][] => {
    return input.reduce((array, item, index) => {

RodrigoNovais

/**
 * Returns the values from array that are not present in the other arrays
 *
 * @param {unknown[]} first
 * @param {unknown[]} second
 * @returns {unknown[]}
 */
export const difference = (first: unknown[], second: unknown[]): unknown[] => {
    return first.filter(item => !second.includes(item));
};

RodrigoNovais

/**
 * Returns the values from array that are present in each of the other arrays
 *
 * @param {...unknown[]} arrays
 * @returns {unknown[]}
 */
export const intersection = (...arrays: unknown[]): unknown[] => {
    return arrays.reduce((a, b) => a.filter((c: any) => b.includes(c)))
};

RodrigoNovais

declare global {
    interface Array<T> {
        /**
         * Creates an tuple of grouped elements limited by the length of the first array.
         * @template U
         * @param {U} list
         */
        zip<U>(list: U[]): [T, U][]
    }
}