@angular/core
Version:
Angular - the core framework
316 lines • 45.4 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { assertNotSame } from '../util/assert';
/**
* A type representing the live collection to be reconciled with any new (incoming) collection. This
* is an adapter class that makes it possible to work with different internal data structures,
* regardless of the actual values of the incoming collection.
*/
export class LiveCollection {
destroy(item) {
// noop by default
}
updateValue(index, value) {
// noop by default
}
// operations below could be implemented on top of the operations defined so far, but having
// them explicitly allow clear expression of intent and potentially more performant
// implementations
swap(index1, index2) {
const startIdx = Math.min(index1, index2);
const endIdx = Math.max(index1, index2);
const endItem = this.detach(endIdx);
if (endIdx - startIdx > 1) {
const startItem = this.detach(startIdx);
this.attach(startIdx, endItem);
this.attach(endIdx, startItem);
}
else {
this.attach(startIdx, endItem);
}
}
move(prevIndex, newIdx) {
this.attach(newIdx, this.detach(prevIndex));
}
}
function valuesMatching(liveIdx, liveValue, newIdx, newValue, trackBy) {
if (liveIdx === newIdx && Object.is(liveValue, newValue)) {
// matching and no value identity to update
return 1;
}
else if (Object.is(trackBy(liveIdx, liveValue), trackBy(newIdx, newValue))) {
// matching but requires value identity update
return -1;
}
return 0;
}
/**
* The live collection reconciliation algorithm that perform various in-place operations, so it
* reflects the content of the new (incoming) collection.
*
* The reconciliation algorithm has 2 code paths:
* - "fast" path that don't require any memory allocation;
* - "slow" path that requires additional memory allocation for intermediate data structures used to
* collect additional information about the live collection.
* It might happen that the algorithm switches between the two modes in question in a single
* reconciliation path - generally it tries to stay on the "fast" path as much as possible.
*
* The overall complexity of the algorithm is O(n + m) for speed and O(n) for memory (where n is the
* length of the live collection and m is the length of the incoming collection). Given the problem
* at hand the complexity / performance constraints makes it impossible to perform the absolute
* minimum of operation to reconcile the 2 collections. The algorithm makes different tradeoffs to
* stay within reasonable performance bounds and may apply sub-optimal number of operations in
* certain situations.
*
* @param liveCollection the current, live collection;
* @param newCollection the new, incoming collection;
* @param trackByFn key generation function that determines equality between items in the life and
* incoming collection;
*/
export function reconcile(liveCollection, newCollection, trackByFn) {
let detachedItems = undefined;
let liveKeysInTheFuture = undefined;
let liveStartIdx = 0;
let liveEndIdx = liveCollection.length - 1;
if (Array.isArray(newCollection)) {
let newEndIdx = newCollection.length - 1;
while (liveStartIdx <= liveEndIdx && liveStartIdx <= newEndIdx) {
// compare from the beginning
const liveStartValue = liveCollection.at(liveStartIdx);
const newStartValue = newCollection[liveStartIdx];
const isStartMatching = valuesMatching(liveStartIdx, liveStartValue, liveStartIdx, newStartValue, trackByFn);
if (isStartMatching !== 0) {
if (isStartMatching < 0) {
liveCollection.updateValue(liveStartIdx, newStartValue);
}
liveStartIdx++;
continue;
}
// compare from the end
// TODO(perf): do _all_ the matching from the end
const liveEndValue = liveCollection.at(liveEndIdx);
const newEndValue = newCollection[newEndIdx];
const isEndMatching = valuesMatching(liveEndIdx, liveEndValue, newEndIdx, newEndValue, trackByFn);
if (isEndMatching !== 0) {
if (isEndMatching < 0) {
liveCollection.updateValue(liveEndIdx, newEndValue);
}
liveEndIdx--;
newEndIdx--;
continue;
}
// Detect swap and moves:
const liveStartKey = trackByFn(liveStartIdx, liveStartValue);
const liveEndKey = trackByFn(liveEndIdx, liveEndValue);
const newStartKey = trackByFn(liveStartIdx, newStartValue);
if (Object.is(newStartKey, liveEndKey)) {
const newEndKey = trackByFn(newEndIdx, newEndValue);
// detect swap on both ends;
if (Object.is(newEndKey, liveStartKey)) {
liveCollection.swap(liveStartIdx, liveEndIdx);
liveCollection.updateValue(liveEndIdx, newEndValue);
newEndIdx--;
liveEndIdx--;
}
else {
// the new item is the same as the live item with the end pointer - this is a move forward
// to an earlier index;
liveCollection.move(liveEndIdx, liveStartIdx);
}
liveCollection.updateValue(liveStartIdx, newStartValue);
liveStartIdx++;
continue;
}
// Fallback to the slow path: we need to learn more about the content of the live and new
// collections.
detachedItems ??= new UniqueValueMultiKeyMap();
liveKeysInTheFuture ??=
initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx, trackByFn);
// Check if I'm inserting a previously detached item: if so, attach it here
if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newStartKey)) {
liveCollection.updateValue(liveStartIdx, newStartValue);
liveStartIdx++;
liveEndIdx++;
}
else if (!liveKeysInTheFuture.has(newStartKey)) {
// Check if we seen a new item that doesn't exist in the old collection and must be INSERTED
const newItem = liveCollection.create(liveStartIdx, newCollection[liveStartIdx]);
liveCollection.attach(liveStartIdx, newItem);
liveStartIdx++;
liveEndIdx++;
}
else {
// We know that the new item exists later on in old collection but we don't know its index
// and as the consequence can't move it (don't know where to find it). Detach the old item,
// hoping that it unlocks the fast path again.
detachedItems.set(liveStartKey, liveCollection.detach(liveStartIdx));
liveEndIdx--;
}
}
// Final cleanup steps:
// - more items in the new collection => insert
while (liveStartIdx <= newEndIdx) {
createOrAttach(liveCollection, detachedItems, trackByFn, liveStartIdx, newCollection[liveStartIdx]);
liveStartIdx++;
}
}
else if (newCollection != null) {
// iterable - immediately fallback to the slow path
const newCollectionIterator = newCollection[Symbol.iterator]();
let newIterationResult = newCollectionIterator.next();
while (!newIterationResult.done && liveStartIdx <= liveEndIdx) {
const liveValue = liveCollection.at(liveStartIdx);
const newValue = newIterationResult.value;
const isStartMatching = valuesMatching(liveStartIdx, liveValue, liveStartIdx, newValue, trackByFn);
if (isStartMatching !== 0) {
// found a match - move on, but update value
if (isStartMatching < 0) {
liveCollection.updateValue(liveStartIdx, newValue);
}
liveStartIdx++;
newIterationResult = newCollectionIterator.next();
}
else {
detachedItems ??= new UniqueValueMultiKeyMap();
liveKeysInTheFuture ??=
initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx, trackByFn);
// Check if I'm inserting a previously detached item: if so, attach it here
const newKey = trackByFn(liveStartIdx, newValue);
if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newKey)) {
liveCollection.updateValue(liveStartIdx, newValue);
liveStartIdx++;
liveEndIdx++;
newIterationResult = newCollectionIterator.next();
}
else if (!liveKeysInTheFuture.has(newKey)) {
liveCollection.attach(liveStartIdx, liveCollection.create(liveStartIdx, newValue));
liveStartIdx++;
liveEndIdx++;
newIterationResult = newCollectionIterator.next();
}
else {
// it is a move forward - detach the current item without advancing in collections
const liveKey = trackByFn(liveStartIdx, liveValue);
detachedItems.set(liveKey, liveCollection.detach(liveStartIdx));
liveEndIdx--;
}
}
}
// this is a new item as we run out of the items in the old collection - create or attach a
// previously detached one
while (!newIterationResult.done) {
createOrAttach(liveCollection, detachedItems, trackByFn, liveCollection.length, newIterationResult.value);
newIterationResult = newCollectionIterator.next();
}
}
// Cleanups common to the array and iterable:
// - more items in the live collection => delete starting from the end;
while (liveStartIdx <= liveEndIdx) {
liveCollection.destroy(liveCollection.detach(liveEndIdx--));
}
// - destroy items that were detached but never attached again.
detachedItems?.forEach(item => {
liveCollection.destroy(item);
});
}
function attachPreviouslyDetached(prevCollection, detachedItems, index, key) {
if (detachedItems !== undefined && detachedItems.has(key)) {
prevCollection.attach(index, detachedItems.get(key));
detachedItems.delete(key);
return true;
}
return false;
}
function createOrAttach(liveCollection, detachedItems, trackByFn, index, value) {
if (!attachPreviouslyDetached(liveCollection, detachedItems, index, trackByFn(index, value))) {
const newItem = liveCollection.create(index, value);
liveCollection.attach(index, newItem);
}
else {
liveCollection.updateValue(index, value);
}
}
function initLiveItemsInTheFuture(liveCollection, start, end, trackByFn) {
const keys = new Set();
for (let i = start; i <= end; i++) {
keys.add(trackByFn(i, liveCollection.at(i)));
}
return keys;
}
/**
* A specific, partial implementation of the Map interface with the following characteristics:
* - allows multiple values for a given key;
* - maintain FIFO order for multiple values corresponding to a given key;
* - assumes that all values are unique.
*
* The implementation aims at having the minimal overhead for cases where keys are _not_ duplicated
* (the most common case in the list reconciliation algorithm). To achieve this, the first value for
* a given key is stored in a regular map. Then, when more values are set for a given key, we
* maintain a form of linked list in a separate map. To maintain this linked list we assume that all
* values (in the entire collection) are unique.
*/
export class UniqueValueMultiKeyMap {
constructor() {
// A map from a key to the first value corresponding to this key.
this.kvMap = new Map();
// A map that acts as a linked list of values - each value maps to the next value in this "linked
// list" (this only works if values are unique). Allocated lazily to avoid memory consumption when
// there are no duplicated values.
this._vMap = undefined;
}
has(key) {
return this.kvMap.has(key);
}
delete(key) {
if (!this.has(key))
return false;
const value = this.kvMap.get(key);
if (this._vMap !== undefined && this._vMap.has(value)) {
this.kvMap.set(key, this._vMap.get(value));
this._vMap.delete(value);
}
else {
this.kvMap.delete(key);
}
return true;
}
get(key) {
return this.kvMap.get(key);
}
set(key, value) {
if (this.kvMap.has(key)) {
let prevValue = this.kvMap.get(key);
ngDevMode &&
assertNotSame(prevValue, value, `Detected a duplicated value ${value} for the key ${key}`);
if (this._vMap === undefined) {
this._vMap = new Map();
}
const vMap = this._vMap;
while (vMap.has(prevValue)) {
prevValue = vMap.get(prevValue);
}
vMap.set(prevValue, value);
}
else {
this.kvMap.set(key, value);
}
}
forEach(cb) {
for (let [key, value] of this.kvMap) {
cb(value, key);
if (this._vMap !== undefined) {
const vMap = this._vMap;
while (vMap.has(value)) {
value = vMap.get(value);
cb(value, key);
}
}
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list_reconciliation.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/list_reconciliation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {TrackByFunction} from '../change_detection';\nimport {assertNotSame} from '../util/assert';\n\n/**\n * A type representing the live collection to be reconciled with any new (incoming) collection. This\n * is an adapter class that makes it possible to work with different internal data structures,\n * regardless of the actual values of the incoming collection.\n */\nexport abstract class LiveCollection<T, V> {\n  abstract get length(): number;\n  abstract at(index: number): V;\n  abstract attach(index: number, item: T): void;\n  abstract detach(index: number): T;\n  abstract create(index: number, value: V): T;\n  destroy(item: T): void {\n    // noop by default\n  }\n  updateValue(index: number, value: V): void {\n    // noop by default\n  }\n\n  // operations below could be implemented on top of the operations defined so far, but having\n  // them explicitly allow clear expression of intent and potentially more performant\n  // implementations\n  swap(index1: number, index2: number): void {\n    const startIdx = Math.min(index1, index2);\n    const endIdx = Math.max(index1, index2);\n    const endItem = this.detach(endIdx);\n    if (endIdx - startIdx > 1) {\n      const startItem = this.detach(startIdx);\n      this.attach(startIdx, endItem);\n      this.attach(endIdx, startItem);\n    } else {\n      this.attach(startIdx, endItem);\n    }\n  }\n  move(prevIndex: number, newIdx: number): void {\n    this.attach(newIdx, this.detach(prevIndex));\n  }\n}\n\nfunction valuesMatching<V>(\n    liveIdx: number, liveValue: V, newIdx: number, newValue: V,\n    trackBy: TrackByFunction<V>): number {\n  if (liveIdx === newIdx && Object.is(liveValue, newValue)) {\n    // matching and no value identity to update\n    return 1;\n  } else if (Object.is(trackBy(liveIdx, liveValue), trackBy(newIdx, newValue))) {\n    // matching but requires value identity update\n    return -1;\n  }\n\n  return 0;\n}\n\n/**\n * The live collection reconciliation algorithm that perform various in-place operations, so it\n * reflects the content of the new (incoming) collection.\n *\n * The reconciliation algorithm has 2 code paths:\n * - \"fast\" path that don't require any memory allocation;\n * - \"slow\" path that requires additional memory allocation for intermediate data structures used to\n * collect additional information about the live collection.\n * It might happen that the algorithm switches between the two modes in question in a single\n * reconciliation path - generally it tries to stay on the \"fast\" path as much as possible.\n *\n * The overall complexity of the algorithm is O(n + m) for speed and O(n) for memory (where n is the\n * length of the live collection and m is the length of the incoming collection). Given the problem\n * at hand the complexity / performance constraints makes it impossible to perform the absolute\n * minimum of operation to reconcile the 2 collections. The algorithm makes different tradeoffs to\n * stay within reasonable performance bounds and may apply sub-optimal number of operations in\n * certain situations.\n *\n * @param liveCollection the current, live collection;\n * @param newCollection the new, incoming collection;\n * @param trackByFn key generation function that determines equality between items in the life and\n *     incoming collection;\n */\nexport function reconcile<T, V>(\n    liveCollection: LiveCollection<T, V>, newCollection: Iterable<V>|undefined|null,\n    trackByFn: TrackByFunction<V>): void {\n  let detachedItems: UniqueValueMultiKeyMap<unknown, T>|undefined = undefined;\n  let liveKeysInTheFuture: Set<unknown>|undefined = undefined;\n\n  let liveStartIdx = 0;\n  let liveEndIdx = liveCollection.length - 1;\n\n  if (Array.isArray(newCollection)) {\n    let newEndIdx = newCollection.length - 1;\n\n    while (liveStartIdx <= liveEndIdx && liveStartIdx <= newEndIdx) {\n      // compare from the beginning\n      const liveStartValue = liveCollection.at(liveStartIdx);\n      const newStartValue = newCollection[liveStartIdx];\n      const isStartMatching =\n          valuesMatching(liveStartIdx, liveStartValue, liveStartIdx, newStartValue, trackByFn);\n      if (isStartMatching !== 0) {\n        if (isStartMatching < 0) {\n          liveCollection.updateValue(liveStartIdx, newStartValue);\n        }\n        liveStartIdx++;\n        continue;\n      }\n\n      // compare from the end\n      // TODO(perf): do _all_ the matching from the end\n      const liveEndValue = liveCollection.at(liveEndIdx);\n      const newEndValue = newCollection[newEndIdx];\n      const isEndMatching =\n          valuesMatching(liveEndIdx, liveEndValue, newEndIdx, newEndValue, trackByFn);\n      if (isEndMatching !== 0) {\n        if (isEndMatching < 0) {\n          liveCollection.updateValue(liveEndIdx, newEndValue);\n        }\n        liveEndIdx--;\n        newEndIdx--;\n        continue;\n      }\n\n      // Detect swap and moves:\n      const liveStartKey = trackByFn(liveStartIdx, liveStartValue);\n      const liveEndKey = trackByFn(liveEndIdx, liveEndValue);\n      const newStartKey = trackByFn(liveStartIdx, newStartValue);\n      if (Object.is(newStartKey, liveEndKey)) {\n        const newEndKey = trackByFn(newEndIdx, newEndValue);\n        // detect swap on both ends;\n        if (Object.is(newEndKey, liveStartKey)) {\n          liveCollection.swap(liveStartIdx, liveEndIdx);\n          liveCollection.updateValue(liveEndIdx, newEndValue);\n          newEndIdx--;\n          liveEndIdx--;\n        } else {\n          // the new item is the same as the live item with the end pointer - this is a move forward\n          // to an earlier index;\n          liveCollection.move(liveEndIdx, liveStartIdx);\n        }\n        liveCollection.updateValue(liveStartIdx, newStartValue);\n        liveStartIdx++;\n        continue;\n      }\n\n      // Fallback to the slow path: we need to learn more about the content of the live and new\n      // collections.\n      detachedItems ??= new UniqueValueMultiKeyMap();\n      liveKeysInTheFuture ??=\n          initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx, trackByFn);\n\n      // Check if I'm inserting a previously detached item: if so, attach it here\n      if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newStartKey)) {\n        liveCollection.updateValue(liveStartIdx, newStartValue);\n        liveStartIdx++;\n        liveEndIdx++;\n      } else if (!liveKeysInTheFuture.has(newStartKey)) {\n        // Check if we seen a new item that doesn't exist in the old collection and must be INSERTED\n        const newItem = liveCollection.create(liveStartIdx, newCollection[liveStartIdx]);\n        liveCollection.attach(liveStartIdx, newItem);\n        liveStartIdx++;\n        liveEndIdx++;\n      } else {\n        // We know that the new item exists later on in old collection but we don't know its index\n        // and as the consequence can't move it (don't know where to find it). Detach the old item,\n        // hoping that it unlocks the fast path again.\n        detachedItems.set(liveStartKey, liveCollection.detach(liveStartIdx));\n        liveEndIdx--;\n      }\n    }\n\n    // Final cleanup steps:\n    // - more items in the new collection => insert\n    while (liveStartIdx <= newEndIdx) {\n      createOrAttach(\n          liveCollection, detachedItems, trackByFn, liveStartIdx, newCollection[liveStartIdx]);\n      liveStartIdx++;\n    }\n\n  } else if (newCollection != null) {\n    // iterable - immediately fallback to the slow path\n    const newCollectionIterator = newCollection[Symbol.iterator]();\n    let newIterationResult = newCollectionIterator.next();\n    while (!newIterationResult.done && liveStartIdx <= liveEndIdx) {\n      const liveValue = liveCollection.at(liveStartIdx);\n      const newValue = newIterationResult.value;\n      const isStartMatching =\n          valuesMatching(liveStartIdx, liveValue, liveStartIdx, newValue, trackByFn);\n      if (isStartMatching !== 0) {\n        // found a match - move on, but update value\n        if (isStartMatching < 0) {\n          liveCollection.updateValue(liveStartIdx, newValue);\n        }\n        liveStartIdx++;\n        newIterationResult = newCollectionIterator.next();\n      } else {\n        detachedItems ??= new UniqueValueMultiKeyMap();\n        liveKeysInTheFuture ??=\n            initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx, trackByFn);\n\n        // Check if I'm inserting a previously detached item: if so, attach it here\n        const newKey = trackByFn(liveStartIdx, newValue);\n        if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newKey)) {\n          liveCollection.updateValue(liveStartIdx, newValue);\n          liveStartIdx++;\n          liveEndIdx++;\n          newIterationResult = newCollectionIterator.next();\n        } else if (!liveKeysInTheFuture.has(newKey)) {\n          liveCollection.attach(liveStartIdx, liveCollection.create(liveStartIdx, newValue));\n          liveStartIdx++;\n          liveEndIdx++;\n          newIterationResult = newCollectionIterator.next();\n        } else {\n          // it is a move forward - detach the current item without advancing in collections\n          const liveKey = trackByFn(liveStartIdx, liveValue);\n          detachedItems.set(liveKey, liveCollection.detach(liveStartIdx));\n          liveEndIdx--;\n        }\n      }\n    }\n\n    // this is a new item as we run out of the items in the old collection - create or attach a\n    // previously detached one\n    while (!newIterationResult.done) {\n      createOrAttach(\n          liveCollection, detachedItems, trackByFn, liveCollection.length,\n          newIterationResult.value);\n      newIterationResult = newCollectionIterator.next();\n    }\n  }\n\n  // Cleanups common to the array and iterable:\n  // - more items in the live collection => delete starting from the end;\n  while (liveStartIdx <= liveEndIdx) {\n    liveCollection.destroy(liveCollection.detach(liveEndIdx--));\n  }\n\n\n  // - destroy items that were detached but never attached again.\n  detachedItems?.forEach(item => {\n    liveCollection.destroy(item);\n  });\n}\n\nfunction attachPreviouslyDetached<T, V>(\n    prevCollection: LiveCollection<T, V>,\n    detachedItems: UniqueValueMultiKeyMap<unknown, T>|undefined, index: number,\n    key: unknown): boolean {\n  if (detachedItems !== undefined && detachedItems.has(key)) {\n    prevCollection.attach(index, detachedItems.get(key)!);\n    detachedItems.delete(key);\n    return true;\n  }\n  return false;\n}\n\nfunction createOrAttach<T, V>(\n    liveCollection: LiveCollection<T, V>,\n    detachedItems: UniqueValueMultiKeyMap<unknown, T>|undefined,\n    trackByFn: TrackByFunction<unknown>, index: number, value: V) {\n  if (!attachPreviouslyDetached(liveCollection, detachedItems, index, trackByFn(index, value))) {\n    const newItem = liveCollection.create(index, value);\n    liveCollection.attach(index, newItem);\n  } else {\n    liveCollection.updateValue(index, value);\n  }\n}\n\nfunction initLiveItemsInTheFuture<T>(\n    liveCollection: LiveCollection<unknown, unknown>, start: number, end: number,\n    trackByFn: TrackByFunction<unknown>): Set<unknown> {\n  const keys = new Set();\n  for (let i = start; i <= end; i++) {\n    keys.add(trackByFn(i, liveCollection.at(i)));\n  }\n  return keys;\n}\n\n/**\n * A specific, partial implementation of the Map interface with the following characteristics:\n * - allows multiple values for a given key;\n * - maintain FIFO order for multiple values corresponding to a given key;\n * - assumes that all values are unique.\n *\n * The implementation aims at having the minimal overhead for cases where keys are _not_ duplicated\n * (the most common case in the list reconciliation algorithm). To achieve this, the first value for\n * a given key is stored in a regular map. Then, when more values are set for a given key, we\n * maintain a form of linked list in a separate map. To maintain this linked list we assume that all\n * values (in the entire collection) are unique.\n */\nexport class UniqueValueMultiKeyMap<K, V> {\n  // A map from a key to the first value corresponding to this key.\n  private kvMap = new Map<K, V>();\n  // A map that acts as a linked list of values - each value maps to the next value in this \"linked\n  // list\" (this only works if values are unique). Allocated lazily to avoid memory consumption when\n  // there are no duplicated values.\n  private _vMap: Map<V, V>|undefined = undefined;\n\n  has(key: K): boolean {\n    return this.kvMap.has(key);\n  }\n\n  delete(key: K): boolean {\n    if (!this.has(key)) return false;\n\n    const value = this.kvMap.get(key)!;\n    if (this._vMap !== undefined && this._vMap.has(value)) {\n      this.kvMap.set(key, this._vMap.get(value)!);\n      this._vMap.delete(value);\n    } else {\n      this.kvMap.delete(key);\n    }\n\n    return true;\n  }\n\n  get(key: K): V|undefined {\n    return this.kvMap.get(key);\n  }\n\n  set(key: K, value: V): void {\n    if (this.kvMap.has(key)) {\n      let prevValue = this.kvMap.get(key)!;\n      ngDevMode &&\n          assertNotSame(\n              prevValue, value, `Detected a duplicated value ${value} for the key ${key}`);\n\n      if (this._vMap === undefined) {\n        this._vMap = new Map();\n      }\n\n      const vMap = this._vMap;\n      while (vMap.has(prevValue)) {\n        prevValue = vMap.get(prevValue)!;\n      }\n      vMap.set(prevValue, value);\n    } else {\n      this.kvMap.set(key, value);\n    }\n  }\n\n  forEach(cb: (v: V, k: K) => void) {\n    for (let [key, value] of this.kvMap) {\n      cb(value, key);\n      if (this._vMap !== undefined) {\n        const vMap = this._vMap;\n        while (vMap.has(value)) {\n          value = vMap.get(value)!;\n          cb(value, key);\n        }\n      }\n    }\n  }\n}\n"]}