Skip to content

Latest commit

 

History

History
257 lines (179 loc) · 5.44 KB

README.md

File metadata and controls

257 lines (179 loc) · 5.44 KB
Raw

The missing js and ts helpers

Arrays

  • sum: Calculates the sum of an array of numbers. Returns 0 if the array is empty.
sum([1,2,3]) // 6
  • mean: Computes the mean of an array of number. Returns 0 if the array is empty
mean([1,2,3]) // 2
  • findIndexAndValue: Finds a value in an array given a predicate, and returns an object with the value and its index
const fruits = ["banana", "peach", "strawberry"	];

findIndexAndValue(fruits, (f) => f === "peach") // {index: 1, value: "peach"}
  • range: Creates an array of numbers between start (defaults to 0) and stop (excluded) in increments of step (defaults to 1)
range(3) // [0,1,2]
range(1,3) // [1,2]
range(1,6,2) // [1,3,5]
  • areArraysEquivalent: Checks whether two arrays have the same elements
areArraysEquivalent([1, 2, 3], [3, 2, 1]) // true;

Functions

  • once: Decorator making a function callable once
let i = 0;

const increment = () => i++;
const wrapped = once(increment);

wrapped(); // i = 1
wrapped(); // i = 1
wrapped(); // i = 1

Heap

A fast priority queue / heap implementation, with O(nlog(n)) complexity.

The constructor takes a comparator function.

Public fields:

  • size: (number) the size of the heap
  • isEmpty: (boolean) whether the heap is empty
  • enqueue: adds an element to the queue and prioritizes it
  • dequeue: pops the next element in the priority queue
  • peek: look at the next element without popping it
  • has: checks whether a given element is in the queue
const queue = new PriorityQueue((a: string, b: string) => a < b ? -1 : a === b ? 0 : 1);

queue.enqueue("Bob");
queue.enqueue("Zack");
queue.enqueue("Alice");

queue.size(); // 3
queue.has("Dan"); // false

queue.dequeue(); // Alice
queue.dequeue(); // Bob

queue.peek(); // Zack
queue.isEmpty(); // false

queue.dequeue(); // Zack

Numbers

  • round: Rounds a value to a given precision. By default rounds to the nearest integer
round(Math.PI, 2) // 3.14
  • modulo(n: number, d: number): Computes n modulo d.

Note: the modulo operator has the same sign as the divisor d whereas the remainder n % d has the same sign as the dividend n

modulo(-1, 3); // 2
-1 % 3;  // -1

Objects

  • merge: Type-safe Object.assign
const m = merge(
  { foo: 123 },
  { foo: "abc", bar: 123 },
  { foo: true, baz: "abc" }
)

typeof m // { foo: boolean; bar: number; baz: string }

Promises

  • debounce: A debounce decorator. Parameters:
    • func The function to debounce.
    • delay (default: 100) Minimum delay in ms between calls.
    • throttle (default: false) When debouncing every new call to func resets the delay timer. When throttling the function ensures there is at least delay ms between calls
const arr = [];

const fn = debounce(() => arr.push(Math.random()), 10);

fn();
await sleep(6);
fn();
await sleep(6);
fn();
await sleep(11);

arr.length; // 1
  • Debounce: a debounce class, similar to the simpler function, but with the ability to flush

Random

  • randint(a:number, b: number): Returns a random integer in [a;b]
randint(0, 5) // 2

Regex

  • regexEscape: escape special Regex characters
regexEscape(".") // \.
regexEscape("(*.*)") // \(\*\.\*\)

Sets

  • areSetsEqual: checks whether two sets are equal
const s1 = new Set([2, 3, 4]);
const s2 = new Set([4, 3, 2]);

areSetsEqual(s1, s2); // true

Strings

  • randomString: Creates a random string of a given length in the alphabet [a-zA-Z0-9_-] (64 characters)
randomString(8); // TNxOLDho
  • nanoId: A fast alias of randomString with length = 8 by default
nanoId(); // b6eKfYLB
  • capitalize: Turns the first letter of a string to uppercase
capitalize("capitalized") // "Capitalized"
  • trim, trimStart, trimEnd: trim (regex escaped) characters (substring) from a string
trim("--dashes-", "-") // "dashes"
trimEnd("ellipsis...", ".") // "ellipsis"

Types

  • type: Returns a string representation of the type of an object and is more precise than typeof.
// null / undefined types
type(null); // "null"
type(undefined); // "undefined"

// other primitive types
type(0); // "number"
type(BigInt(0)); // "bigint"
type(true); // "boolean"
type(""); // "string"
type(Symbol("")); // "symbol"

// object types
type([]); // "array"
type(new Date()); // "date"
type(new Boolean(true)); // "boolean"
type(new Number(0)); // "number"
type(new String("")); // "string"
type(new Error("")); // "error"
type(new RegExp("a")); // "regexp"
type(/a/); // "regexp"
type({}); // "object"

// function type
type(() => 1); // "function"
type(class Dog {}); // "class"

  • Prettify<T>: Prettify types by ensuring type expansion

  • Required<T, K extends keyof T>: Require only a specific subset of keys of T

  • Partial<T, K extends keyof T>: Partial on specific keys of T

  • StrictOmit<T, K extends keyof T>: Omit with constrained keys

  • StrictExtract<T, U extends T>: Extract with constrained keys

  • Timeout: Return type of setTimeout

  • StructuredCloneValue: allowable values for the structuredClone function