emrioutils
Options
All
  • Public
  • Public/Protected
  • All
Menu

emrioutils npm version license

Site | Changelog | Github | NPM | Docs

Installing

Downloading from NPM

$ npm i emrioutils --save

Then, in JavaScript:

const u = require('emrioutils')

or in Typescript/ES6

import u from 'emrioutils'

or

import u = require('emrioutils')

List of untested functions
  • arr2obj
  • arr2objmap
  • binarySearch
  • binarySearchIndex
  • filterObj
  • hop
  • iterkv
  • makeShallowCopy
  • mapKey
  • mergekv
  • pourkv
  • rand
  • randstring
  • randUniqueList
  • resolveObjectProperty
  • rmfast
  • split

Notes

This project is intended for a personal use only. Future versions may include breaking changes if they fit my needs. Nonetheless feel free to use or fork the project.

Feel free to post some suggestions and/or questions in the Issues Page

Index

References

Namespaces

Classes

Type aliases

Variables

Functions

References

access

Re-exports access

appendFile

Re-exports appendFile

mkdir

Re-exports mkdir

readFile

Re-exports readFile

readdir

Re-exports readdir

rmdir

Re-exports rmdir

stat

Re-exports stat

unlink

Re-exports unlink

writeFile

Re-exports writeFile

Type aliases

CollisionResolver

CollisionResolver<K, V>: (k: K, a: V, b: V) => V

Type parameters

  • K

  • V

Type declaration

    • (k: K, a: V, b: V): V

    • Parameters

      • k: K
      • a: V
      • b: V

      Returns V

Key

Key: number | symbol | string

Types that can be used as keys in a Record

NestedArray

NestedArray<T>: (T | NestedArray<T>)[]

Nested array type - array of array of array of ...

Type parameters

  • T

Unpack

Unpack<T>: T extends infer U[] ? U : T

Retrieve the type of an array

Type parameters

  • T

ValueOf

ValueOf<T>: T extends Record<Key, infer U> ? U : never

Type parameters

  • T

nOpt

nOpt<T>: T | null

T or null

Type parameters

  • T

nuOpt

nuOpt<T>: nOpt<T> | uOpt<T>

T or null or undefined

Type parameters

  • T

uOpt

uOpt<T>: T | undefined

T or undefined, equivalent to T?

Type parameters

  • T

Variables

Const base10

base10: "0123456789" = '0123456789'

Decimal base

Const base16

base16: "0123456789abcdef" = '0123456789abcdef'

Hexadecimal base

Const base2

base2: "01" = '01'

Binary base

Const base26

base26: "abcdefghijklmnopqrstuvwxyz" = 'abcdefghijklmnopqrstuvwxyz'

Lowercase latin alphabet

Const base52

base52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

Latin alphabet

Const base57

base57: "23456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ" = '23456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'

Alphanumeric base without any homoglyphs

Const base62

base62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

Alphanumeric alphabet

Const base64

base64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/" = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/'

Cananocial Base64

Const base64safe

base64safe: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_" = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_'

URI-safe Base64

Const base8

base8: "01234567" = '01234567'

Octal base

Const defaultSizes

defaultSizes: { enBandwidth: string[]; enStorage: string[]; frBandwidth: string[]; frStorage: string[] } = ...

Sizes for storage and bandwidth measurement in English and French

Type declaration

  • enBandwidth: string[]
  • enStorage: string[]
  • frBandwidth: string[]
  • frStorage: string[]

Functions

arr2obj

  • arr2obj<T, K>(arr: T[], mapper: (x: T, i: number) => K): Record<K, T>

  • Maps array elements to an object Mapper function returns the key value

    Type parameters

    Parameters

    • arr: T[]
    • mapper: (x: T, i: number) => K
        • (x: T, i: number): K

        • Parameters

          • x: T
          • i: number

          Returns K

    Returns Record<K, T>

arr2objmap

  • arr2objmap<T, K, V>(arr: T[], mapper: (x: T, i: number) => [K, V]): Record<K, V>

  • Maps array elements to an object Mapper function returns the key value and the value object

    Type parameters

    Parameters

    • arr: T[]
    • mapper: (x: T, i: number) => [K, V]
        • (x: T, i: number): [K, V]

        • Parameters

          • x: T
          • i: number

          Returns [K, V]

    Returns Record<K, V>

