Utils

Index

Classes

Interfaces

Type aliases

Functions

Object literals

defaultOptions

Type aliases

ArrayElement

ArrayElement<ArrayType>: ArrayType[number]

Type parameters

ArrayType: readonly unknown[]

DeepPartial

DeepPartial<T>: {}

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

Type parameters

Type declaration

WaitForResult

WaitForResult<T>: [T, null] | [null, Error]

Type parameters

Variables

Const HOUR_IN_MINUTES

HOUR_IN_MINUTES: 60 = 60

Const HOUR_IN_MS

HOUR_IN_MS: number = HOUR_IN_SECONDS * SECOND_IN_MS

Const HOUR_IN_SECONDS

HOUR_IN_SECONDS: number = HOUR_IN_MINUTES * MINUTE_IN_SECONDS

Const MINUTE_IN_MS

MINUTE_IN_MS: number = MINUTE_IN_SECONDS * SECOND_IN_MS

Const MINUTE_IN_SECONDS

MINUTE_IN_SECONDS: 60 = 60

Const SECOND_IN_MS

SECOND_IN_MS: 1000 = 1000

Const cache

cache: {}

Type declaration

[key: string]: any

Const emToNumber

emToNumber: (Anonymous function) = asNumber(/^([0-9\.]*?)em$/)

Convert em number to a plain number

Const hoursInMinutes

hoursInMinutes: (Anonymous function) = multiplyBy(HOUR_IN_MINUTES)

Const hoursInMs

hoursInMs: (Anonymous function) = chain(multiplyBy(HOUR_IN_MINUTES), multiplyBy(MINUTE_IN_SECONDS), multiplyBy(SECOND_IN_MS))

Const hoursInSeconds

hoursInSeconds: (Anonymous function) = chain(multiplyBy(HOUR_IN_MINUTES), multiplyBy(MINUTE_IN_SECONDS))

Const minutesAsHours

minutesAsHours: (Anonymous function) = divideBy(HOUR_IN_MINUTES)

Const minutesInMs

minutesInMs: (Anonymous function) = chain(multiplyBy(MINUTE_IN_SECONDS), multiplyBy(SECOND_IN_MS))

Const minutesInSeconds

minutesInSeconds: (Anonymous function) = multiplyBy(MINUTE_IN_SECONDS)

Const msAsHour

msAsHour: (Anonymous function) = chain(divideBy(SECOND_IN_MS), divideBy(MINUTE_IN_SECONDS), divideBy(HOUR_IN_MINUTES))

Const msAsMinutes

msAsMinutes: (Anonymous function) = chain(divideBy(SECOND_IN_MS), divideBy(MINUTE_IN_SECONDS))

Const msAsSeconds

msAsSeconds: (Anonymous function) = divideBy(SECOND_IN_MS)

Const numberToEm

numberToEm: (Anonymous function) = asUnit('em')

Conver a number to em

Const numberToPx

numberToPx: (Anonymous function) = asUnit('px')

Conver a number to px

Const numberToRem

numberToRem: (Anonymous function) = asUnit('rem')

Conver a number to rem

Const numberToVh

numberToVh: (Anonymous function) = asUnit('vh')

Conver a number to vh

Const numberToVw

numberToVw: (Anonymous function) = asUnit('vw')

Conver a number to vw

Const pxToNumber

pxToNumber: (Anonymous function) = asNumber(/^([0-9\.]*?)px$/)

Convert px number to a plain number

Const remToNumber

remToNumber: (Anonymous function) = asNumber(/^([0-9\.]*?)rem$/)

Convert rem number to a plain number

Const secondsAsHours

secondsAsHours: (Anonymous function) = chain(divideBy(MINUTE_IN_SECONDS), divideBy(HOUR_IN_MINUTES))

Const secondsAsMinutes

secondsAsMinutes: (Anonymous function) = divideBy(MINUTE_IN_SECONDS)

Const secondsInMs

secondsInMs: (Anonymous function) = multiplyBy(SECOND_IN_MS)

Const vhToNumber

vhToNumber: (Anonymous function) = asNumber(/^([0-9\.]*?)vh$/)

Convert vh number to a plain number

Const vwToNumber

vwToNumber: (Anonymous function) = asNumber(/^([0-9\.]*?)vw$/)

Convert vw number to a plain number

Functions

Const asNumber

asNumber(regex: RegExp): (Anonymous function)

- Defined in functions/css.ts:6
Creates a function that turns 1unit into 1

