@angular/core 13.0.0-next.7 → 13.0.0-rc.1

package/esm2020/src/change_detection/differs/default_iterable_differ.mjs

@@ -0,0 +1,666 @@
+/**
+ * @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 { stringify } from '../../util/stringify';
+import { isListLikeIterable, iterateListLike } from '../change_detection_util';
+export class DefaultIterableDifferFactory {
+    constructor() { }
+    supports(obj) {
+        return isListLikeIterable(obj);
+    }
+    create(trackByFn) {
+        return new DefaultIterableDiffer(trackByFn);
+    }
+}
+const trackByIdentity = (index, item) => item;
+/**
+ * @deprecated v4.0.0 - Should not be part of public API.
+ * @publicApi
+ */
+export class DefaultIterableDiffer {
+    constructor(trackByFn) {
+        this.length = 0;
+        // Keeps track of the used records at any point in time (during & across `_check()` calls)
+        this._linkedRecords = null;
+        // Keeps track of the removed records at any point in time during `_check()` calls.
+        this._unlinkedRecords = null;
+        this._previousItHead = null;
+        this._itHead = null;
+        this._itTail = null;
+        this._additionsHead = null;
+        this._additionsTail = null;
+        this._movesHead = null;
+        this._movesTail = null;
+        this._removalsHead = null;
+        this._removalsTail = null;
+        // Keeps track of records where custom track by is the same, but item identity has changed
+        this._identityChangesHead = null;
+        this._identityChangesTail = null;
+        this._trackByFn = trackByFn || trackByIdentity;
+    }
+    forEachItem(fn) {
+        let record;
+        for (record = this._itHead; record !== null; record = record._next) {
+            fn(record);
+        }
+    }
+    forEachOperation(fn) {
+        let nextIt = this._itHead;
+        let nextRemove = this._removalsHead;
+        let addRemoveOffset = 0;
+        let moveOffsets = null;
+        while (nextIt || nextRemove) {
+            // Figure out which is the next record to process
+            // Order: remove, add, move
+            const record = !nextRemove ||
+                nextIt &&
+                    nextIt.currentIndex <
+                        getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ?
+                nextIt :
+                nextRemove;
+            const adjPreviousIndex = getPreviousIndex(record, addRemoveOffset, moveOffsets);
+            const currentIndex = record.currentIndex;
+            // consume the item, and adjust the addRemoveOffset and update moveDistance if necessary
+            if (record === nextRemove) {
+                addRemoveOffset--;
+                nextRemove = nextRemove._nextRemoved;
+            }
+            else {
+                nextIt = nextIt._next;
+                if (record.previousIndex == null) {
+                    addRemoveOffset++;
+                }
+                else {
+                    // INVARIANT:  currentIndex < previousIndex
+                    if (!moveOffsets)
+                        moveOffsets = [];
+                    const localMovePreviousIndex = adjPreviousIndex - addRemoveOffset;
+                    const localCurrentIndex = currentIndex - addRemoveOffset;
+                    if (localMovePreviousIndex != localCurrentIndex) {
+                        for (let i = 0; i < localMovePreviousIndex; i++) {
+                            const offset = i < moveOffsets.length ? moveOffsets[i] : (moveOffsets[i] = 0);
+                            const index = offset + i;
+                            if (localCurrentIndex <= index && index < localMovePreviousIndex) {
+                                moveOffsets[i] = offset + 1;
+                            }
+                        }
+                        const previousIndex = record.previousIndex;
+                        moveOffsets[previousIndex] = localCurrentIndex - localMovePreviousIndex;
+                    }
+                }
+            }
+            if (adjPreviousIndex !== currentIndex) {
+                fn(record, adjPreviousIndex, currentIndex);
+            }
+        }
+    }
+    forEachPreviousItem(fn) {
+        let record;
+        for (record = this._previousItHead; record !== null; record = record._nextPrevious) {
+            fn(record);
+        }
+    }
+    forEachAddedItem(fn) {
+        let record;
+        for (record = this._additionsHead; record !== null; record = record._nextAdded) {
+            fn(record);
+        }
+    }
+    forEachMovedItem(fn) {
+        let record;
+        for (record = this._movesHead; record !== null; record = record._nextMoved) {
+            fn(record);
+        }
+    }
+    forEachRemovedItem(fn) {
+        let record;
+        for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
+            fn(record);
+        }
+    }
+    forEachIdentityChange(fn) {
+        let record;
+        for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {
+            fn(record);
+        }
+    }
+    diff(collection) {
+        if (collection == null)
+            collection = [];
+        if (!isListLikeIterable(collection)) {
+            throw new Error(`Error trying to diff '${stringify(collection)}'. Only arrays and iterables are allowed`);
+        }
+        if (this.check(collection)) {
+            return this;
+        }
+        else {
+            return null;
+        }
+    }
+    onDestroy() { }
+    check(collection) {
+        this._reset();
+        let record = this._itHead;
+        let mayBeDirty = false;
+        let index;
+        let item;
+        let itemTrackBy;
+        if (Array.isArray(collection)) {
+            this.length = collection.length;
+            for (let index = 0; index < this.length; index++) {
+                item = collection[index];
+                itemTrackBy = this._trackByFn(index, item);
+                if (record === null || !Object.is(record.trackById, itemTrackBy)) {
+                    record = this._mismatch(record, item, itemTrackBy, index);
+                    mayBeDirty = true;
+                }
+                else {
+                    if (mayBeDirty) {
+                        // TODO(misko): can we limit this to duplicates only?
+                        record = this._verifyReinsertion(record, item, itemTrackBy, index);
+                    }
+                    if (!Object.is(record.item, item))
+                        this._addIdentityChange(record, item);
+                }
+                record = record._next;
+            }
+        }
+        else {
+            index = 0;
+            iterateListLike(collection, (item) => {
+                itemTrackBy = this._trackByFn(index, item);
+                if (record === null || !Object.is(record.trackById, itemTrackBy)) {
+                    record = this._mismatch(record, item, itemTrackBy, index);
+                    mayBeDirty = true;
+                }
+                else {
+                    if (mayBeDirty) {
+                        // TODO(misko): can we limit this to duplicates only?
+                        record = this._verifyReinsertion(record, item, itemTrackBy, index);
+                    }
+                    if (!Object.is(record.item, item))
+                        this._addIdentityChange(record, item);
+                }
+                record = record._next;
+                index++;
+            });
+            this.length = index;
+        }
+        this._truncate(record);
+        this.collection = collection;
+        return this.isDirty;
+    }
+    /* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity
+     * changes.
+     */
+    get isDirty() {
+        return this._additionsHead !== null || this._movesHead !== null ||
+            this._removalsHead !== null || this._identityChangesHead !== null;
+    }
+    /**
+     * Reset the state of the change objects to show no changes. This means set previousKey to
+     * currentKey, and clear all of the queues (additions, moves, removals).
+     * Set the previousIndexes of moved and added items to their currentIndexes
+     * Reset the list of additions, moves and removals
+     *
+     * @internal
+     */
+    _reset() {
+        if (this.isDirty) {
+            let record;
+            for (record = this._previousItHead = this._itHead; record !== null; record = record._next) {
+                record._nextPrevious = record._next;
+            }
+            for (record = this._additionsHead; record !== null; record = record._nextAdded) {
+                record.previousIndex = record.currentIndex;
+            }
+            this._additionsHead = this._additionsTail = null;
+            for (record = this._movesHead; record !== null; record = record._nextMoved) {
+                record.previousIndex = record.currentIndex;
+            }
+            this._movesHead = this._movesTail = null;
+            this._removalsHead = this._removalsTail = null;
+            this._identityChangesHead = this._identityChangesTail = null;
+            // TODO(vicb): when assert gets supported
+            // assert(!this.isDirty);
+        }
+    }
+    /**
+     * This is the core function which handles differences between collections.
+     *
+     * - `record` is the record which we saw at this position last time. If null then it is a new
+     *   item.
+     * - `item` is the current item in the collection
+     * - `index` is the position of the item in the collection
+     *
+     * @internal
+     */
+    _mismatch(record, item, itemTrackBy, index) {
+        // The previous record after which we will append the current one.
+        let previousRecord;
+        if (record === null) {
+            previousRecord = this._itTail;
+        }
+        else {
+            previousRecord = record._prev;
+            // Remove the record from the collection since we know it does not match the item.
+            this._remove(record);
+        }
+        // See if we have evicted the item, which used to be at some anterior position of _itHead list.
+        record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
+        if (record !== null) {
+            // It is an item which we have evicted earlier: reinsert it back into the list.
+            // But first we need to check if identity changed, so we can update in view if necessary.
+            if (!Object.is(record.item, item))
+                this._addIdentityChange(record, item);
+            this._reinsertAfter(record, previousRecord, index);
+        }
+        else {
+            // Attempt to see if the item is at some posterior position of _itHead list.
+            record = this._linkedRecords === null ? null : this._linkedRecords.get(itemTrackBy, index);
+            if (record !== null) {
+                // We have the item in _itHead at/after `index` position. We need to move it forward in the
+                // collection.
+                // But first we need to check if identity changed, so we can update in view if necessary.
+                if (!Object.is(record.item, item))
+                    this._addIdentityChange(record, item);
+                this._moveAfter(record, previousRecord, index);
+            }
+            else {
+                // It is a new item: add it.
+                record =
+                    this._addAfter(new IterableChangeRecord_(item, itemTrackBy), previousRecord, index);
+            }
+        }
+        return record;
+    }
+    /**
+     * This check is only needed if an array contains duplicates. (Short circuit of nothing dirty)
+     *
+     * Use case: `[a, a]` => `[b, a, a]`
+     *
+     * If we did not have this check then the insertion of `b` would:
+     *   1) evict first `a`
+     *   2) insert `b` at `0` index.
+     *   3) leave `a` at index `1` as is. <-- this is wrong!
+     *   3) reinsert `a` at index 2. <-- this is wrong!
+     *
+     * The correct behavior is:
+     *   1) evict first `a`
+     *   2) insert `b` at `0` index.
+     *   3) reinsert `a` at index 1.
+     *   3) move `a` at from `1` to `2`.
+     *
+     *
+     * Double check that we have not evicted a duplicate item. We need to check if the item type may
+     * have already been removed:
+     * The insertion of b will evict the first 'a'. If we don't reinsert it now it will be reinserted
+     * at the end. Which will show up as the two 'a's switching position. This is incorrect, since a
+     * better way to think of it is as insert of 'b' rather then switch 'a' with 'b' and then add 'a'
+     * at the end.
+     *
+     * @internal
+     */
+    _verifyReinsertion(record, item, itemTrackBy, index) {
+        let reinsertRecord = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
+        if (reinsertRecord !== null) {
+            record = this._reinsertAfter(reinsertRecord, record._prev, index);
+        }
+        else if (record.currentIndex != index) {
+            record.currentIndex = index;
+            this._addToMoves(record, index);
+        }
+        return record;
+    }
+    /**
+     * Get rid of any excess {@link IterableChangeRecord_}s from the previous collection
+     *
+     * - `record` The first excess {@link IterableChangeRecord_}.
+     *
+     * @internal
+     */
+    _truncate(record) {
+        // Anything after that needs to be removed;
+        while (record !== null) {
+            const nextRecord = record._next;
+            this._addToRemovals(this._unlink(record));
+            record = nextRecord;
+        }
+        if (this._unlinkedRecords !== null) {
+            this._unlinkedRecords.clear();
+        }
+        if (this._additionsTail !== null) {
+            this._additionsTail._nextAdded = null;
+        }
+        if (this._movesTail !== null) {
+            this._movesTail._nextMoved = null;
+        }
+        if (this._itTail !== null) {
+            this._itTail._next = null;
+        }
+        if (this._removalsTail !== null) {
+            this._removalsTail._nextRemoved = null;
+        }
+        if (this._identityChangesTail !== null) {
+            this._identityChangesTail._nextIdentityChange = null;
+        }
+    }
+    /** @internal */
+    _reinsertAfter(record, prevRecord, index) {
+        if (this._unlinkedRecords !== null) {
+            this._unlinkedRecords.remove(record);
+        }
+        const prev = record._prevRemoved;
+        const next = record._nextRemoved;
+        if (prev === null) {
+            this._removalsHead = next;
+        }
+        else {
+            prev._nextRemoved = next;
+        }
+        if (next === null) {
+            this._removalsTail = prev;
+        }
+        else {
+            next._prevRemoved = prev;
+        }
+        this._insertAfter(record, prevRecord, index);
+        this._addToMoves(record, index);
+        return record;
+    }
+    /** @internal */
+    _moveAfter(record, prevRecord, index) {
+        this._unlink(record);
+        this._insertAfter(record, prevRecord, index);
+        this._addToMoves(record, index);
+        return record;
+    }
+    /** @internal */
+    _addAfter(record, prevRecord, index) {
+        this._insertAfter(record, prevRecord, index);
+        if (this._additionsTail === null) {
+            // TODO(vicb):
+            // assert(this._additionsHead === null);
+            this._additionsTail = this._additionsHead = record;
+        }
+        else {
+            // TODO(vicb):
+            // assert(_additionsTail._nextAdded === null);
+            // assert(record._nextAdded === null);
+            this._additionsTail = this._additionsTail._nextAdded = record;
+        }
+        return record;
+    }
+    /** @internal */
+    _insertAfter(record, prevRecord, index) {
+        // TODO(vicb):
+        // assert(record != prevRecord);
+        // assert(record._next === null);
+        // assert(record._prev === null);
+        const next = prevRecord === null ? this._itHead : prevRecord._next;
+        // TODO(vicb):
+        // assert(next != record);
+        // assert(prevRecord != record);
+        record._next = next;
+        record._prev = prevRecord;
+        if (next === null) {
+            this._itTail = record;
+        }
+        else {
+            next._prev = record;
+        }
+        if (prevRecord === null) {
+            this._itHead = record;
+        }
+        else {
+            prevRecord._next = record;
+        }
+        if (this._linkedRecords === null) {
+            this._linkedRecords = new _DuplicateMap();
+        }
+        this._linkedRecords.put(record);
+        record.currentIndex = index;
+        return record;
+    }
+    /** @internal */
+    _remove(record) {
+        return this._addToRemovals(this._unlink(record));
+    }
+    /** @internal */
+    _unlink(record) {
+        if (this._linkedRecords !== null) {
+            this._linkedRecords.remove(record);
+        }
+        const prev = record._prev;
+        const next = record._next;
+        // TODO(vicb):
+        // assert((record._prev = null) === null);
+        // assert((record._next = null) === null);
+        if (prev === null) {
+            this._itHead = next;
+        }
+        else {
+            prev._next = next;
+        }
+        if (next === null) {
+            this._itTail = prev;
+        }
+        else {
+            next._prev = prev;
+        }
+        return record;
+    }
+    /** @internal */
+    _addToMoves(record, toIndex) {
+        // TODO(vicb):
+        // assert(record._nextMoved === null);
+        if (record.previousIndex === toIndex) {
+            return record;
+        }
+        if (this._movesTail === null) {
+            // TODO(vicb):
+            // assert(_movesHead === null);
+            this._movesTail = this._movesHead = record;
+        }
+        else {
+            // TODO(vicb):
+            // assert(_movesTail._nextMoved === null);
+            this._movesTail = this._movesTail._nextMoved = record;
+        }
+        return record;
+    }
+    _addToRemovals(record) {
+        if (this._unlinkedRecords === null) {
+            this._unlinkedRecords = new _DuplicateMap();
+        }
+        this._unlinkedRecords.put(record);
+        record.currentIndex = null;
+        record._nextRemoved = null;
+        if (this._removalsTail === null) {
+            // TODO(vicb):
+            // assert(_removalsHead === null);
+            this._removalsTail = this._removalsHead = record;
+            record._prevRemoved = null;
+        }
+        else {
+            // TODO(vicb):
+            // assert(_removalsTail._nextRemoved === null);
+            // assert(record._nextRemoved === null);
+            record._prevRemoved = this._removalsTail;
+            this._removalsTail = this._removalsTail._nextRemoved = record;
+        }
+        return record;
+    }
+    /** @internal */
+    _addIdentityChange(record, item) {
+        record.item = item;
+        if (this._identityChangesTail === null) {
+            this._identityChangesTail = this._identityChangesHead = record;
+        }
+        else {
+            this._identityChangesTail = this._identityChangesTail._nextIdentityChange = record;
+        }
+        return record;
+    }
+}
+export class IterableChangeRecord_ {
+    constructor(item, trackById) {
+        this.item = item;
+        this.trackById = trackById;
+        this.currentIndex = null;
+        this.previousIndex = null;
+        /** @internal */
+        this._nextPrevious = null;
+        /** @internal */
+        this._prev = null;
+        /** @internal */
+        this._next = null;
+        /** @internal */
+        this._prevDup = null;
+        /** @internal */
+        this._nextDup = null;
+        /** @internal */
+        this._prevRemoved = null;
+        /** @internal */
+        this._nextRemoved = null;
+        /** @internal */
+        this._nextAdded = null;
+        /** @internal */
+        this._nextMoved = null;
+        /** @internal */
+        this._nextIdentityChange = null;
+    }
+}
+// A linked list of IterableChangeRecords with the same IterableChangeRecord_.item
+class _DuplicateItemRecordList {
+    constructor() {
+        /** @internal */
+        this._head = null;
+        /** @internal */
+        this._tail = null;
+    }
+    /**
+     * Append the record to the list of duplicates.
+     *
+     * Note: by design all records in the list of duplicates hold the same value in record.item.
+     */
+    add(record) {
+        if (this._head === null) {
+            this._head = this._tail = record;
+            record._nextDup = null;
+            record._prevDup = null;
+        }
+        else {
+            // TODO(vicb):
+            // assert(record.item ==  _head.item ||
+            //       record.item is num && record.item.isNaN && _head.item is num && _head.item.isNaN);
+            this._tail._nextDup = record;
+            record._prevDup = this._tail;
+            record._nextDup = null;
+            this._tail = record;
+        }
+    }
+    // Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and
+    // IterableChangeRecord_.currentIndex >= atOrAfterIndex
+    get(trackById, atOrAfterIndex) {
+        let record;
+        for (record = this._head; record !== null; record = record._nextDup) {
+            if ((atOrAfterIndex === null || atOrAfterIndex <= record.currentIndex) &&
+                Object.is(record.trackById, trackById)) {
+                return record;
+            }
+        }
+        return null;
+    }
+    /**
+     * Remove one {@link IterableChangeRecord_} from the list of duplicates.
+     *
+     * Returns whether the list of duplicates is empty.
+     */
+    remove(record) {
+        // TODO(vicb):
+        // assert(() {
+        //  // verify that the record being removed is in the list.
+        //  for (IterableChangeRecord_ cursor = _head; cursor != null; cursor = cursor._nextDup) {
+        //    if (identical(cursor, record)) return true;
+        //  }
+        //  return false;
+        //});
+        const prev = record._prevDup;
+        const next = record._nextDup;
+        if (prev === null) {
+            this._head = next;
+        }
+        else {
+            prev._nextDup = next;
+        }
+        if (next === null) {
+            this._tail = prev;
+        }
+        else {
+            next._prevDup = prev;
+        }
+        return this._head === null;
+    }
+}
+class _DuplicateMap {
+    constructor() {
+        this.map = new Map();
+    }
+    put(record) {
+        const key = record.trackById;
+        let duplicates = this.map.get(key);
+        if (!duplicates) {
+            duplicates = new _DuplicateItemRecordList();
+            this.map.set(key, duplicates);
+        }
+        duplicates.add(record);
+    }
+    /**
+     * Retrieve the `value` using key. Because the IterableChangeRecord_ value may be one which we
+     * have already iterated over, we use the `atOrAfterIndex` to pretend it is not there.
+     *
+     * Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we
+     * have any more `a`s needs to return the second `a`.
+     */
+    get(trackById, atOrAfterIndex) {
+        const key = trackById;
+        const recordList = this.map.get(key);
+        return recordList ? recordList.get(trackById, atOrAfterIndex) : null;
+    }
+    /**
+     * Removes a {@link IterableChangeRecord_} from the list of duplicates.
+     *
+     * The list of duplicates also is removed from the map if it gets empty.
+     */
+    remove(record) {
+        const key = record.trackById;
+        const recordList = this.map.get(key);
+        // Remove the list of duplicates when it gets empty
+        if (recordList.remove(record)) {
+            this.map.delete(key);
+        }
+        return record;
+    }
+    get isEmpty() {
+        return this.map.size === 0;
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+function getPreviousIndex(item, addRemoveOffset, moveOffsets) {
+    const previousIndex = item.previousIndex;
+    if (previousIndex === null)
+        return previousIndex;
+    let moveOffset = 0;
+    if (moveOffsets && previousIndex < moveOffsets.length) {
+        moveOffset = moveOffsets[previousIndex];
+    }
+    return previousIndex + addRemoveOffset + moveOffset;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default_iterable_differ.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/change_detection/differs/default_iterable_differ.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 {stringify} from '../../util/stringify';\nimport {isListLikeIterable, iterateListLike} from '../change_detection_util';\n\nimport {IterableChangeRecord, IterableChanges, IterableDiffer, IterableDifferFactory, NgIterable, TrackByFunction} from './iterable_differs';\n\n\nexport class DefaultIterableDifferFactory implements IterableDifferFactory {\n  constructor() {}\n  supports(obj: Object|null|undefined): boolean {\n    return isListLikeIterable(obj);\n  }\n\n  create<V>(trackByFn?: TrackByFunction<V>): DefaultIterableDiffer<V> {\n    return new DefaultIterableDiffer<V>(trackByFn);\n  }\n}\n\nconst trackByIdentity = (index: number, item: any) => item;\n\n/**\n * @deprecated v4.0.0 - Should not be part of public API.\n * @publicApi\n */\nexport class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChanges<V> {\n  public readonly length: number = 0;\n  // TODO(issue/24571): remove '!'.\n  public readonly collection!: V[]|Iterable<V>|null;\n  // Keeps track of the used records at any point in time (during & across `_check()` calls)\n  private _linkedRecords: _DuplicateMap<V>|null = null;\n  // Keeps track of the removed records at any point in time during `_check()` calls.\n  private _unlinkedRecords: _DuplicateMap<V>|null = null;\n  private _previousItHead: IterableChangeRecord_<V>|null = null;\n  private _itHead: IterableChangeRecord_<V>|null = null;\n  private _itTail: IterableChangeRecord_<V>|null = null;\n  private _additionsHead: IterableChangeRecord_<V>|null = null;\n  private _additionsTail: IterableChangeRecord_<V>|null = null;\n  private _movesHead: IterableChangeRecord_<V>|null = null;\n  private _movesTail: IterableChangeRecord_<V>|null = null;\n  private _removalsHead: IterableChangeRecord_<V>|null = null;\n  private _removalsTail: IterableChangeRecord_<V>|null = null;\n  // Keeps track of records where custom track by is the same, but item identity has changed\n  private _identityChangesHead: IterableChangeRecord_<V>|null = null;\n  private _identityChangesTail: IterableChangeRecord_<V>|null = null;\n  private _trackByFn: TrackByFunction<V>;\n\n  constructor(trackByFn?: TrackByFunction<V>) {\n    this._trackByFn = trackByFn || trackByIdentity;\n  }\n\n  forEachItem(fn: (record: IterableChangeRecord_<V>) => void) {\n    let record: IterableChangeRecord_<V>|null;\n    for (record = this._itHead; record !== null; record = record._next) {\n      fn(record);\n    }\n  }\n\n  forEachOperation(\n      fn: (item: IterableChangeRecord<V>, previousIndex: number|null, currentIndex: number|null) =>\n          void) {\n    let nextIt = this._itHead;\n    let nextRemove = this._removalsHead;\n    let addRemoveOffset = 0;\n    let moveOffsets: number[]|null = null;\n    while (nextIt || nextRemove) {\n      // Figure out which is the next record to process\n      // Order: remove, add, move\n      const record: IterableChangeRecord<V> = !nextRemove ||\n              nextIt &&\n                  nextIt.currentIndex! <\n                      getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ?\n          nextIt! :\n          nextRemove;\n      const adjPreviousIndex = getPreviousIndex(record, addRemoveOffset, moveOffsets);\n      const currentIndex = record.currentIndex;\n\n      // consume the item, and adjust the addRemoveOffset and update moveDistance if necessary\n      if (record === nextRemove) {\n        addRemoveOffset--;\n        nextRemove = nextRemove._nextRemoved;\n      } else {\n        nextIt = nextIt!._next;\n        if (record.previousIndex == null) {\n          addRemoveOffset++;\n        } else {\n          // INVARIANT:  currentIndex < previousIndex\n          if (!moveOffsets) moveOffsets = [];\n          const localMovePreviousIndex = adjPreviousIndex - addRemoveOffset;\n          const localCurrentIndex = currentIndex! - addRemoveOffset;\n          if (localMovePreviousIndex != localCurrentIndex) {\n            for (let i = 0; i < localMovePreviousIndex; i++) {\n              const offset = i < moveOffsets.length ? moveOffsets[i] : (moveOffsets[i] = 0);\n              const index = offset + i;\n              if (localCurrentIndex <= index && index < localMovePreviousIndex) {\n                moveOffsets[i] = offset + 1;\n              }\n            }\n            const previousIndex = record.previousIndex;\n            moveOffsets[previousIndex] = localCurrentIndex - localMovePreviousIndex;\n          }\n        }\n      }\n\n      if (adjPreviousIndex !== currentIndex) {\n        fn(record, adjPreviousIndex, currentIndex);\n      }\n    }\n  }\n\n  forEachPreviousItem(fn: (record: IterableChangeRecord_<V>) => void) {\n    let record: IterableChangeRecord_<V>|null;\n    for (record = this._previousItHead; record !== null; record = record._nextPrevious) {\n      fn(record);\n    }\n  }\n\n  forEachAddedItem(fn: (record: IterableChangeRecord_<V>) => void) {\n    let record: IterableChangeRecord_<V>|null;\n    for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n      fn(record);\n    }\n  }\n\n  forEachMovedItem(fn: (record: IterableChangeRecord_<V>) => void) {\n    let record: IterableChangeRecord_<V>|null;\n    for (record = this._movesHead; record !== null; record = record._nextMoved) {\n      fn(record);\n    }\n  }\n\n  forEachRemovedItem(fn: (record: IterableChangeRecord_<V>) => void) {\n    let record: IterableChangeRecord_<V>|null;\n    for (record = this._removalsHead; record !== null; record = record._nextRemoved) {\n      fn(record);\n    }\n  }\n\n  forEachIdentityChange(fn: (record: IterableChangeRecord_<V>) => void) {\n    let record: IterableChangeRecord_<V>|null;\n    for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {\n      fn(record);\n    }\n  }\n\n  diff(collection: NgIterable<V>|null|undefined): DefaultIterableDiffer<V>|null {\n    if (collection == null) collection = [];\n    if (!isListLikeIterable(collection)) {\n      throw new Error(\n          `Error trying to diff '${stringify(collection)}'. Only arrays and iterables are allowed`);\n    }\n\n    if (this.check(collection)) {\n      return this;\n    } else {\n      return null;\n    }\n  }\n\n  onDestroy() {}\n\n  check(collection: NgIterable<V>): boolean {\n    this._reset();\n\n    let record: IterableChangeRecord_<V>|null = this._itHead;\n    let mayBeDirty: boolean = false;\n    let index: number;\n    let item: V;\n    let itemTrackBy: any;\n    if (Array.isArray(collection)) {\n      (this as {length: number}).length = collection.length;\n\n      for (let index = 0; index < this.length; index++) {\n        item = collection[index];\n        itemTrackBy = this._trackByFn(index, item);\n        if (record === null || !Object.is(record.trackById, itemTrackBy)) {\n          record = this._mismatch(record, item, itemTrackBy, index);\n          mayBeDirty = true;\n        } else {\n          if (mayBeDirty) {\n            // TODO(misko): can we limit this to duplicates only?\n            record = this._verifyReinsertion(record, item, itemTrackBy, index);\n          }\n          if (!Object.is(record.item, item)) this._addIdentityChange(record, item);\n        }\n\n        record = record._next;\n      }\n    } else {\n      index = 0;\n      iterateListLike(collection, (item: V) => {\n        itemTrackBy = this._trackByFn(index, item);\n        if (record === null || !Object.is(record.trackById, itemTrackBy)) {\n          record = this._mismatch(record, item, itemTrackBy, index);\n          mayBeDirty = true;\n        } else {\n          if (mayBeDirty) {\n            // TODO(misko): can we limit this to duplicates only?\n            record = this._verifyReinsertion(record, item, itemTrackBy, index);\n          }\n          if (!Object.is(record.item, item)) this._addIdentityChange(record, item);\n        }\n        record = record._next;\n        index++;\n      });\n      (this as {length: number}).length = index;\n    }\n\n    this._truncate(record);\n    (this as {collection: V[] | Iterable<V>}).collection = collection;\n    return this.isDirty;\n  }\n\n  /* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity\n   * changes.\n   */\n  get isDirty(): boolean {\n    return this._additionsHead !== null || this._movesHead !== null ||\n        this._removalsHead !== null || this._identityChangesHead !== null;\n  }\n\n  /**\n   * Reset the state of the change objects to show no changes. This means set previousKey to\n   * currentKey, and clear all of the queues (additions, moves, removals).\n   * Set the previousIndexes of moved and added items to their currentIndexes\n   * Reset the list of additions, moves and removals\n   *\n   * @internal\n   */\n  _reset() {\n    if (this.isDirty) {\n      let record: IterableChangeRecord_<V>|null;\n\n      for (record = this._previousItHead = this._itHead; record !== null; record = record._next) {\n        record._nextPrevious = record._next;\n      }\n\n      for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n        record.previousIndex = record.currentIndex;\n      }\n      this._additionsHead = this._additionsTail = null;\n\n      for (record = this._movesHead; record !== null; record = record._nextMoved) {\n        record.previousIndex = record.currentIndex;\n      }\n      this._movesHead = this._movesTail = null;\n      this._removalsHead = this._removalsTail = null;\n      this._identityChangesHead = this._identityChangesTail = null;\n\n      // TODO(vicb): when assert gets supported\n      // assert(!this.isDirty);\n    }\n  }\n\n  /**\n   * This is the core function which handles differences between collections.\n   *\n   * - `record` is the record which we saw at this position last time. If null then it is a new\n   *   item.\n   * - `item` is the current item in the collection\n   * - `index` is the position of the item in the collection\n   *\n   * @internal\n   */\n  _mismatch(record: IterableChangeRecord_<V>|null, item: V, itemTrackBy: any, index: number):\n      IterableChangeRecord_<V> {\n    // The previous record after which we will append the current one.\n    let previousRecord: IterableChangeRecord_<V>|null;\n\n    if (record === null) {\n      previousRecord = this._itTail;\n    } else {\n      previousRecord = record._prev;\n      // Remove the record from the collection since we know it does not match the item.\n      this._remove(record);\n    }\n\n    // See if we have evicted the item, which used to be at some anterior position of _itHead list.\n    record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);\n    if (record !== null) {\n      // It is an item which we have evicted earlier: reinsert it back into the list.\n      // But first we need to check if identity changed, so we can update in view if necessary.\n      if (!Object.is(record.item, item)) this._addIdentityChange(record, item);\n\n      this._reinsertAfter(record, previousRecord, index);\n    } else {\n      // Attempt to see if the item is at some posterior position of _itHead list.\n      record = this._linkedRecords === null ? null : this._linkedRecords.get(itemTrackBy, index);\n      if (record !== null) {\n        // We have the item in _itHead at/after `index` position. We need to move it forward in the\n        // collection.\n        // But first we need to check if identity changed, so we can update in view if necessary.\n        if (!Object.is(record.item, item)) this._addIdentityChange(record, item);\n\n        this._moveAfter(record, previousRecord, index);\n      } else {\n        // It is a new item: add it.\n        record =\n            this._addAfter(new IterableChangeRecord_<V>(item, itemTrackBy), previousRecord, index);\n      }\n    }\n    return record;\n  }\n\n  /**\n   * This check is only needed if an array contains duplicates. (Short circuit of nothing dirty)\n   *\n   * Use case: `[a, a]` => `[b, a, a]`\n   *\n   * If we did not have this check then the insertion of `b` would:\n   *   1) evict first `a`\n   *   2) insert `b` at `0` index.\n   *   3) leave `a` at index `1` as is. <-- this is wrong!\n   *   3) reinsert `a` at index 2. <-- this is wrong!\n   *\n   * The correct behavior is:\n   *   1) evict first `a`\n   *   2) insert `b` at `0` index.\n   *   3) reinsert `a` at index 1.\n   *   3) move `a` at from `1` to `2`.\n   *\n   *\n   * Double check that we have not evicted a duplicate item. We need to check if the item type may\n   * have already been removed:\n   * The insertion of b will evict the first 'a'. If we don't reinsert it now it will be reinserted\n   * at the end. Which will show up as the two 'a's switching position. This is incorrect, since a\n   * better way to think of it is as insert of 'b' rather then switch 'a' with 'b' and then add 'a'\n   * at the end.\n   *\n   * @internal\n   */\n  _verifyReinsertion(record: IterableChangeRecord_<V>, item: V, itemTrackBy: any, index: number):\n      IterableChangeRecord_<V> {\n    let reinsertRecord: IterableChangeRecord_<V>|null =\n        this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);\n    if (reinsertRecord !== null) {\n      record = this._reinsertAfter(reinsertRecord, record._prev!, index);\n    } else if (record.currentIndex != index) {\n      record.currentIndex = index;\n      this._addToMoves(record, index);\n    }\n    return record;\n  }\n\n  /**\n   * Get rid of any excess {@link IterableChangeRecord_}s from the previous collection\n   *\n   * - `record` The first excess {@link IterableChangeRecord_}.\n   *\n   * @internal\n   */\n  _truncate(record: IterableChangeRecord_<V>|null) {\n    // Anything after that needs to be removed;\n    while (record !== null) {\n      const nextRecord: IterableChangeRecord_<V>|null = record._next;\n      this._addToRemovals(this._unlink(record));\n      record = nextRecord;\n    }\n    if (this._unlinkedRecords !== null) {\n      this._unlinkedRecords.clear();\n    }\n\n    if (this._additionsTail !== null) {\n      this._additionsTail._nextAdded = null;\n    }\n    if (this._movesTail !== null) {\n      this._movesTail._nextMoved = null;\n    }\n    if (this._itTail !== null) {\n      this._itTail._next = null;\n    }\n    if (this._removalsTail !== null) {\n      this._removalsTail._nextRemoved = null;\n    }\n    if (this._identityChangesTail !== null) {\n      this._identityChangesTail._nextIdentityChange = null;\n    }\n  }\n\n  /** @internal */\n  _reinsertAfter(\n      record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>|null,\n      index: number): IterableChangeRecord_<V> {\n    if (this._unlinkedRecords !== null) {\n      this._unlinkedRecords.remove(record);\n    }\n    const prev = record._prevRemoved;\n    const next = record._nextRemoved;\n\n    if (prev === null) {\n      this._removalsHead = next;\n    } else {\n      prev._nextRemoved = next;\n    }\n    if (next === null) {\n      this._removalsTail = prev;\n    } else {\n      next._prevRemoved = prev;\n    }\n\n    this._insertAfter(record, prevRecord, index);\n    this._addToMoves(record, index);\n    return record;\n  }\n\n  /** @internal */\n  _moveAfter(\n      record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>|null,\n      index: number): IterableChangeRecord_<V> {\n    this._unlink(record);\n    this._insertAfter(record, prevRecord, index);\n    this._addToMoves(record, index);\n    return record;\n  }\n\n  /** @internal */\n  _addAfter(\n      record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>|null,\n      index: number): IterableChangeRecord_<V> {\n    this._insertAfter(record, prevRecord, index);\n\n    if (this._additionsTail === null) {\n      // TODO(vicb):\n      // assert(this._additionsHead === null);\n      this._additionsTail = this._additionsHead = record;\n    } else {\n      // TODO(vicb):\n      // assert(_additionsTail._nextAdded === null);\n      // assert(record._nextAdded === null);\n      this._additionsTail = this._additionsTail._nextAdded = record;\n    }\n    return record;\n  }\n\n  /** @internal */\n  _insertAfter(\n      record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>|null,\n      index: number): IterableChangeRecord_<V> {\n    // TODO(vicb):\n    // assert(record != prevRecord);\n    // assert(record._next === null);\n    // assert(record._prev === null);\n\n    const next: IterableChangeRecord_<V>|null =\n        prevRecord === null ? this._itHead : prevRecord._next;\n    // TODO(vicb):\n    // assert(next != record);\n    // assert(prevRecord != record);\n    record._next = next;\n    record._prev = prevRecord;\n    if (next === null) {\n      this._itTail = record;\n    } else {\n      next._prev = record;\n    }\n    if (prevRecord === null) {\n      this._itHead = record;\n    } else {\n      prevRecord._next = record;\n    }\n\n    if (this._linkedRecords === null) {\n      this._linkedRecords = new _DuplicateMap<V>();\n    }\n    this._linkedRecords.put(record);\n\n    record.currentIndex = index;\n    return record;\n  }\n\n  /** @internal */\n  _remove(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {\n    return this._addToRemovals(this._unlink(record));\n  }\n\n  /** @internal */\n  _unlink(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {\n    if (this._linkedRecords !== null) {\n      this._linkedRecords.remove(record);\n    }\n\n    const prev = record._prev;\n    const next = record._next;\n\n    // TODO(vicb):\n    // assert((record._prev = null) === null);\n    // assert((record._next = null) === null);\n\n    if (prev === null) {\n      this._itHead = next;\n    } else {\n      prev._next = next;\n    }\n    if (next === null) {\n      this._itTail = prev;\n    } else {\n      next._prev = prev;\n    }\n\n    return record;\n  }\n\n  /** @internal */\n  _addToMoves(record: IterableChangeRecord_<V>, toIndex: number): IterableChangeRecord_<V> {\n    // TODO(vicb):\n    // assert(record._nextMoved === null);\n\n    if (record.previousIndex === toIndex) {\n      return record;\n    }\n\n    if (this._movesTail === null) {\n      // TODO(vicb):\n      // assert(_movesHead === null);\n      this._movesTail = this._movesHead = record;\n    } else {\n      // TODO(vicb):\n      // assert(_movesTail._nextMoved === null);\n      this._movesTail = this._movesTail._nextMoved = record;\n    }\n\n    return record;\n  }\n\n  private _addToRemovals(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {\n    if (this._unlinkedRecords === null) {\n      this._unlinkedRecords = new _DuplicateMap<V>();\n    }\n    this._unlinkedRecords.put(record);\n    record.currentIndex = null;\n    record._nextRemoved = null;\n\n    if (this._removalsTail === null) {\n      // TODO(vicb):\n      // assert(_removalsHead === null);\n      this._removalsTail = this._removalsHead = record;\n      record._prevRemoved = null;\n    } else {\n      // TODO(vicb):\n      // assert(_removalsTail._nextRemoved === null);\n      // assert(record._nextRemoved === null);\n      record._prevRemoved = this._removalsTail;\n      this._removalsTail = this._removalsTail._nextRemoved = record;\n    }\n    return record;\n  }\n\n  /** @internal */\n  _addIdentityChange(record: IterableChangeRecord_<V>, item: V) {\n    record.item = item;\n    if (this._identityChangesTail === null) {\n      this._identityChangesTail = this._identityChangesHead = record;\n    } else {\n      this._identityChangesTail = this._identityChangesTail._nextIdentityChange = record;\n    }\n    return record;\n  }\n}\n\nexport class IterableChangeRecord_<V> implements IterableChangeRecord<V> {\n  currentIndex: number|null = null;\n  previousIndex: number|null = null;\n\n  /** @internal */\n  _nextPrevious: IterableChangeRecord_<V>|null = null;\n  /** @internal */\n  _prev: IterableChangeRecord_<V>|null = null;\n  /** @internal */\n  _next: IterableChangeRecord_<V>|null = null;\n  /** @internal */\n  _prevDup: IterableChangeRecord_<V>|null = null;\n  /** @internal */\n  _nextDup: IterableChangeRecord_<V>|null = null;\n  /** @internal */\n  _prevRemoved: IterableChangeRecord_<V>|null = null;\n  /** @internal */\n  _nextRemoved: IterableChangeRecord_<V>|null = null;\n  /** @internal */\n  _nextAdded: IterableChangeRecord_<V>|null = null;\n  /** @internal */\n  _nextMoved: IterableChangeRecord_<V>|null = null;\n  /** @internal */\n  _nextIdentityChange: IterableChangeRecord_<V>|null = null;\n\n\n  constructor(public item: V, public trackById: any) {}\n}\n\n// A linked list of IterableChangeRecords with the same IterableChangeRecord_.item\nclass _DuplicateItemRecordList<V> {\n  /** @internal */\n  _head: IterableChangeRecord_<V>|null = null;\n  /** @internal */\n  _tail: IterableChangeRecord_<V>|null = null;\n\n  /**\n   * Append the record to the list of duplicates.\n   *\n   * Note: by design all records in the list of duplicates hold the same value in record.item.\n   */\n  add(record: IterableChangeRecord_<V>): void {\n    if (this._head === null) {\n      this._head = this._tail = record;\n      record._nextDup = null;\n      record._prevDup = null;\n    } else {\n      // TODO(vicb):\n      // assert(record.item ==  _head.item ||\n      //       record.item is num && record.item.isNaN && _head.item is num && _head.item.isNaN);\n      this._tail!._nextDup = record;\n      record._prevDup = this._tail;\n      record._nextDup = null;\n      this._tail = record;\n    }\n  }\n\n  // Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and\n  // IterableChangeRecord_.currentIndex >= atOrAfterIndex\n  get(trackById: any, atOrAfterIndex: number|null): IterableChangeRecord_<V>|null {\n    let record: IterableChangeRecord_<V>|null;\n    for (record = this._head; record !== null; record = record._nextDup) {\n      if ((atOrAfterIndex === null || atOrAfterIndex <= record.currentIndex!) &&\n          Object.is(record.trackById, trackById)) {\n        return record;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Remove one {@link IterableChangeRecord_} from the list of duplicates.\n   *\n   * Returns whether the list of duplicates is empty.\n   */\n  remove(record: IterableChangeRecord_<V>): boolean {\n    // TODO(vicb):\n    // assert(() {\n    //  // verify that the record being removed is in the list.\n    //  for (IterableChangeRecord_ cursor = _head; cursor != null; cursor = cursor._nextDup) {\n    //    if (identical(cursor, record)) return true;\n    //  }\n    //  return false;\n    //});\n\n    const prev: IterableChangeRecord_<V>|null = record._prevDup;\n    const next: IterableChangeRecord_<V>|null = record._nextDup;\n    if (prev === null) {\n      this._head = next;\n    } else {\n      prev._nextDup = next;\n    }\n    if (next === null) {\n      this._tail = prev;\n    } else {\n      next._prevDup = prev;\n    }\n    return this._head === null;\n  }\n}\n\nclass _DuplicateMap<V> {\n  map = new Map<any, _DuplicateItemRecordList<V>>();\n\n  put(record: IterableChangeRecord_<V>) {\n    const key = record.trackById;\n\n    let duplicates = this.map.get(key);\n    if (!duplicates) {\n      duplicates = new _DuplicateItemRecordList<V>();\n      this.map.set(key, duplicates);\n    }\n    duplicates.add(record);\n  }\n\n  /**\n   * Retrieve the `value` using key. Because the IterableChangeRecord_ value may be one which we\n   * have already iterated over, we use the `atOrAfterIndex` to pretend it is not there.\n   *\n   * Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we\n   * have any more `a`s needs to return the second `a`.\n   */\n  get(trackById: any, atOrAfterIndex: number|null): IterableChangeRecord_<V>|null {\n    const key = trackById;\n    const recordList = this.map.get(key);\n    return recordList ? recordList.get(trackById, atOrAfterIndex) : null;\n  }\n\n  /**\n   * Removes a {@link IterableChangeRecord_} from the list of duplicates.\n   *\n   * The list of duplicates also is removed from the map if it gets empty.\n   */\n  remove(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {\n    const key = record.trackById;\n    const recordList: _DuplicateItemRecordList<V> = this.map.get(key)!;\n    // Remove the list of duplicates when it gets empty\n    if (recordList.remove(record)) {\n      this.map.delete(key);\n    }\n    return record;\n  }\n\n  get isEmpty(): boolean {\n    return this.map.size === 0;\n  }\n\n  clear() {\n    this.map.clear();\n  }\n}\n\nfunction getPreviousIndex(item: any, addRemoveOffset: number, moveOffsets: number[]|null): number {\n  const previousIndex = item.previousIndex;\n  if (previousIndex === null) return previousIndex;\n  let moveOffset = 0;\n  if (moveOffsets && previousIndex < moveOffsets.length) {\n    moveOffset = moveOffsets[previousIndex];\n  }\n  return previousIndex + addRemoveOffset + moveOffset;\n}\n"]}