avg

  • avg(values: number[]): number

  • Gives the mean value of a list of numbers

    Parameters

    • values: number[]

    Returns number

binarySearch

  • binarySearch<T, TT>(arr: T[], x: TT, key?: Cast<T, TT>): boolean

  • Tests if given value is present is a sorted array

    Type parameters

    • T

    • TT

    Parameters

    • arr: T[]
    • x: TT
    • Optional key: Cast<T, TT>

    Returns boolean

binarySearchIndex

  • binarySearchIndex<T, TT>(arr: T[], x: TT, key?: Cast<T, TT>): number

  • Returns the index of an element in a sorted array Returns -1 if element does not exist in array

    Optionally takes a comparator function, more or less required if T is not string or number. This comparator should test if first argument is strictly greater than the second argument.

    Type parameters

    • T

    • TT

    Parameters

    • arr: T[]
    • x: TT
    • Optional key: Cast<T, TT>

    Returns number

cfl

  • cfl(str: string): string

  • Capitalize the first character of a string

    Parameters

    • str: string

    Returns string

createLinearTransform

  • createLinearTransform(source1: number, source2: number, dest1: number, dest2: number): (x: number) => number

  • Creates a function that transforms a vector from source1 to source2 into another vector from dest1 to dest2 in a linear fashion

    Parameters

    • source1: number
    • source2: number
    • dest1: number
    • dest2: number

    Returns (x: number) => number

      • (x: number): number

      • Creates a function that transforms a vector from source1 to source2 into another vector from dest1 to dest2 in a linear fashion

        Parameters

        • x: number

        Returns number

createLinearTransformND

  • createLinearTransformND(source1: number[], source2: number[], dest1: number[], dest2: number[]): (x: number[]) => number[]

  • N-dimensional version of createLinearTransform

    Parameters

    • source1: number[]
    • source2: number[]
    • dest1: number[]
    • dest2: number[]

    Returns (x: number[]) => number[]

      • (x: number[]): number[]

day

  • day(date?: Date): number

  • Get the day in a date (from 1 to 31*)

    Parameters

    • date: Date = ...

    Returns number

dayPad

  • dayPad(date?: Date): string

  • Get the day in a date (from '01' to '31'*)

    Parameters

    • date: Date = ...

    Returns string

ddmmyyyy

  • ddmmyyyy(separation?: string, date?: Date): string

  • Returns a custom string that represent the given date

    Parameters

    • separation: string = '-'
    • date: Date = ...

    Returns string

ddmmyyyyhhmm

  • ddmmyyyyhhmm(separation?: string, date?: Date): string

  • Returns a custom string that represent the given date

    Parameters

    • separation: string = '-'
    • date: Date = ...

    Returns string

ddmmyyyyhhmmss

  • ddmmyyyyhhmmss(separation?: string, date?: Date): string

  • Returns a custom string that represent the given date

    Parameters

    • separation: string = '-'
    • date: Date = ...

    Returns string

debug

  • debug(...debugIdentifiers: string[]): Debugger

  • Creates or retrieves a custom debugger class instance

    Parameters

    • Rest ...debugIdentifiers: string[]

    Returns Debugger

enumerate

  • enumerate<T>(arr: T[]): Generator<[number, T]>

  • TS implementation of Python's built-in enumerate function

    Type parameters

    • T

    Parameters

    • arr: T[]

    Returns Generator<[number, T]>

equal

  • equal(a: number, b: number, precision?: number): boolean

  • Tests if two numbers are equal within an error margin

    Parameters

    • a: number
    • b: number
    • precision: number = 1e-9

    Returns boolean

fileExists

  • fileExists(path: string): Promise<boolean>

  • Tests if a file exists

    Parameters

    • path: string

    Returns Promise<boolean>

