Utils

Index

Classes

Interfaces

Type aliases

Variables

Functions

Type aliases

ArrayElement

ArrayElement<ArrayType>: ArrayType[number]

Turns array elements into a type.

['name', 'email'] becomes 'name' | 'email'

Type parameters

ArrayType: readonly unknown[]

DeepPartial

DeepPartial<T>: {[ P in keyof T]: DeepPartial<T[P]> }

Works the same as Partial<T> except it applies Partial to sub elements.

Type parameters

Variables

Const HOUR_IN_MINUTES

HOUR_IN_MINUTES: 60 = 60

Const HOUR_IN_MS

HOUR_IN_MS: number = ...

Const HOUR_IN_SECONDS

HOUR_IN_SECONDS: number = ...

Const MINUTE_IN_MS

MINUTE_IN_MS: number = ...

Const MINUTE_IN_SECONDS

MINUTE_IN_SECONDS: 60 = 60

Const SECOND_IN_MS

SECOND_IN_MS: 1000 = 1000

Functions

Const asyncForEach

asyncForEach<T>(array: T[], itterator: (value: T, index: number, array: T[]) => Promise<void>, options?: DeepPartial<AsyncForEachOptions>): Promise<void>

- Defined in functions/async-for-each.ts:21
Runs the supplied itterator for all elements in the array asyncronously.

Type parameters
- T
Parameters
- array: T[]
  
  The array to itterate through.
- itterator: (value: T, index: number, array: T[]) => Promise<void>
  
  The async function to run for each element.
  - - (value: T, index: number, array: T[]): Promise<void>
    - Parameters
      - value: T
      - index: number
      - array: T[]
      Returns Promise<void>
- Optional options: DeepPartial<AsyncForEachOptions>
Returns Promise<void>

Const asyncMap

asyncMap<T, K>(list: T[], executor: (element: T, index: number, array: T[]) => Promise<K>): Promise<K[]>

- Defined in functions/async-map.ts:7
Runs Array.map asyncronously.

Type parameters
- T
- K
Parameters
- list: T[]
  
  The array to map
- executor: (element: T, index: number, array: T[]) => Promise<K>
  
  The function to run for each
  - - (element: T, index: number, array: T[]): Promise<K>
    - Parameters
      - element: T
      - index: number
      - array: T[]
      Returns Promise<K>
Returns Promise<K[]>

Const asyncTimes

asyncTimes<T>(number: number, cb: (i: number) => Promise<T>): Promise<T[]>

- Defined in functions/times.ts:24
Repeat the given function number times asyncronously

Type parameters
- T
Parameters
- number: number
  
  The number of times to itterate
- cb: (i: number) => Promise<T>
  
  The function to run
  - - (i: number): Promise<T>
    - Parameters
      - i: number
      Returns Promise<T>
Returns Promise<T[]>

Const cacheFor

cacheFor<T>(__namedParameters: CacheForOptions, generator: () => Promise<T>): Promise<T>

- Defined in functions/cache-for.ts:94
A crude caching system that will cache values for the given time.

Type parameters
- T
Parameters
- __namedParameters: CacheForOptions
- generator: () => Promise<T>
  
  The promise function that returns the cached value.
  - - (): Promise<T>
    - Returns Promise<T>
Returns Promise<T>

Const cacheForSync

cacheForSync<T>(__namedParameters: CacheForOptions, generator: () => T): T

- Defined in functions/cache-for.ts:68
A crude caching system that will cache values for the given time.

Type parameters
- T
Parameters
- __namedParameters: CacheForOptions
- generator: () => T
  
  The function that returns the cached value.
  - - (): T
    - Returns T
Returns T

Const cacheKey

cacheKey<T>(key: string, generator: () => T): T

- Defined in functions/cache-for.ts:31
Cache the given value in the supplied key if the key doesn't already exist.

Type parameters
- T
Parameters
- key: string
  
  The key to store.
- generator: () => T
  - - (): T
    - Returns T
Returns T

Const cacheKeyExists

cacheKeyExists(key: string): boolean

- Defined in functions/cache-for.ts:21
Does the supplied key exist in the cache?

Parameters
- key: string
  
  Key to check.
Returns boolean

Const createMap

createMap<T>(maxX: number, maxY: number, initialValue: T, minX?: number, minY?: number): Map<T>

- Defined in functions/create-map.ts:27
Create a co-ordinate grid

Type parameters
- T
Parameters
- maxX: number
  
  The maximum X value.
- maxY: number
  
  The maximum Y value.
- initialValue: T
  
  THe default value for all cells.
- minX: number = 0
  
  (Optional) The minimum X value, defaults to 0
