• Statuses
• entries
• ifilter
• imap
• ireduce
• phraseStatuses
• statuses

• default

• Status

• IsAllPartial
• IsAllPartialNullable
• IterableValue
• MaybePromise
• PartialNullable
• Tuple

• phraseStatus
• status

• accumulate
• arrayToChunks
• baseGcd
• between
• capitalizeFirst
• ceil
• chain
• choice
• compress
• count
• createWrappedText
• cycle
• debounce
• dropWhile
• enumerate
• escapeRegex
• filter
• filterMap
• floor
• gcd
• getPrimesUpTo
• increment
• inlineTry
• inlineTryPromise
• isEqual
• isEqualArray
• isEqualObject
• isErrorLike
• isObject
• isPrime
• islice
• map
• objectEntries
• omit
• pick
• pickAll
• randint
• range
• reduce
• repeat
• round
• runIfDefined
• shuffle
• takeWhile
• toTitleCase
• trunc
• uniform
• zip

Renames and re-exports Status

Renames and re-exports objectEntries

Renames and re-exports filter

Renames and re-exports map

Renames and re-exports reduce

Renames and re-exports phraseStatus

Renames and re-exports status

Ƭ IsAllPartial<T>: Partial<T> extends T ? true : false

Evaluates to true if all properties in T are optional, false otherwise

types.ts:49

Ƭ IsAllPartialNullable<T>: PartialNullable<T> extends T ? true : false

Evaluates to true if all properties in T are optional AND nullable, false otherwise

types.ts:52

Ƭ IterableValue<T>: Exclude<ReturnType<ReturnType<T[typeof Symbol.iterator]>["next"]>, IteratorReturnResult<any>>["value"]

Extracts the value of an iterable

types.ts:28

Ƭ MaybePromise<T>: Promise<T> | T

Takes type param T and creates a type that's either Promise<T> or T

Example

const myVar: MaybePromise<number> = 3
const myVar: MaybePromise<number> = Promise.resolve(3)

types.ts:43

Ƭ PartialNullable<T>: { [P in keyof T]?: T[P] | null }

Make all properties in T optional and nullable

types.ts:46

Ƭ Tuple<T, L>: L extends L ? number extends L ? T[] : TupleOf<T, L, []> : never

Tuple of type T with L values in it

Example

type MyTuple = Tuple<string, 3> // [string, string, string]

types.ts:13

• Const phraseStatus: Object

HTTP response status codes indicate whether a specific HTTP request has been successfully completed. Responses are grouped in five classes:

1. Informational responses (100–199)
2. Successful responses (200–299)
3. Redirects (300–399)
4. Client errors (400–499)
5. Server errors (500–599)

Doc comments: copyright MDN Contributors under CC-BY-SA 2.5

Documentation from the MDN

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status

http.ts:3808

• Const status: Object

HTTP response status codes indicate whether a specific HTTP request has been successfully completed. Responses are grouped in five classes:

1. Informational responses (100–199)
2. Successful responses (200–299)
3. Redirects (300–399)
4. Client errors (400–499)
5. Server errors (500–599)

Doc comments: copyright MDN Contributors under CC-BY-SA 2.5

Documentation from the MDN

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status

http.ts:1310

▸ accumulate<K>(iterable, operator?, initial?): Generator<number, void, void>

Make an iterator that returns accumulated sums, or accumulated results of other binary functions (specified via the optional func argument).

Based on Python's itertools.accumulate function

Generator<number, void, void>

• Generator of each item of iterable, each item accumulated from the previous values

Example

