lutils

✓ TypesSript documented

• merge for deep merging of objects
• clone for deep cloning of objects & arrays
• typeOf for consistant type checking

import { typeOf, merge, clone } from 'lutils'

• See: CHANGELOG.md

---

merge

Merge objects together, traversing objects & arrays recursively

• merge(subject, ...sources[]) => subject
• Default depth: 10

import { merge } from 'lutils'
 
merge({ aa: { cc: 1 }, }, { aa: { cc: 2 } }, { bb: 3 })
=== { aa: { cc: 2 }, bb: 3 }

---

Construct & configure your own Merge instance

• new Merge(config).merge
• See: config

import { Merge } from 'lutils'
 
const merge = new Merge({ depth: Infinity }).merge
 
merge(megaDeep, ultraDeep)

---

Merge, but with two common behaviours, whitelisting and blacklisting

• merge.white(subject, ...sources[]) => subject
• merge.black(subject, ...sources[]) => subject

import { merge } from 'lutils'
 
merge.white({ aa: { bb: 1, cc: 1 } }, { aa: { xx: 2, cc: 2 } })
=== { aa: { bb: 1, cc: 2 } }
 
merge.black({ aa: { bb: 1, cc: 1 } }, { aa: { xx: 2, cc: 2 } })
=== { aa: { bb: 1, cc: 1, xx: 2 } }

---

clone

Clones objects & arrays recursively

• clone(subject) => clonedSubject
• Default depth: 10

import { clone } from 'lutils'
 
const cloned = clone({ my: { little: { foo: 'bar' } } })

• new Clone(config).clone
• See: config

import { Clone } from 'lutils'
 
const clone = new Clone({ depth: Infinity }).clone
 
const cloned = clone({ my: { little: { foo: 'bar' } } })

---

typeOf

Gets the type of a value as a lowercase string.
Like the built-in typeof, but works for all primitives.

• typeOf(value) => string

import { typeOf } from 'lutils'
 
typeOf(null)
=== 'null'
 
typeOf(NaN)
=== 'nan'
 
typeOf([])
=== 'array'

---

Specific type checkers are also exported and attached to typeOf
These checkers also supply typescript with type information, meaning they can act a type guards.

• isBoolean(value) => boolean
• is<type>(value) => boolean
• See: ITypeOf

import { typeOf, isBoolean, isString } from 'lutils'
 
typeOf.isNull(null)
=== true
 
isString(undefined)
=== false
 
typeOf.isString('')
=== true
 
isBoolean(false)
=== true
 
// Type guarding...
 
function blah (aa: number|string) {
  if (isString(aa)) {
    // string
    aa += '!!!!'
  } else {
    // number
    ++aa 
  }
 
  return aa
}