filterObj

  • filterObj<K, V>(obj: Record<K, V>, filter: (k: K, v: V) => boolean): Record<K, V>

  • Takes a record and creates a new record by filtering its keys

    Type parameters

    Parameters

    • obj: Record<K, V>
    • filter: (k: K, v: V) => boolean
        • (k: K, v: V): boolean

        • Parameters

          • k: K
          • v: V

          Returns boolean

    Returns Record<K, V>

fitSize

  • fitSize(size: number, units?: string[]): { unit: string; value: number }

  • Returns the best size for a given raw size value

    Parameters

    • size: number
    • units: string[] = ...

    Returns { unit: string; value: number }

    • unit: string
    • value: number

flatten

  • flatten<T>(arr: NestedArray<T>, maxDepth?: number): T[]

  • Array.flat

    Type parameters

    • T

    Parameters

    Returns T[]

getSize

  • getSize(size: number, units?: string[]): string

  • Get a string representing the size best

    Parameters

    • size: number
    • units: string[] = ...

    Returns string

hhmm

  • hhmm(separation?: string, date?: Date): string

  • Returns a custom string that represent the given date

    Parameters

    • separation: string = '-'
    • date: Date = ...

    Returns string

hhmmss

  • hhmmss(separation?: string, date?: Date): string

  • Returns a custom string that represent the given date

    Parameters

    • separation: string = '-'
    • date: Date = ...

    Returns string

hop

  • hop<T>(obj: T, prop: Key): boolean

  • Shortcut for Object.prototype.hasOwnProperty.call

    Type parameters

    • T

    Parameters

    • obj: T
    • prop: Key

    Returns boolean

hour

  • hour(date?: Date): number

  • Get the hour in a date (from 0 to 23)

    Parameters

    • date: Date = ...

    Returns number

hourPad

  • hourPad(date?: Date): string

  • Get the hour in a date (from '00' to '23')

    Parameters

    • date: Date = ...

    Returns string

hr2ms

  • hr2ms(hrtime: [number, number]): number

  • Returns the time between now and an hrtime record with nanosecond precision and casted to millisecond

    Parameters

    • hrtime: [number, number]

    Returns number

id

  • id<T>(x: T): T

  • Identity function Handy shortcut for (x: T): T => T in Typescript

    Type parameters

    • T

    Parameters

    • x: T

    Returns T

inter

  • inter<T>(arr1: T[], arr2: T[]): T[]

  • Returns the elements that are present in both arrays

    Type parameters

    • T

    Parameters

    • arr1: T[]
    • arr2: T[]

    Returns T[]

isDir

  • isDir(path: string): Promise<boolean>

  • Tests if a file is a directory

    Parameters

    • path: string

    Returns Promise<boolean>

iterkv

  • iterkv<K, V>(obj: Record<K, V>): Generator<[K, V]>

  • Iterate through key/value pairs of an object

    Type parameters

    Parameters

    • obj: Record<K, V>

    Returns Generator<[K, V]>

last

  • last<T>(arr: T[], offset?: number): T

  • Returns the last element of an array. Optionally accepts an offset

    Type parameters

    • T

    Parameters

    • arr: T[]
    • offset: number = 0

    Returns T

makeShallowCopy

  • makeShallowCopy(target: Record<Key, unknown>, from: Record<Key, unknown>, replace?: boolean): void

  • Makes a shallow copy of the one object's properties to another. target and from objects won't have same reference but their properties, if they are objects, will have the same reference

    Parameters

    • target: Record<Key, unknown>
    • from: Record<Key, unknown>
    • replace: boolean = false

    Returns void

mapKey

  • mapKey<K, T, TT>(obj: Record<K, T>, f: (x: T, k: K, o: Record<K, T>) => TT): Record<K, TT>

  • Type parameters

    Parameters

    • obj: Record<K, T>
    • f: (x: T, k: K, o: Record<K, T>) => TT
        • (x: T, k: K, o: Record<K, T>): TT

        • Parameters

          • x: T
          • k: K
          • o: Record<K, T>

          Returns TT

    Returns Record<K, TT>

