Function mapEntry

src/common/object.js:62–186

(fnValue, fnKey, thisObj)

 * @return {Object}
 */
export function mapEntry(fnValue, fnKey, thisObj) {
  const res = {};
  for (let key of Object.keys(this)) {
    const val = this[key];
    if (!fnKey || (key = thisObj::fnKey(key, val, this))) {
      res[key] = fnValue ? thisObj::fnValue(val, key, this) : val;
    }
  }
  return res;
}

// invoked as obj::forEachEntry(([key, value], i, allEntries) => {})
export function forEachEntry(func, thisObj) {
  if (this) Object.entries(this).forEach(func, thisObj);
}

// invoked as obj::forEachKey(key => {}, i, allKeys)
export function forEachKey(func, thisObj) {
  if (this) Object.keys(this).forEach(func, thisObj);
}

// invoked as obj::forEachValue(value => {}, i, allValues)
export function forEachValue(func, thisObj) {
  if (this) Object.values(this).forEach(func, thisObj);
}

export function deepCopy(src) {
  if (!src || typeof src !== 'object') return src;
  // Using a literal [] instead of `src.map(deepCopy)` to avoid src `window` leaking.
  // Using `concat` instead of `for` loop to preserve holes in the array.
  if (Array.isArray(src)) return [].concat(src).map(deepCopy);
  return src::mapEntry(deepCopy);
}

// Simplified deep equality checker
export function deepEqual(a, b) {
  let res;
  if (!a || !b || typeof a !== typeof b || typeof a !== 'object') {
    res = a === b;
  } else if (Array.isArray(a)) {
    res = a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));
  } else {
    const keysA = Object.keys(a);
    /* Not checking hasOwnProperty because 1) we only use own properties and
     * 2) this can be slow for a large value storage that has thousands of keys */
    res = keysA.length === Object.keys(b).length
      && keysA.every(key => deepEqual(a[key], b[key]));
  }
  return res;
}

/** @return {?} `undefined` if equal */
export function deepCopyDiff(src, sample) {
  if (src === sample) return;
  if (!src || typeof src !== 'object') return src;
  if (!sample || typeof sample !== 'object') return deepCopy(src);
  deepDiff = false;
  src = (Array.isArray(src) ? deepCopyDiffArrays : deepCopyDiffObjects)(src, sample);