@winged/core/src/utils.ts

Morden webapp framekwork made only for ts developers. (UNDER DEVELOPMENT, PLEASE DO NOT USE)

export namespace utils {
  export function listContains<T>(list: T[], item: T): boolean {
    return list.indexOf(item) !== -1
  }

  export function upperCamelToLowerCamel(str: string) {
    return str[0].toUpperCase() + str.slice(1)
  }

  /**
   * clone object
   * @param source source object
   * @param deepClone true for deep clone, false for 1 level clone
   */
  export function clone<T>(source: T, deepClone = false): T {
    if (source instanceof Array) {
      const res = []
      for (const item of source) {
        if (deepClone) {
          res.push(utils.clone(item), deepClone)
        } else {
          res.push(item)
        }
      }
      return res as any
    } else if (typeof source === 'object') {
      const res = {} as any
      for (const key in source) {
        if (deepClone) {
          res[key] = utils.clone(source[key], deepClone)
        } else {
          res[key] = source[key]
        }
      }
      return res
    } else {
      return source
    }
  }

  /**
   * convert a string into camelcase
   * any charactor followed a separator will be convert to uppercased letter,
   * otherwise convert to lowercased letter
   * @param key string to convert
   * @param separators list of separator, defauls to "-"/"_"
   */
  export function camelizeKey(key: string, separators: string[] = ['-', '_']): string {
    const out: any = []
    let i: number = 0
    while (i < key.length) {
      if (separators.indexOf(key[i]) > -1) {
        out.push(key[i + 1].toUpperCase())
        i++
      } else {
        out.push(key[i])
      }
      i++
    }
    return out.join('')
  }

  /**
   * convert all keys in an object recursivly using utils.camelizeKey
   * @param obj
   */
  export function camelize(obj: object): { [key: string]: any } {
    if (obj === null || obj === undefined) {
      return obj
    } else if (obj instanceof Array) {
      return obj.map((item) => {
        return utils.camelize(item)
      })
    } else if (typeof obj === 'object') {
      const out: any = {}
      for (const key in (obj as any)) {
        const v = (obj as any)[key]
        out[utils.camelizeKey(key)] = utils.camelize(v)
      }
      return out
    } else {
      return obj
    }
  }

  export function generateId() {
    // TODO: consider conflicts
    return Date.now().toString(36) + parseInt(Math.random() * 1000000 + '').toString(36)
  }

  export function isEmptyObject(object: any): boolean {
    for (const _ in object) {
      return false
    }
    return true
  }

  export function listToMap<T>(list: T[], hashKey?: keyof T) {
    const map: { [key: string]: true } = {}
    if (hashKey) {
      for (const item of list) {
        map[item[hashKey].toString()] = true
      }
    } else {
      for (const item of list) {
        map[item.toString()] = true
      }
    }
    return map
  }
}