- minY: number = 0
  
  (Optional) The minimum Y value, defaults to 0
Returns Map<T>

Const deepIncludesArray

deepIncludesArray<T>(array: T[], compare: T): boolean

- Defined in functions/deep-includes.ts:10
Check if an array exists inside an array

Type parameters
- T: any[]
Parameters
- array: T[]
  
  The arraay of arrays to check
- compare: T
  
  The array to check for existance of
Returns boolean

true id the exact array matches, false if not.

Const defaults

defaults<T>(supplied: undefined | DeepPartial<T>, defaultValues: T): T

- Defined in functions/defaults.ts:9
Deeply applies defaults to an object.

Type parameters
- T: {}
Parameters
- supplied: undefined | DeepPartial<T>
  
  The supplied options, a DeepPartial of defaultValues.
- defaultValues: T
  
  The default values to fallback on. Should represent a full copy of the options object.
Returns T

Const diffArray

diffArray<T>(original: T[], compare: T[]): { additional: T[]; missing: T[] }

- Defined in functions/diff-array.ts:7
Returns an object with 2 parameters. additional which is elements in compare that are not in original, and missing which are elements in original that are not in compare

Type parameters
- T
Parameters
- original: T[]
  
  The base array to compare against
- compare: T[]
  
  The array to compare to
Returns { additional: T[]; missing: T[] }
- additional: T[]
- missing: T[]

Const diffObject

diffObject<T, K>(original: T, compare: K): DiffObjectResult<T, K>

- Defined in functions/diff-object.ts:7
Type parameters
- T: {}
- K: {}
Parameters
- original: T
- compare: K
Returns DiffObjectResult<T, K>

Const emToNumber

emToNumber(unit: string): number

- Defined in functions/css.ts:30
Convert em number to a plain number

Parameters
- unit: string
Returns number

Const expireKey

expireKey(key: string): void

- Defined in functions/cache-for.ts:44
Delete the supplied key from the cache.

Parameters
- key: string
  
  Key to delete.
Returns void

Const groupedBy

groupedBy<T, K>(key: K, array: T[]): GroupedArray<T>

- Defined in functions/grouped-by.ts:11
Takes an array of objects and returns an object with a property for each value in the key containing an array of all the objects that have that value.

Type parameters
- T: {}
- K: string | number | symbol
Parameters
- key: K
  
  The key to group by.
- array: T[]
  
  The array of objects.
Returns GroupedArray<T>

Const hoursInMinutes

hoursInMinutes(value: number): number

- Defined in functions/time.ts:64
Parameters
- value: number
Returns number

Const hoursInMs

hoursInMs(value: number): number

- Defined in functions/time.ts:55
Parameters
- value: number
Returns number

Const hoursInSeconds

hoursInSeconds(value: number): number

- Defined in functions/time.ts:60
Parameters
- value: number
Returns number

Const indexedBy

indexedBy<T, K>(key: K, array: T[], options?: Partial<IndexedByOptions>): IndexedArray<T>

- Defined in functions/indexed-by.ts:22
Returns an object indexed by the given field from the array of objects.

Type parameters
- T: {}
- K: string | number | symbol
Parameters
- key: K
  
  The key to index by.
- array: T[]
  
  The array of Objects.
- options: Partial<IndexedByOptions> = {}
  
  See IndexedByOptions
Returns IndexedArray<T>

Const keys

keys<T>(object: T): keyof T[]

- Defined in functions/keys.ts:6
Returns an array of keys that matches the type keyof T

Type parameters
- T: {}
Parameters
- object: T
  
  Any object.
Returns keyof T[]

Const mapProperty

mapProperty<T, K>(array: T[], property: K): T[K][]

- Defined in functions/map-property.ts:7
Takes an array of objects and returns an array of values from the given property

Type parameters
- T
- K: string | number | symbol
Parameters
- array: T[]
  
  The array of objects
- property: K
  
  The property to extract
Returns T[K][]

Const minutesAsHours

minutesAsHours(value: number): number

- Defined in functions/time.ts:53
Parameters
- value: number
Returns number

Const minutesInMs

minutesInMs(value: number): number

- Defined in functions/time.ts:48
Parameters
- value: number
Returns number

Const minutesInSeconds

minutesInSeconds(value: number): number

- Defined in functions/time.ts:52
Parameters
- value: number
Returns number

Const msAsHour

msAsHour(value: number): number

- Defined in functions/time.ts:35
Parameters
- value: number
Returns number

Const msAsMinutes

msAsMinutes(value: number): number

- Defined in functions/time.ts:31
Parameters
- value: number
Returns number

Const msAsSeconds

msAsSeconds(value: number): number

