Function deepMapInternal

tfjs-data/src/util/deep_map.ts:62–106

* @param seen: A Map of known object mappings (i.e., memoized results of * `mapFn()`) * @param containedIn: An set containing objects on the reference path currently * being processed (used to detect cycles).

(
    input: any, mapFn: (x: any) => DeepMapResult,
    seen: Map<any, any> = new Map(), containedIn: Set<{}> = new Set())

 *   being processed (used to detect cycles).
 */
function deepMapInternal(
    input: any, mapFn: (x: any) => DeepMapResult,
    seen: Map<any, any> = new Map(), containedIn: Set<{}> = new Set()): any|
    any[] {
  if (input == null) {
    return null;
  }
  if (typeof Blob === 'function' && input instanceof Blob) {
    return input.slice();
  }

  if (containedIn.has(input)) {
    throw new Error('Circular references are not supported.');
  }
  if (seen.has(input)) {
    return seen.get(input);
  }
  const result = mapFn(input);

  if (result.recurse && result.value !== null) {
    throw new Error(
        'A deep map function may not return both a value and recurse=true.');
  }

  if (!result.recurse) {
    seen.set(input, result.value);
    return result.value;
  } else if (isIterable(input)) {
    // tslint:disable-next-line:no-any
    const mappedIterable: any|any[] = Array.isArray(input) ? [] : {};
    containedIn.add(input);
    for (const k in input) {
      const child = input[k];
      const childResult = deepMapInternal(child, mapFn, seen, containedIn);
      mappedIterable[k] = childResult;
    }
    containedIn.delete(input);
    if (input.__proto__) {
      mappedIterable.__proto__ = input.__proto__;
    }
    return mappedIterable;
  } else {
    throw new Error(`Can't recurse into non-iterable type: ${input}`);
  }
}

// TODO(soergel, kangyizhang) Reconsider naming of deepZip() to avoid confusion
// with zip()