mergekv

  • mergekv<K, V>(onCollision: CollisionResolver<K, V>, ...src: Record<K, V>[]): Record<K, V>

  • Takes a list of records and merges them into another new record Collision are handled with the provided function

    Type parameters

    Parameters

    Returns Record<K, V>

minute

  • minute(date?: Date): number

  • Get the minute in a date (from 0 to 59)

    Parameters

    • date: Date = ...

    Returns number

minutePad

  • minutePad(date?: Date): string

  • Get the minute in a date (from '00' to '59')

    Parameters

    • date: Date = ...

    Returns string

month

  • month(date?: Date): number

  • Get the month in a date (from 1 to 12)

    Parameters

    • date: Date = ...

    Returns number

monthPad

  • monthPad(date?: Date): string

  • Get the month in a date (from '01' to '12')

    Parameters

    • date: Date = ...

    Returns string

n

  • n<T>(...sets: Set<T>[]): Set<T>

  • Intersection of sets

    Type parameters

    • T

    Parameters

    • Rest ...sets: Set<T>[]

    Returns Set<T>

nafum

  • nafum<T>(n: number, filler: (i: number) => T): T[]

  • Creates an array of n items with a custom filler Shortcut for new Array(n).fill(undefined).map(fillerFunction)

    Type parameters

    • T

    Parameters

    • n: number
    • filler: (i: number) => T
        • (i: number): T

        • Parameters

          • i: number

          Returns T

    Returns T[]

partition

  • partition<K, V>(arr: V[], partitioner: (x: V, i: number) => K): Record<K, V[]>

  • Split an array's elements

    Type parameters

    Parameters

    • arr: V[]
    • partitioner: (x: V, i: number) => K
        • (x: V, i: number): K

        • Parameters

          • x: V
          • i: number

          Returns K

    Returns Record<K, V[]>

pourkv

  • pourkv<K, V>(onCollision: CollisionResolver<K, V>, dst: Record<K, V>, ...src: Record<K, V>[]): void

  • Takes a list of records and pours their key-value pairs into another provided record. Takes a function for collision resolution when two objects have the same key

    Type parameters

    Parameters

    Returns void

rand

  • rand<T>(inputset: T[]): T

  • Returns a random element from a set This function is not cryptographically secure

    Type parameters

    • T

    Parameters

    • inputset: T[]

    Returns T

randUniqueList

  • randUniqueList<T>(rand: () => T, n: number, maxWithdraws?: number): T[]

  • Create a list of random values grabbed from a random function All values are unique

    Draws values from the random function until any of desired array length or maximum withdraws amount is reached

    For random functions that take parameters, please bind first

    Type parameters

    • T

    Parameters

    • rand: () => T
        • (): T

        • Returns T

    • n: number
    • maxWithdraws: number = ...

    Returns T[]

randfloat

  • randfloat(from: number, to: number): number

  • Returns a float number between two values This function is not cryptographically secure

    Parameters

    • from: number
    • to: number

    Returns number

randhex

  • randhex(from: number, to: number): string
  • randhex(length: number): string

  • Parameters

    • from: number
    • to: number

    Returns string

  • Parameters

    • length: number

    Returns string

randint

  • randint(from: number, to: number, includeTo?: boolean): number
  • randint(length: number, includeTo?: boolean): number

  • Parameters

    • from: number
    • to: number
    • Optional includeTo: boolean

    Returns number

  • Parameters

    • length: number
    • Optional includeTo: boolean

    Returns number

randstring

  • randstring(alphabet: string, length: number): string

  • Returns a string composed of characters in a provided alphabet Can return fixed length strings or random lengthed strings This function is not cryptographically secure

    Parameters

    • alphabet: string
    • length: number

    Returns string

range

  • range(to: number): Generator<number>
  • range(from: number, to: number, step: number): Generator<number>

  • TS implementation of Python's built-in range function

    Parameters

    • to: number

    Returns Generator<number>

  • Parameters

    • from: number
    • to: number
    • step: number

    Returns Generator<number>

replaceText

  • replaceText(t: string, w: {}, replaceAllOccurences?: boolean): string

  • In given text, replaces '{foo}' by the value of the property foo of the translation object. By default only replaces first occurence

    Parameters

    • t: string
    • w: {}
      • [k: string]: AllowedTypes
    • replaceAllOccurences: boolean = false

    Returns string