Array.from(accumulate([1, 2, 3, 4, 5])) // [1, 3, 6, 10, 15]
Array.from(accumulate([1, 2, 3, 4, 5], undefined, 100)) // [100, 101, 103, 106, 110, 115]
Array.from(accumulate([1, 2, 3, 4, 5], (prev, current) => prev * current)) // [1, 2, 6, 24, 120]
Array.from(accumulate([1, 2, 3, 4, 5], "*") // [1, 2, 6, 24, 120]

itertools.ts:128

▸ arrayToChunks<T>(array, chunkSize?): T[][]

Splits an array into chunks

T[][]

Array of each chunk in the form of arrays

Example

arrayToChunks([1, 2, 3, 4, 5, 5]) // [[1, 2, 3], [4, 5, 6]]
arrayToChunks([1, 2, 3, 4, 5, 5], 2) // [[1, 2], [3, 4], [5, 6]]

array.ts:30

▸ baseGcd(first, second): number

Recursive implementation of Euclid's GCD algorithm

number

Gcd of first and second

Example

baseGcd(10, 100) // 10
baseGcd(128, 64) // 64

math.ts:21

▸ between(lower, value, upper): number

Keeps a number between an upper and lower bound

number

Bound number

Example

const num = 5

between(0, num, 10) // 5
between(-1, num, 3) // 3
between(10, num, 30) // 10

math.ts:207

▸ capitalizeFirst(str): string

Capitalizes the first letter of a string

string

String with first letter capitalized

Example

capitalizeFirst("hello") // "Hello"
capitalizeFist("WORLD") // "WORLD"
capitalizeFirst("hello world!") // "Hello world!"

string.ts:21

▸ ceil(num, precision?): number

Ceils num to n decimal place

number

Ceiled number

Example

ceil(123.456, 2) // 123.46
ceil(123.456, 1) // 123.5
ceil(123.456, -2) // 100

math.ts:168

▸ chain<T, K>(...iterables): Generator<IterableValue<IterableValue<K>>, void, void>

Chains iterables together into one iterable, from the first iterable until it is exhausted, then proceeds to the next iterable, until all of the iterables are exhausted.

Generator<IterableValue<IterableValue<K>>, void, void>

Generator of the chained iterables

Remarks

Used for treating consecutive sequences as a single sequence.

Based on Python's itertools.chain function

Example

function* generator1(): Generator<string> {
    yield "a"
    yield "b"
}

function* generator2(): Generator<number> {
    yield 1
    yield 2
    yield 3
}

Array.from(chain(generator1(), generator2())) // ["a", "b", 1, 2, 3]
Array.from(chain(generator1(), generator2(), [4, 5, 6])) // ["a", "b", 1, 2, 3, 4, 5, 6]

itertools.ts:91

▸ choice<T>(arr): T

Return a random element from the non-empty array arr

T

Random item chosen from arr

random.ts:36

▸ compress<T>(data, selectors): Generator<T, void, void>

Make an iterator that filters elements from data returning only those that have a corresponding element in selectors that is truthy. Stops when either the data or selectors iterables has been exhausted.

Based on Pythons itertools.compress function

Generator<T, void, void>

Example

Array.from(compress("abcdef", [1, 0, 1, 0, 1, 1])) // ["a", "c", "e", "f"]
Array.from(compress([1, 2, 3, 4, 5, 6], [true, false, true, false])) // [1, 3]

itertools.ts:379

▸ count<T>(array, predicate, max?): number

Counts items in array that match the predicate

number

Number of counted items

Example

const array = [true, true, true, false, false, false, false]
count(array, (val) => val) // 3
count(array, (val) => !val) // 4
count(array, (val) => !val, 2) // 2

array.ts:58

▸ createWrappedText(text, lengthThreshold, hyphenThreshold?, delimiter?): string[]

Splits text by maximum line length

string[]

Array of lines wrapped to threshold

string.ts:60

▸ cycle<T, K>(iterable): Generator<IterableValue<K>, void, void>

Make an iterator returning elements from the iterable and saving a copy of each. When the iterable is exhausted, return elements from the saved copy. Repeats indefinitely.

Based on Python's itertools.cycle function

Generator<IterableValue<K>, void, void>

Generator of the elements of iterable

Example

Array.from(zip([1, 2, 3], cycle("abc"))) // [[1, "a"], [2, "b"], [3, "c"]]
Array.from(cycle([1, 2, 3])) // [1, 2, 3, 1, 2, 3, 1, 2, 3 ...(forever)]

itertools.ts:219

▸ debounce<Args>(func, ms): (...args: Args) => void

Delay the execution of a function, and reset said delay if the function is called again within the delay window.

fn

Debounced function

▸ (...args): void

void

Example

window.addEventListener(
    "resize",
    debounce((event) => console.log(event), 100),
)

functions.ts:51

▸ dropWhile<T>(iterable, predicate): Generator<T>

Make an iterator that drops elements from iterable as long as the predicate is true; afterwards, returns every element

Based on Python's itertools.dropwhile function

Generator<T>

Generator of each item after the predicate is fulfulled

Remarks

The iterator does not produce any output until the predicate first becomes false, so it may have a lengthy start-up time.

Example

Array.from(dropWhile([1, 4, 6, 4, 1], (val) => val < 5)) // [6, 4, 1]
Array.from(dropWhile("abcdefg", (val) => val !== "d")) // ["d", "e", "f", "g"]

itertools.ts:411

▸ enumerate<T>(iterable, start?): Iterable<[index: number, value: T]>

Array.entries equivalent with support for iterables

Based on Python's enumerate

Iterable<[index: number, value: T]>

Iterable with a tuple containing the index and value of the iterable item

Example

const seasons = ["Spring", "Summer", "Fall", "Winter"]

Array.from(enumerate(seasons)) // [[0, 'Spring'], [1, 'Summer'], [2, 'Fall'], [3, 'Winter']]
Array.from(enumerate(seasons, 1)) // [[1, 'Spring'], [2, 'Summer'], [3, 'Fall'], [4, 'Winter']]

itertools.ts:477

▸ escapeRegex(str): string

Escapes string for use in regular expressions

string

String with values escaped for regex

Example

const string = "**string**"

new RegExp(string) // Uncaught SyntaxError: Invalid regular expression: /**string**​/: Nothing to repeat

new RegExp(escapeRegex(string)) // OK

regex.ts:25

▸ filter<T>(iterable, predicate, maxSize?): Generator<T, void, void>

Array.filter equivalent with size limit and support for iterables

Generator<T, void, void>

Generator of each item that isn't filtered and within the limit

Example

const array = [true, true, true, false, false, false, false]
Array.from(filter(array, (val) => val)) // [true, true, true]
Array.from(filter(array, (val) => val, 2)) // [true, true]
Array.from(filter("abcdefg", (val) => val !== "a", 3)) // ["b", "c", "d"]

itertools.ts:500

▸ filterMap<T, K>(array, callbackFn): K[]

Map and filter in one loop

K[]

Array of each item that goes through callbackFn

Example

const array = [true, true, true, false, false, false, false]

filterMap(array, (val, index) => ({
    shouldInclude: val,
    value: index,
})) // [0, 1, 2]

filterMap(array, (val, index) => ({
    shouldInclude: !val,
    value: index,
})) // [3, 4, 5, 6]

array.ts:112

▸ floor(num, precision?): number

Floors num to n decimal place

number

Floored number

Example

floor(123.456, 2) // 123.45
floor(123.456, 1) // 123.4
floor(123.456, -2) // 100

math.ts:150

▸ gcd(...numbers): number

Computes the GCD using array reduce and Euclid's GCD algorithm

number

The gcd of all the numbers

Example

gcd(10, 20, 30) // 10
gcd(13924, 1249, 123, 3) // 1

math.ts:42

▸ getPrimesUpTo(max): Generator<number>

Generates all prime numbers up to max using the Sieve of Eratosthenes

Generator<number>

Generator of each prime number

Example

Array.from(getPrimesUpTo(30)) // [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
Array.from(getPrimseUpTo(10)) // [2, 3, 5, 7]
Array.from(getPrimseUpTo(7)) // [2, 3, 5]

math.ts:85

▸ increment(start?, step?): Generator<number, void, void>

Make an iterator that returns evenly spaced values step apart starting with number start

Based on Python's itertools.count function

Generator<number, void, void>

Generator of evenly spaced values step apart starting with number start

Example

Array.from(zip([1, 2, 3], increment())) // [[1, 1], [2, 2], [3, 3]]
Array.from(increment()) // [0, 1, 2, 3, 4, ...(forever)]
Array.from(increment(10, 2)) // [10, 12, 14, 16, ...(forever)]

itertools.ts:255

▸ inlineTry<T>(func, shouldKeepError): undefined | T

Tries to execute func and returns or discards any error that occurs

undefined | T

Return value of func. If an error is thrown, return it if shouldKeepError is true, else discard it

Example

inlineTry(() => {
    throw new Error("Error!")
}) // Error: Error!
inlineTry(() => {
    throw new Error("Error!")
}, false) // undefined
inlineTry(() => 1, true) // 1
inlineTry(() => 1, false) // 1

try.ts:69

▸ inlineTry<T>(func, shouldKeepError?): Error | T

Tries to execute func and returns or discards any error that occurs

Error | T

Return value of func. If an error is thrown, return it if shouldKeepError is true, else discard it

Example

inlineTry(() => {
    throw new Error("Error!")
}) // Error: Error!
inlineTry(() => {
    throw new Error("Error!")
}, false) // undefined
inlineTry(() => 1, true) // 1
inlineTry(() => 1, false) // 1

try.ts:69

▸ inlineTryPromise<T>(func, shouldKeepError): Promise<undefined | T>

Tries to execute and await func and returns or discards any error that occurs

Promise<undefined | T>

Return value of func. If an error is thrown, return it if shouldKeepError is true, else discard it

Example

await inlineTryPromise(async () => {
    await Promise.resolve()
    throw new Error("Error!")
}, true) // Error: Error!
await inlineTryPromise(async () => {
    await Promise.resolve()
    throw new Error("Error!")
}, false) // undefined
await inlineTryPromise(async () => await Promise.resolve(1), false) // 1
await inlineTryPromise(async () => await Promise.resolve(1), true) // 1

try.ts:150

▸ inlineTryPromise<T>(func, shouldKeepError?): Promise<Error | T>

Tries to execute and await func and returns or discards any error that occurs

Promise<Error | T>

Return value of func. If an error is thrown, return it if shouldKeepError is true, else discard it

Example

await inlineTryPromise(async () => {
    await Promise.resolve()
    throw new Error("Error!")
}, true) // Error: Error!
await inlineTryPromise(async () => {
    await Promise.resolve()
    throw new Error("Error!")
}, false) // undefined
await inlineTryPromise(async () => await Promise.resolve(1), false) // 1
await inlineTryPromise(async () => await Promise.resolve(1), true) // 1

try.ts:150

▸ isEqual(val1, val2, maxDepth?, maxLength?): boolean

Checks if val1 and val2 are equal. Works like lodash isEqual, and is just as fast.

boolean

If val1 is deeply equal to val2

Remarks

BEFORE YOU USE THIS: think to yourself, "Do I need this?" If there's another way, it's problably faster. Deep equality checking is a very costly operation and should be used sparingly

deepEqual.ts:26

▸ isEqualArray(obj1, obj2, maxDepth?, maxLength?): boolean

Checks if arr1 and arr2 are equal, given that they are both arrays

boolean

If arr1 is deeply equal to arr2

deepEqual.ts:111

▸ isEqualObject(obj1, obj2, maxDepth?, maxLength?): boolean

Checks if obj1 and obj2 are equal, given that they are both arrays

boolean

If obj1 is deeply equal to obj2

deepEqual.ts:67

▸ isErrorLike(obj): obj is Object

Check if error like (i.e has the name and message properties, both of which are strings)

obj is Object

If object is error-like

Example

isErrorLike(new Error()) // True
isErrorLike({name: "Error!", message: "This is an error", other: 0}) // True
isErrorLike({}) // False
isErrorLike({name: "Error", message: null}) // False

// Works as a typguard
const something = {name: "Error", message: "This is an error"} as unknown

if (isErrorLike(something)) {
    console.log(something.name) // No Typescript error
}

typeGuards.ts:60

▸ isObject(obj): obj is Object

Check if object like (typeof object and not null)

obj is Object

If object is error-like

Example

isErrorLike({}) // True
isErrorLike(/regex/) // True
isErrorLike(new Date()) // True
isErrorLike("string") // False

// Works as a typguard
const something = {} as unknown

if (isObject(something)) {
    // No Typescript error
    console.log(something.property)
}

if (typeof something === "object" && something !== null) {
    // Property 'property' does not exist on type 'object'. ts(2339)
    console.log(something.property)
}

typeGuards.ts:35

▸ isPrime(num): boolean

Checks if a number is prime

boolean

If num is prime or not

Example

isPrime(2) // true
isPrime(10) // false
isPrime(31) // true

math.ts:59

▸ islice<T>(iterable): Generator<T, void, void>

Make an iterator that returns all the elements from iterable consecutively

Based on Python's itertools.islice function

Generator<T, void, void>

Generator of each element of iterable

Example

Array.from(islice("abcdefg")) // ["a", "b", "c", "d", "e", "f", "g"]

itertools.ts:622

▸ islice<T>(iterable, end): Generator<T, void, void>

Make an iterator that returns the elements from iterable consecutively, from 0 - end

Generator<T, void, void>

Generator of the elements from iterable sliced from 0 to end

Remarks

Sliced iterable is non-inclusive of end, where end is a non-negative number

Based on Python's itertools.islice function

Example

Array.from(islice("abcdefg", 2)) // ["a", "b"]

itertools.ts:643

▸ islice<T>(iterable, start, end): Generator<T, void, void>

Make an iterator that returns the elements from iterable consecutively, from start - end,

Generator<T, void, void>

Generator of the elements from iterable sliced from 0 to end

Remarks

Slice is non-inclusive of end, where start and end are non-negative numbers. If end is null, slice from start to the end of the iterator

Based on Python's itertools.islice function

Example

Array.from(islice("abcdefg", 2, 4)) // ["c", "d"]
Array.from(islice("abcdefg", 2, null)) // ["c", "d", "e", "f", "g"]

itertools.ts:667

▸ islice<T>(iterable, start, end, step): Generator<T, void, void>

Make an iterator that returns the elements from iterable for every stepth element, from start - end

Generator<T, void, void>

Generator of the elements from iterable sliced from 0 to end

Remarks

Slice is non-inclusive of end, where start, end, and step are non-negative numbers. If end is null, slice from start to the end of the iterator

Based on Python's itertools.islice function

Example

Array.from(islice("abcdefg", 0, null, 2)) // ["a", "c", "e", "g"]
Array.from(islice("abcdefg", 0, 4, 2)) // ["a", "c"]

itertools.ts:697

▸ map<T, K>(iterable, transformer): Generator<K, void, void>

Array.map equivalent with support for iterables

Generator<K, void, void>

Generator of each item, passed through the transformer function

Example

const array = [1, 2, 3, 4, 5, 6]
Array.from(map(array, (val) => val % 2 === 0)) // [false, true, false, true, false, true]
Array.from(map(array, (val) => val - 1)) // [0, 1, 2, 3, 4, 5]
Array.from(map("abc", (val: string) => val + "a")) // ["aa", "ba", "ca"]

itertools.ts:541

▸ objectEntries<T>(obj): Generator<{ [K in keyof T]: [K, T[K]] }[keyof T], void, void>

Better Object.entries, which is faster, returns an iterator instead of an array (more memory efficient), and is typed better

Generator<{ [K in keyof T]: [K, T[K]] }[keyof T], void, void>

Generator producing the key and value of each item

Example

Array.from(objectEntries({a: 1, b: 2})) // [["a", 1], ["b", 2]]

object.ts:20

▸ omit<T, K>(obj, ...keys): Omit<T, K[number]>

Omits values from an object and creates a new object