- Defined in functions/time.ts:30
Parameters
- value: number
Returns number

Const nl2br

nl2br(string: string): string

- Defined in functions/nl2br.ts:6
Adds
for new lines in a string

Parameters
- string: string
  
  The multi line string to add
  tags to
Returns string

Const numberToEm

numberToEm(value: number): string

- Defined in functions/css.ts:41
Conver a number to em

Parameters
- value: number
Returns string

Const numberToPx

numberToPx(value: number): string

- Defined in functions/css.ts:39
Conver a number to px

Parameters
- value: number
Returns string

Const numberToRem

numberToRem(value: number): string

- Defined in functions/css.ts:43
Conver a number to rem

Parameters
- value: number
Returns string

Const numberToVh

numberToVh(value: number): string

- Defined in functions/css.ts:45
Conver a number to vh

Parameters
- value: number
Returns string

Const numberToVw

numberToVw(value: number): string

- Defined in functions/css.ts:47
Conver a number to vw

Parameters
- value: number
Returns string

Const omit

omit<T, K, P>(object: T, fields: K): Omit<T, P>

- Defined in functions/pick.ts:35
Pragmatic version of Typescripts Omit<Object, Fields>

Type parameters
- T: {}
- K: keyof T[]
- P: string | number | symbol
Parameters
- object: T
  
  The object to omit fields from.
- fields: K
  
  The fields to omit.
Returns Omit<T, P>

An object without the supplied fields.

Const parameterize

parameterize(slug: string): string

- Defined in functions/parameterize.ts:8
Takes a string and makes it safe for url slugs.

For Example: My Article's title becomes my-articles-title

Parameters
- slug: string
  
  The string to parameterize
Returns string

Const pick

pick<T, K, P>(object: T, fields: K): Pick<T, P>