resolveObjectProperty

  • resolveObjectProperty<R, T>(obj: R, path: string[] | string, ensurePropertiesExist?: boolean): T

  • resolveObjectProperty - Returns the reference of an object sub property Also creates sub properties if they do not exist

    User should make sure paths exist or could exist on the object, else the function would throw somewhere.

    Type parameters

    • R: Record<Key, unknown>

    • T: unknown

    Parameters

    • obj: R
    • path: string[] | string
    • ensurePropertiesExist: boolean = false

    Returns T

rmfast

  • rmfast<T>(arr: T[], i: number): void

  • Removes an element of an array at a given index in constant time Order of elements is not conserved Does not require array to be sorted

    Type parameters

    • T

    Parameters

    • arr: T[]
    • i: number

    Returns void

round

  • round(x: number, n?: number): number

  • Rounds numbers with digits

    Parameters

    • x: number
    • n: number = 0

    Returns number

second

  • second(date?: Date): number

  • Get the second in a date (from 0 to 59)

    Parameters

    • date: Date = ...

    Returns number

secondPad

  • secondPad(date?: Date): string

  • Get the second in a date (from '00' to '59')

    Parameters

    • date: Date = ...

    Returns string

sleep

  • sleep(ms: number): Promise<void>

  • Resolves a promise after a given period of time

    Parameters

    • ms: number

    Returns Promise<void>

splice

  • splice(str: string, index: number, rem: number, str2: string): string

  • Array.splice but for String

    Parameters

    • str: string
    • index: number
    • rem: number
    • str2: string

    Returns string

split

  • split(str: string, delimitor: string, limit: number): string[]

  • Split function which returns the end of the string as an element of the array if limit is set

    Parameters

    • str: string
    • delimitor: string
    • limit: number

    Returns string[]

swap

  • swap<T>(arr: T[], i: number, j: number): void

  • Swap two elements in an array

    Type parameters

    • T

    Parameters

    • arr: T[]
    • i: number
    • j: number

    Returns void

u

  • u<T>(...sets: Set<T>[]): Set<T>

  • Union of sets

    Type parameters

    • T

    Parameters

    • Rest ...sets: Set<T>[]

    Returns Set<T>

unique

  • unique<T>(arr: T[]): T[]

  • Removes all duplicates elements in an array

    Type parameters

    • T

    Parameters

    • arr: T[]

    Returns T[]

voidDir

  • voidDir(dirpath: string, recursive?: boolean, deleteSubDirectories?: boolean): Promise<void>

  • Removes all files in a directory May do so recursively May also remove sub directories

    Parameters

    • dirpath: string
    • recursive: boolean = false
    • deleteSubDirectories: boolean = false

    Returns Promise<void>

year

  • year(date?: Date): number

  • Get the year in a date

    Parameters

    • date: Date = ...

    Returns number

yearPad

  • yearPad(date?: Date): string

  • Get the year in a date (from '0000' to '9999') Only works correctly with dates from year 0 to year 9999

    Parameters

    • date: Date = ...

    Returns string

yyyymmdd

  • yyyymmdd(separation?: string, date?: Date): string

  • Returns a custom string that represent the given date

    Parameters

    • separation: string = '-'
    • date: Date = ...

    Returns string

yyyymmddhhmm

  • yyyymmddhhmm(separation?: string, date?: Date): string

  • Returns a custom string that represent the given date

    Parameters

    • separation: string = '-'
    • date: Date = ...

    Returns string

yyyymmddhhmmss

  • yyyymmddhhmmss(separation?: string, date?: Date): string

  • Returns a custom string that represent the given date

    Parameters

    • separation: string = '-'
    • date: Date = ...

    Returns string

zip

  • zip<T>(...arrs: Unpack<T>[][]): Generator<T>

  • TS implementation of Python's built-in zip function

    Type parameters

    • T: unknown[]

    Parameters

    Returns Generator<T>

Legend

  • Constructor
  • Property

Generated using TypeDoc