Newts Parading Majestically

    lutils
    TypeScript icon, indicating that this package has built-in type declarations

    2.4.0 • Public • Published
     

    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'

    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
    }

    Install

    npm i lutils

    DownloadsWeekly Downloads

    3,945

    Version

    2.4.0

    License

    none

    Last publish

    Collaborators

    • nfour