Parameters
- regex: RegExp
  
  The regex to remove the unit e.g. /^([0-9\.]*?)px$/
Returns (Anonymous function)

Const asUnit

asUnit(unit: string): (Anonymous function)

- Defined in functions/css.ts:21
Creates a function to add a unit to the number.

Parameters
- unit: string
  
  The unit to append.
Returns (Anonymous function)

Const asyncForEach

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

- Defined in functions/async-for-each.ts:7
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>
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:22
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: { duration: number; key: string }, generator: () => Promise<T>): Promise<T>

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

Type parameters
- T
Parameters
- __namedParameters: { duration: number; key: string }
  - duration: number
  - key: string
- generator: () => Promise<T>
  
  The promise function that returns the cached value.
  - - (): Promise<T>
    - Returns Promise<T>
Returns Promise<T>

Const cacheForSync

cacheForSync<T>(__namedParameters: { duration: number; key: string }, generator: () => T): T

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

Type parameters
- T
Parameters
- __namedParameters: { duration: number; key: string }
  - duration: number
  - key: string
- 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:62
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:52
Does the supplied key exist in the cache?

Parameters
- key: string
  
  Key to check.
Returns boolean

Const chain

chain(...actions: ((v: number) => number)[]): (Anonymous function)

- Defined in functions/time.ts:13
Parameters
- Rest ...actions: ((v: number) => number)[]
Returns (Anonymous function)

Const createMap

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

- Defined in functions/create-map.ts:21
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.
- Default value minX: number = 0
  
  (Optional) The minimum X value, defaults to 0
- Default value minY: number = 0
  
  (Optional) The minimum Y value, defaults to 0
Returns Map<T>

Const defaults

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

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

Type parameters
- T: {}
Parameters
- supplied: 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 divideBy

divideBy(factor: number): (Anonymous function)

- Defined in functions/time.ts:7
Parameters
- factor: number
Returns (Anonymous function)

Const expireKey

expireKey(key: string): void

- Defined in functions/cache-for.ts:75
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: keyof T
Parameters
- key: K
  
  The key to group by.
- array: T[]
  
  The array of objects.
Returns GroupedArray<T>

Const indexedBy

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

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

Type parameters
- T: {}
- K: keyof T
Parameters
- key: K
  
  The key to index by.
- array: T[]
  
  The array of Objects.
- Optional 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: keyof T
Parameters
- array: T[]
  
  The array of objects
- property: K
  
  The property to extract
Returns T[K][]

Const multiplyBy

multiplyBy(factor: number): (Anonymous function)

- Defined in functions/time.ts:1
Parameters
- factor: number
Returns (Anonymous function)

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 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:3
Type parameters
- T: {}
- K: keyof T[]
- P: ArrayElement<K>
Parameters
- object: T
- fields: K
Returns Pick<T, P>

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: keyof T
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:21
Find all entires in an array where prop does not equals value.

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

Const rangeAsArray

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

- Defined in functions/range-as-string.ts:25
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(range: number[]): string[]

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

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

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

Const resetCache

resetCache(): void

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

Returns void

Const times

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

- Defined in functions/times.ts:7
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 valueOr

valueOr<T>(value: T | undefined, 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: T | undefined
  
  The Value that could be undefined
- or: T
  
  The fallback value
Returns T

Const waitFor

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

- Defined in functions/wait-for.ts:10
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

Object literals

Type aliases

ArrayElement

Type parameters

ArrayType: readonly unknown[]

DeepPartial

Type parameters

T

Type declaration

WaitForResult

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

Const cache

Type declaration

[key: string]: any

Const emToNumber

Const hoursInMinutes

Const hoursInMs

Const hoursInSeconds

Const minutesAsHours

Const minutesInMs

Const minutesInSeconds

Const msAsHour

Const msAsMinutes

Const msAsSeconds

Const numberToEm

Const numberToPx

Const numberToRem

Const numberToVh

Const numberToVw

Const pxToNumber

Const remToNumber

Const secondsAsHours

Const secondsAsMinutes

Const secondsInMs

Const vhToNumber

Const vwToNumber

Functions

Const asNumber

Parameters

regex: RegExp

Returns (Anonymous function)

Const asUnit

Parameters

unit: string

Returns (Anonymous function)

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>

Returns Promise<void>

Const asyncMap

Type parameters

T

K

Parameters

list: T[]

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

Parameters

element: T