RodrigoNovais

{
    "env": {
        "node": true,
        "es2021": true
    },
    "extends": [
        "eslint:recommended",
        "plugin:@typescript-eslint/recommended",
        "plugin:import/errors",
        "plugin:import/warnings",

RodrigoNovais

export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

RodrigoNovais

/**
 * Group array of objects by given keys
 *
 * @param keys keys to be grouped by
 * @param array objects to be grouped
 *
 * @returns an object with objects in `array` grouped by `keys`
 */
export const groupBy = <T>(keys: (keyof T)[]) => (array: T[]): Record<string, T[]> => {
    return array.reduce((objectsByKeyValue, obj) => {

RodrigoNovais

import React, { Fragment, useEffect, useState } from 'react';
import { createPortal } from 'react-dom';

const Portal: React.FC<{ selector: string }> = ({ children, selector }) => {
    const [mounted, setMounted] = useState<boolean>(false);

    useEffect(() => {
        setMounted(true);
        return () => setMounted(false);
    }, [selector]);

RodrigoNovais

import EventEmitter from 'events';

export interface TimerEvents {
    'tick': (time: number) => void;
    'complete': () => void;
}

export interface Timer {
    addListener<U extends keyof TimerEvents>(event: U, listener: TimerEvents[U]): this;
    prependListener<U extends keyof TimerEvents>(event: U, listener: TimerEvents[U]): this;

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][]
    }
}

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

/**
 * 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

/**
 * 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

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]