- Defined in functions/pick.ts:11
Pragmatic version of Typescripts `Pick<Object, Fields>

Type parameters
- T: {}
- K: keyof T[]
- P: string | number | symbol
Parameters
- object: T
  
  The Object to pick fields from.
- fields: K
  
  An array of fields to pick,
Returns Pick<T, P>

An object with the picked fields.

Const propIs

propIs<T, K>(items: T[], prop: K, value: T[K]): T[]

- Defined in functions/selectors.ts:8
Find all entires in an array where prop equals value.

Type parameters
- T
- K: string | number | symbol
Parameters
- items: T[]
  
  The Items to filter
- prop: K
  
  The property to filter
- value: T[K]
  
  The value to check for
Returns T[]

Const propIsNot

propIsNot<T, K>(items: T[], prop: K, value: T[K]): T[]

- Defined in functions/selectors.ts:25
Find all entires in an array where prop does not equals value.

Type parameters
- T
- K: string | number | symbol
Parameters
- items: T[]
  
  The Items to filter
- prop: K
  
  The property to filter
- value: T[K]
  
  The value to check for
Returns T[]

Const pxToNumber

pxToNumber(unit: string): number

- Defined in functions/css.ts:28
Convert px number to a plain number

Parameters
- unit: string
Returns number

Const rangeAsArray

rangeAsArray(range: number[]): [number, number][]

- Defined in functions/range-as-string.ts:8
Returns an array of ranges

e.g. [[1,3], [5,6], [10,15], [20,20]]

Parameters
- range: number[]
  
  An array of integers to describe
Returns [number, number][]

Const rangeAsString

rangeAsString(integers: number[]): string[]

- Defined in functions/range-as-string.ts:42
Returns an array of string describing the range.

e.g. ['1-3','5,6','10-15','20']

Parameters
- integers: number[]
Returns string[]

Const reduceFalsy

reduceFalsy<T>(array: T[], check: (entry: T, i: number) => boolean): boolean

- Defined in functions/reduce.ts:30
Reduce the array into a single boolean value for if the check function returns false.

once the first true is encountered check is not run again

Type parameters
- T
Parameters
- array: T[]
  
  The array to test
- check: (entry: T, i: number) => boolean
  
  The function to check the array entries with
  - - (entry: T, i: number): boolean
    - Parameters
      - entry: T
      - i: number
      Returns boolean
Returns boolean

true if check only ever returned false, otherwise false

Const reduceTruthy

reduceTruthy<T>(array: T[], check: (entry: T, i: number) => boolean): boolean

- Defined in functions/reduce.ts:10
Reduce the array into a single boolean value for if the check function returns true.

once the first false is encountered check is not run again

Type parameters
- T
Parameters
- array: T[]
  
  The array to test
- check: (entry: T, i: number) => boolean
  
  The function to check the array entries with
  - - (entry: T, i: number): boolean
    - Parameters
      - entry: T
      - i: number
      Returns boolean
Returns boolean

true if check only ever returned true, otherwise false

Const remToNumber

remToNumber(unit: string): number

- Defined in functions/css.ts:32
Convert rem number to a plain number

Parameters
- unit: string
Returns number

Const replaceProperty

replaceProperty<T, K, P>(object: T, property: K, replacer: (value: T[K]) => P): Omit<T, K> & {[ key in string | number | symbol]: P }

- Defined in functions/replace-property.ts:9
Replace a property on an objcet with a different type

Type parameters
- T: {}
- K: string | number | symbol
- P
Parameters
- object: T
  
  The object
- property: K
  
  The property to replace
- replacer: (value: T[K]) => P
  
  Function to take the value and return the new value
  - - (value: T[K]): P
    - Parameters
      - value: T[K]
      Returns P
Returns Omit<T, K> & {[ key in string | number | symbol]: P }

An object with the property replaced

Const resetCache

resetCache(): void

- Defined in functions/cache-for.ts:52
Removes all keys from the cache.

Returns void

Const secondsAsHours

secondsAsHours(value: number): number

- Defined in functions/time.ts:43
Parameters
- value: number
Returns number

Const secondsAsMinutes

secondsAsMinutes(value: number): number

- Defined in functions/time.ts:42
Parameters
- value: number
Returns number

Const secondsInMs

secondsInMs(value: number): number

- Defined in functions/time.ts:41
Parameters
- value: number
Returns number

Const times

times<T>(number: number, cb: (i: number) => T): T[]

- Defined in functions/times.ts:9
Repeat the given function number times

Type parameters
- T
Parameters
- number: number
  
  The number of times to itterate
- cb: (i: number) => T
  
  The function to run
  - - (i: number): T
    - Parameters
      - i: number
      Returns T
Returns T[]

Const unique

unique<T>(array: T[]): T[]

- Defined in functions/unique.ts:6
Returns an array of unique values from the given array.

Type parameters
- T
Parameters
- array: T[]
  
  Array of values.
Returns T[]

Const valueOr

valueOr<T>(value: undefined | T, or: T): T

- Defined in functions/value-or.ts:7
Returns the supplied value if it is not undefined otherwise it returns the or value.

Type parameters
- T
Parameters
- value: undefined | T
  
  The Value that could be undefined
- or: T
  
  The fallback value
Returns T

Const vhToNumber

vhToNumber(unit: string): number

- Defined in functions/css.ts:34
Convert vh number to a plain number

Parameters
- unit: string
Returns number

Const vwToNumber

vwToNumber(unit: string): number

- Defined in functions/css.ts:36
Convert vw number to a plain number

Parameters
- unit: string
Returns number

Const waitFor

waitFor<T>(promise: Promise<T>): Promise<WaitForResult<T>>

- Defined in functions/wait-for.ts:8
Normalises a promise that errors into an awaitable [result, error] array.

Type parameters
- T
Parameters
- promise: Promise<T>
  
  The resolveable promise
Returns Promise<WaitForResult<T>>

Index

Classes

Interfaces

Type aliases

Variables

Functions

Type aliases

ArrayElement

Type parameters

ArrayType: readonly unknown[]

DeepPartial

Type parameters

T

Variables

Const HOUR_IN_MINUTES

Const HOUR_IN_MS

Const HOUR_IN_SECONDS

Const MINUTE_IN_MS

Const MINUTE_IN_SECONDS

Const SECOND_IN_MS

Functions

Const asyncForEach

Type parameters

T

Parameters

array: T[]

itterator: (value: T, index: number, array: T[]) => Promise<void>

Parameters

value: T

index: number

array: T[]

Returns Promise<void>

Optional options: DeepPartial<AsyncForEachOptions>

Returns Promise<void>

Const asyncMap

Type parameters

T

K

Parameters

list: T[]

executor: (element: T, index: number, array: T[]) => Promise<K>

Parameters

element: T

index: number

array: T[]

Returns Promise<K>

Returns Promise<K[]>

Const asyncTimes

Type parameters

T

Parameters

number: number

cb: (i: number) => Promise<T>

Parameters

i: number

Returns Promise<T>

Returns Promise<T[]>

Const cacheFor

Type parameters

T

Parameters

__namedParameters: CacheForOptions

generator: () => Promise<T>

Returns Promise<T>

Returns Promise<T>

Const cacheForSync

Type parameters

T

Parameters

__namedParameters: CacheForOptions

generator: () => T

Returns T

Returns T

Const cacheKey

Type parameters

T

Parameters

key: string

generator: () => T

Returns T