Options
All
  • Public
  • Public/Protected
  • All
Menu

Module utils/object-utils

Index

Functions

Functions

createMergedObject

  • createMergedObject<T>(source: T, ...updates: Partial<T>[]): T

deepCopy

  • deepCopy<T>(source: T): T

deepEqual

  • deepEqual<T>(objA: T, objB: T): boolean

deepFreeze

  • deepFreeze<T>(o: T): T

getNestedProperty

  • getNestedProperty(object: any, propertyPath: string | string[], separator?: string): any

getObjectEntries

getOrSetProperty

  • getOrSetProperty<S, T>(obj: S, index: T, value: S[T]): S[T]

isNotInstance

  • isNotInstance<T>(value: T): boolean

isPlain

  • isPlain<T>(object: T): boolean

makeFlat

  • makeFlat<T>(list: T[], propertyPath: string, separator?: string, skipUndefined?: boolean): T[]
  • example
    const items = [
   {
       person: {
           name: "Gabriel"
       }
   },
   {
       person: {
           name: "Ella"
       }
   },
   {
       person: {
           name: "Gabriel"
       }
   },
   {
       person: {
           name: "Joe"
       }
   }
]

console.log(makeFlat(items), "person.name");
// ["Gabriel", "Ella", "Gabriel", "Joe"]
console.log(makeFlat(items), "person_name", "_");
// ["Gabriel", "Ella", "Gabriel", "Joe"]
console.log(makeFlat(items), "person.name", ".", true);
// ["Gabriel", "Ella", "Joe"]

    Type parameters

    • T

    Parameters

    • list: T[]

      data-structures to flat

    • propertyPath: string

      path to property

    • separator: string = "."

      separator in propertyPath

    • skipUndefined: boolean = false

      true if undefined should be skipped

    Returns T[]

roughSizeOfObject

  • roughSizeOfObject<T>(object: T): number

setNestedProperty

  • setNestedProperty<T>(item: any, key: string | string[], value: T): void

size

  • size<T>(object: T): number
  • deprecated

    use {@link Object.keys(object).length}

    Type parameters

    • T: unknown[] | Record<string, unknown>

    Parameters

    • object: T

    Returns number

toBoolean

  • toBoolean<T>(value: T): boolean

without

  • without<T>(obj: T, items: keyof T[]): Omit<T, any>

  • Type parameters

    • T: Record<string, unknown>

    Parameters

    • obj: T
    • items: keyof T[]

    Returns Omit<T, any>

Generated using TypeDoc