You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
315 lines
46 KiB
315 lines
46 KiB
/**
|
|
* @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 { ArrayDataSource, isDataSource, _RecycleViewRepeaterStrategy, _VIEW_REPEATER_STRATEGY, } from '@angular/cdk/collections';
|
|
import { Directive, Inject, Input, IterableDiffers, NgZone, SkipSelf, TemplateRef, ViewContainerRef, } from '@angular/core';
|
|
import { coerceNumberProperty } from '@angular/cdk/coercion';
|
|
import { Subject, of as observableOf, isObservable } from 'rxjs';
|
|
import { pairwise, shareReplay, startWith, switchMap, takeUntil } from 'rxjs/operators';
|
|
import { CdkVirtualScrollViewport } from './virtual-scroll-viewport';
|
|
/** Helper to extract the offset of a DOM Node in a certain direction. */
|
|
import * as ɵngcc0 from '@angular/core';
|
|
import * as ɵngcc1 from './virtual-scroll-viewport';
|
|
import * as ɵngcc2 from '@angular/cdk/collections';
|
|
function getOffset(orientation, direction, node) {
|
|
const el = node;
|
|
if (!el.getBoundingClientRect) {
|
|
return 0;
|
|
}
|
|
const rect = el.getBoundingClientRect();
|
|
if (orientation === 'horizontal') {
|
|
return direction === 'start' ? rect.left : rect.right;
|
|
}
|
|
return direction === 'start' ? rect.top : rect.bottom;
|
|
}
|
|
/**
|
|
* A directive similar to `ngForOf` to be used for rendering data inside a virtual scrolling
|
|
* container.
|
|
*/
|
|
export class CdkVirtualForOf {
|
|
constructor(
|
|
/** The view container to add items to. */
|
|
_viewContainerRef,
|
|
/** The template to use when stamping out new items. */
|
|
_template,
|
|
/** The set of available differs. */
|
|
_differs,
|
|
/** The strategy used to render items in the virtual scroll viewport. */
|
|
_viewRepeater,
|
|
/** The virtual scrolling viewport that these items are being rendered in. */
|
|
_viewport, ngZone) {
|
|
this._viewContainerRef = _viewContainerRef;
|
|
this._template = _template;
|
|
this._differs = _differs;
|
|
this._viewRepeater = _viewRepeater;
|
|
this._viewport = _viewport;
|
|
/** Emits when the rendered view of the data changes. */
|
|
this.viewChange = new Subject();
|
|
/** Subject that emits when a new DataSource instance is given. */
|
|
this._dataSourceChanges = new Subject();
|
|
/** Emits whenever the data in the current DataSource changes. */
|
|
this.dataStream = this._dataSourceChanges
|
|
.pipe(
|
|
// Start off with null `DataSource`.
|
|
startWith(null),
|
|
// Bundle up the previous and current data sources so we can work with both.
|
|
pairwise(),
|
|
// Use `_changeDataSource` to disconnect from the previous data source and connect to the
|
|
// new one, passing back a stream of data changes which we run through `switchMap` to give
|
|
// us a data stream that emits the latest data from whatever the current `DataSource` is.
|
|
switchMap(([prev, cur]) => this._changeDataSource(prev, cur)),
|
|
// Replay the last emitted data when someone subscribes.
|
|
shareReplay(1));
|
|
/** The differ used to calculate changes to the data. */
|
|
this._differ = null;
|
|
/** Whether the rendered data should be updated during the next ngDoCheck cycle. */
|
|
this._needsUpdate = false;
|
|
this._destroyed = new Subject();
|
|
this.dataStream.subscribe(data => {
|
|
this._data = data;
|
|
this._onRenderedDataChange();
|
|
});
|
|
this._viewport.renderedRangeStream.pipe(takeUntil(this._destroyed)).subscribe(range => {
|
|
this._renderedRange = range;
|
|
ngZone.run(() => this.viewChange.next(this._renderedRange));
|
|
this._onRenderedDataChange();
|
|
});
|
|
this._viewport.attach(this);
|
|
}
|
|
/** The DataSource to display. */
|
|
get cdkVirtualForOf() {
|
|
return this._cdkVirtualForOf;
|
|
}
|
|
set cdkVirtualForOf(value) {
|
|
this._cdkVirtualForOf = value;
|
|
if (isDataSource(value)) {
|
|
this._dataSourceChanges.next(value);
|
|
}
|
|
else {
|
|
// If value is an an NgIterable, convert it to an array.
|
|
this._dataSourceChanges.next(new ArrayDataSource(isObservable(value) ? value : Array.from(value || [])));
|
|
}
|
|
}
|
|
/**
|
|
* The `TrackByFunction` to use for tracking changes. The `TrackByFunction` takes the index and
|
|
* the item and produces a value to be used as the item's identity when tracking changes.
|
|
*/
|
|
get cdkVirtualForTrackBy() {
|
|
return this._cdkVirtualForTrackBy;
|
|
}
|
|
set cdkVirtualForTrackBy(fn) {
|
|
this._needsUpdate = true;
|
|
this._cdkVirtualForTrackBy = fn ?
|
|
(index, item) => fn(index + (this._renderedRange ? this._renderedRange.start : 0), item) :
|
|
undefined;
|
|
}
|
|
/** The template used to stamp out new elements. */
|
|
set cdkVirtualForTemplate(value) {
|
|
if (value) {
|
|
this._needsUpdate = true;
|
|
this._template = value;
|
|
}
|
|
}
|
|
/**
|
|
* The size of the cache used to store templates that are not being used for re-use later.
|
|
* Setting the cache size to `0` will disable caching. Defaults to 20 templates.
|
|
*/
|
|
get cdkVirtualForTemplateCacheSize() {
|
|
return this._viewRepeater.viewCacheSize;
|
|
}
|
|
set cdkVirtualForTemplateCacheSize(size) {
|
|
this._viewRepeater.viewCacheSize = coerceNumberProperty(size);
|
|
}
|
|
/**
|
|
* Measures the combined size (width for horizontal orientation, height for vertical) of all items
|
|
* in the specified range. Throws an error if the range includes items that are not currently
|
|
* rendered.
|
|
*/
|
|
measureRangeSize(range, orientation) {
|
|
if (range.start >= range.end) {
|
|
return 0;
|
|
}
|
|
if ((range.start < this._renderedRange.start || range.end > this._renderedRange.end) &&
|
|
(typeof ngDevMode === 'undefined' || ngDevMode)) {
|
|
throw Error(`Error: attempted to measure an item that isn't rendered.`);
|
|
}
|
|
// The index into the list of rendered views for the first item in the range.
|
|
const renderedStartIndex = range.start - this._renderedRange.start;
|
|
// The length of the range we're measuring.
|
|
const rangeLen = range.end - range.start;
|
|
// Loop over all the views, find the first and land node and compute the size by subtracting
|
|
// the top of the first node from the bottom of the last one.
|
|
let firstNode;
|
|
let lastNode;
|
|
// Find the first node by starting from the beginning and going forwards.
|
|
for (let i = 0; i < rangeLen; i++) {
|
|
const view = this._viewContainerRef.get(i + renderedStartIndex);
|
|
if (view && view.rootNodes.length) {
|
|
firstNode = lastNode = view.rootNodes[0];
|
|
break;
|
|
}
|
|
}
|
|
// Find the last node by starting from the end and going backwards.
|
|
for (let i = rangeLen - 1; i > -1; i--) {
|
|
const view = this._viewContainerRef.get(i + renderedStartIndex);
|
|
if (view && view.rootNodes.length) {
|
|
lastNode = view.rootNodes[view.rootNodes.length - 1];
|
|
break;
|
|
}
|
|
}
|
|
return firstNode && lastNode ?
|
|
getOffset(orientation, 'end', lastNode) - getOffset(orientation, 'start', firstNode) : 0;
|
|
}
|
|
ngDoCheck() {
|
|
if (this._differ && this._needsUpdate) {
|
|
// TODO(mmalerba): We should differentiate needs update due to scrolling and a new portion of
|
|
// this list being rendered (can use simpler algorithm) vs needs update due to data actually
|
|
// changing (need to do this diff).
|
|
const changes = this._differ.diff(this._renderedItems);
|
|
if (!changes) {
|
|
this._updateContext();
|
|
}
|
|
else {
|
|
this._applyChanges(changes);
|
|
}
|
|
this._needsUpdate = false;
|
|
}
|
|
}
|
|
ngOnDestroy() {
|
|
this._viewport.detach();
|
|
this._dataSourceChanges.next(undefined);
|
|
this._dataSourceChanges.complete();
|
|
this.viewChange.complete();
|
|
this._destroyed.next();
|
|
this._destroyed.complete();
|
|
this._viewRepeater.detach();
|
|
}
|
|
/** React to scroll state changes in the viewport. */
|
|
_onRenderedDataChange() {
|
|
if (!this._renderedRange) {
|
|
return;
|
|
}
|
|
this._renderedItems = this._data.slice(this._renderedRange.start, this._renderedRange.end);
|
|
if (!this._differ) {
|
|
// Use a wrapper function for the `trackBy` so any new values are
|
|
// picked up automatically without having to recreate the differ.
|
|
this._differ = this._differs.find(this._renderedItems).create((index, item) => {
|
|
return this.cdkVirtualForTrackBy ? this.cdkVirtualForTrackBy(index, item) : item;
|
|
});
|
|
}
|
|
this._needsUpdate = true;
|
|
}
|
|
/** Swap out one `DataSource` for another. */
|
|
_changeDataSource(oldDs, newDs) {
|
|
if (oldDs) {
|
|
oldDs.disconnect(this);
|
|
}
|
|
this._needsUpdate = true;
|
|
return newDs ? newDs.connect(this) : observableOf();
|
|
}
|
|
/** Update the `CdkVirtualForOfContext` for all views. */
|
|
_updateContext() {
|
|
const count = this._data.length;
|
|
let i = this._viewContainerRef.length;
|
|
while (i--) {
|
|
const view = this._viewContainerRef.get(i);
|
|
view.context.index = this._renderedRange.start + i;
|
|
view.context.count = count;
|
|
this._updateComputedContextProperties(view.context);
|
|
view.detectChanges();
|
|
}
|
|
}
|
|
/** Apply changes to the DOM. */
|
|
_applyChanges(changes) {
|
|
this._viewRepeater.applyChanges(changes, this._viewContainerRef, (record, _adjustedPreviousIndex, currentIndex) => this._getEmbeddedViewArgs(record, currentIndex), (record) => record.item);
|
|
// Update $implicit for any items that had an identity change.
|
|
changes.forEachIdentityChange((record) => {
|
|
const view = this._viewContainerRef.get(record.currentIndex);
|
|
view.context.$implicit = record.item;
|
|
});
|
|
// Update the context variables on all items.
|
|
const count = this._data.length;
|
|
let i = this._viewContainerRef.length;
|
|
while (i--) {
|
|
const view = this._viewContainerRef.get(i);
|
|
view.context.index = this._renderedRange.start + i;
|
|
view.context.count = count;
|
|
this._updateComputedContextProperties(view.context);
|
|
}
|
|
}
|
|
/** Update the computed properties on the `CdkVirtualForOfContext`. */
|
|
_updateComputedContextProperties(context) {
|
|
context.first = context.index === 0;
|
|
context.last = context.index === context.count - 1;
|
|
context.even = context.index % 2 === 0;
|
|
context.odd = !context.even;
|
|
}
|
|
_getEmbeddedViewArgs(record, index) {
|
|
// Note that it's important that we insert the item directly at the proper index,
|
|
// rather than inserting it and the moving it in place, because if there's a directive
|
|
// on the same node that injects the `ViewContainerRef`, Angular will insert another
|
|
// comment node which can throw off the move when it's being repeated for all items.
|
|
return {
|
|
templateRef: this._template,
|
|
context: {
|
|
$implicit: record.item,
|
|
// It's guaranteed that the iterable is not "undefined" or "null" because we only
|
|
// generate views for elements if the "cdkVirtualForOf" iterable has elements.
|
|
cdkVirtualForOf: this._cdkVirtualForOf,
|
|
index: -1,
|
|
count: -1,
|
|
first: false,
|
|
last: false,
|
|
odd: false,
|
|
even: false
|
|
},
|
|
index,
|
|
};
|
|
}
|
|
}
|
|
CdkVirtualForOf.ɵfac = function CdkVirtualForOf_Factory(t) { return new (t || CdkVirtualForOf)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.IterableDiffers), ɵngcc0.ɵɵdirectiveInject(_VIEW_REPEATER_STRATEGY), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.CdkVirtualScrollViewport, 4), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone)); };
|
|
CdkVirtualForOf.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkVirtualForOf, selectors: [["", "cdkVirtualFor", "", "cdkVirtualForOf", ""]], inputs: { cdkVirtualForOf: "cdkVirtualForOf", cdkVirtualForTrackBy: "cdkVirtualForTrackBy", cdkVirtualForTemplate: "cdkVirtualForTemplate", cdkVirtualForTemplateCacheSize: "cdkVirtualForTemplateCacheSize" }, features: [ɵngcc0.ɵɵProvidersFeature([
|
|
{ provide: _VIEW_REPEATER_STRATEGY, useClass: _RecycleViewRepeaterStrategy },
|
|
])] });
|
|
CdkVirtualForOf.ctorParameters = () => [
|
|
{ type: ViewContainerRef },
|
|
{ type: TemplateRef },
|
|
{ type: IterableDiffers },
|
|
{ type: _RecycleViewRepeaterStrategy, decorators: [{ type: Inject, args: [_VIEW_REPEATER_STRATEGY,] }] },
|
|
{ type: CdkVirtualScrollViewport, decorators: [{ type: SkipSelf }] },
|
|
{ type: NgZone }
|
|
];
|
|
CdkVirtualForOf.propDecorators = {
|
|
cdkVirtualForOf: [{ type: Input }],
|
|
cdkVirtualForTrackBy: [{ type: Input }],
|
|
cdkVirtualForTemplate: [{ type: Input }],
|
|
cdkVirtualForTemplateCacheSize: [{ type: Input }]
|
|
};
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkVirtualForOf, [{
|
|
type: Directive,
|
|
args: [{
|
|
selector: '[cdkVirtualFor][cdkVirtualForOf]',
|
|
providers: [
|
|
{ provide: _VIEW_REPEATER_STRATEGY, useClass: _RecycleViewRepeaterStrategy },
|
|
]
|
|
}]
|
|
}], function () { return [{ type: ɵngcc0.ViewContainerRef }, { type: ɵngcc0.TemplateRef }, { type: ɵngcc0.IterableDiffers }, { type: ɵngcc2._RecycleViewRepeaterStrategy, decorators: [{
|
|
type: Inject,
|
|
args: [_VIEW_REPEATER_STRATEGY]
|
|
}] }, { type: ɵngcc1.CdkVirtualScrollViewport, decorators: [{
|
|
type: SkipSelf
|
|
}] }, { type: ɵngcc0.NgZone }]; }, { cdkVirtualForOf: [{
|
|
type: Input
|
|
}], cdkVirtualForTrackBy: [{
|
|
type: Input
|
|
}], cdkVirtualForTemplate: [{
|
|
type: Input
|
|
}], cdkVirtualForTemplateCacheSize: [{
|
|
type: Input
|
|
}] }); })();
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"virtual-for-of.js","sources":["../../../../../../src/cdk/scrolling/virtual-for-of.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 {\n  ArrayDataSource,\n  CollectionViewer,\n  DataSource,\n  ListRange,\n  isDataSource,\n  _RecycleViewRepeaterStrategy,\n  _VIEW_REPEATER_STRATEGY,\n  _ViewRepeaterItemInsertArgs,\n} from '@angular/cdk/collections';\nimport {\n  Directive,\n  DoCheck,\n  EmbeddedViewRef,\n  Inject,\n  Input,\n  IterableChangeRecord,\n  IterableChanges,\n  IterableDiffer,\n  IterableDiffers,\n  NgIterable,\n  NgZone,\n  OnDestroy,\n  SkipSelf,\n  TemplateRef,\n  TrackByFunction,\n  ViewContainerRef,\n} from '@angular/core';\nimport {coerceNumberProperty, NumberInput} from '@angular/cdk/coercion';\nimport {Observable, Subject, of as observableOf, isObservable} from 'rxjs';\nimport {pairwise, shareReplay, startWith, switchMap, takeUntil} from 'rxjs/operators';\nimport {CdkVirtualScrollRepeater} from './virtual-scroll-repeater';\nimport {CdkVirtualScrollViewport} from './virtual-scroll-viewport';\n\n\n/** The context for an item rendered by `CdkVirtualForOf` */\nexport type CdkVirtualForOfContext<T> = {\n  /** The item value. */\n  $implicit: T;\n  /** The DataSource, Observable, or NgIterable that was passed to *cdkVirtualFor. */\n  cdkVirtualForOf: DataSource<T> | Observable<T[]> | NgIterable<T>;\n  /** The index of the item in the DataSource. */\n  index: number;\n  /** The number of items in the DataSource. */\n  count: number;\n  /** Whether this is the first item in the DataSource. */\n  first: boolean;\n  /** Whether this is the last item in the DataSource. */\n  last: boolean;\n  /** Whether the index is even. */\n  even: boolean;\n  /** Whether the index is odd. */\n  odd: boolean;\n};\n\n\n/** Helper to extract the offset of a DOM Node in a certain direction. */\nfunction getOffset(orientation: 'horizontal' | 'vertical', direction: 'start' | 'end', node: Node) {\n  const el = node as Element;\n  if (!el.getBoundingClientRect) {\n    return 0;\n  }\n  const rect = el.getBoundingClientRect();\n\n  if (orientation === 'horizontal') {\n    return direction === 'start' ? rect.left : rect.right;\n  }\n\n  return direction === 'start' ? rect.top : rect.bottom;\n}\n\n/**\n * A directive similar to `ngForOf` to be used for rendering data inside a virtual scrolling\n * container.\n */\n@Directive({\n  selector: '[cdkVirtualFor][cdkVirtualForOf]',\n  providers: [\n    {provide: _VIEW_REPEATER_STRATEGY, useClass: _RecycleViewRepeaterStrategy},\n  ]\n})\nexport class CdkVirtualForOf<T> implements\n    CdkVirtualScrollRepeater<T>, CollectionViewer, DoCheck, OnDestroy {\n  /** Emits when the rendered view of the data changes. */\n  readonly viewChange = new Subject<ListRange>();\n\n  /** Subject that emits when a new DataSource instance is given. */\n  private readonly _dataSourceChanges = new Subject<DataSource<T>>();\n\n  /** The DataSource to display. */\n  @Input()\n  get cdkVirtualForOf(): DataSource<T> | Observable<T[]> | NgIterable<T> | null | undefined {\n    return this._cdkVirtualForOf;\n  }\n  set cdkVirtualForOf(value: DataSource<T> | Observable<T[]> | NgIterable<T> | null | undefined) {\n    this._cdkVirtualForOf = value;\n    if (isDataSource(value)) {\n      this._dataSourceChanges.next(value);\n    } else {\n      // If value is an an NgIterable, convert it to an array.\n      this._dataSourceChanges.next(new ArrayDataSource<T>(\n          isObservable(value) ? value : Array.from(value || [])));\n    }\n  }\n\n  _cdkVirtualForOf: DataSource<T> | Observable<T[]> | NgIterable<T> | null | undefined;\n\n  /**\n   * The `TrackByFunction` to use for tracking changes. The `TrackByFunction` takes the index and\n   * the item and produces a value to be used as the item's identity when tracking changes.\n   */\n  @Input()\n  get cdkVirtualForTrackBy(): TrackByFunction<T> | undefined {\n    return this._cdkVirtualForTrackBy;\n  }\n  set cdkVirtualForTrackBy(fn: TrackByFunction<T> | undefined) {\n    this._needsUpdate = true;\n    this._cdkVirtualForTrackBy = fn ?\n        (index, item) => fn(index + (this._renderedRange ? this._renderedRange.start : 0), item) :\n        undefined;\n  }\n  private _cdkVirtualForTrackBy: TrackByFunction<T> | undefined;\n\n  /** The template used to stamp out new elements. */\n  @Input()\n  set cdkVirtualForTemplate(value: TemplateRef<CdkVirtualForOfContext<T>>) {\n    if (value) {\n      this._needsUpdate = true;\n      this._template = value;\n    }\n  }\n\n  /**\n   * The size of the cache used to store templates that are not being used for re-use later.\n   * Setting the cache size to `0` will disable caching. Defaults to 20 templates.\n   */\n  @Input()\n  get cdkVirtualForTemplateCacheSize() {\n    return this._viewRepeater.viewCacheSize;\n  }\n  set cdkVirtualForTemplateCacheSize(size: number) {\n    this._viewRepeater.viewCacheSize = coerceNumberProperty(size);\n  }\n\n  /** Emits whenever the data in the current DataSource changes. */\n  readonly dataStream: Observable<readonly T[]> = this._dataSourceChanges\n  .pipe(\n      // Start off with null `DataSource`.\n      startWith(null),\n      // Bundle up the previous and current data sources so we can work with both.\n      pairwise(),\n      // Use `_changeDataSource` to disconnect from the previous data source and connect to the\n      // new one, passing back a stream of data changes which we run through `switchMap` to give\n      // us a data stream that emits the latest data from whatever the current `DataSource` is.\n      switchMap(([prev, cur]) => this._changeDataSource(prev, cur)),\n      // Replay the last emitted data when someone subscribes.\n      shareReplay(1));\n\n  /** The differ used to calculate changes to the data. */\n  private _differ: IterableDiffer<T> | null = null;\n\n  /** The most recent data emitted from the DataSource. */\n  private _data: readonly T[];\n\n  /** The currently rendered items. */\n  private _renderedItems: T[];\n\n  /** The currently rendered range of indices. */\n  private _renderedRange: ListRange;\n\n  /** Whether the rendered data should be updated during the next ngDoCheck cycle. */\n  private _needsUpdate = false;\n\n  private readonly _destroyed = new Subject<void>();\n\n  constructor(\n      /** The view container to add items to. */\n      private _viewContainerRef: ViewContainerRef,\n      /** The template to use when stamping out new items. */\n      private _template: TemplateRef<CdkVirtualForOfContext<T>>,\n      /** The set of available differs. */\n      private _differs: IterableDiffers,\n      /** The strategy used to render items in the virtual scroll viewport. */\n      @Inject(_VIEW_REPEATER_STRATEGY)\n      private _viewRepeater: _RecycleViewRepeaterStrategy<T, T, CdkVirtualForOfContext<T>>,\n      /** The virtual scrolling viewport that these items are being rendered in. */\n      @SkipSelf() private _viewport: CdkVirtualScrollViewport,\n      ngZone: NgZone) {\n    this.dataStream.subscribe(data => {\n      this._data = data;\n      this._onRenderedDataChange();\n    });\n    this._viewport.renderedRangeStream.pipe(takeUntil(this._destroyed)).subscribe(range => {\n      this._renderedRange = range;\n      ngZone.run(() => this.viewChange.next(this._renderedRange));\n      this._onRenderedDataChange();\n    });\n    this._viewport.attach(this);\n  }\n\n  /**\n   * Measures the combined size (width for horizontal orientation, height for vertical) of all items\n   * in the specified range. Throws an error if the range includes items that are not currently\n   * rendered.\n   */\n  measureRangeSize(range: ListRange, orientation: 'horizontal' | 'vertical'): number {\n    if (range.start >= range.end) {\n      return 0;\n    }\n    if ((range.start < this._renderedRange.start || range.end > this._renderedRange.end) &&\n      (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error(`Error: attempted to measure an item that isn't rendered.`);\n    }\n\n    // The index into the list of rendered views for the first item in the range.\n    const renderedStartIndex = range.start - this._renderedRange.start;\n    // The length of the range we're measuring.\n    const rangeLen = range.end - range.start;\n\n    // Loop over all the views, find the first and land node and compute the size by subtracting\n    // the top of the first node from the bottom of the last one.\n    let firstNode: HTMLElement | undefined;\n    let lastNode: HTMLElement | undefined;\n\n    // Find the first node by starting from the beginning and going forwards.\n    for (let i = 0; i < rangeLen; i++) {\n      const view = this._viewContainerRef.get(i + renderedStartIndex) as\n          EmbeddedViewRef<CdkVirtualForOfContext<T>> | null;\n      if (view && view.rootNodes.length) {\n        firstNode = lastNode = view.rootNodes[0];\n        break;\n      }\n    }\n\n    // Find the last node by starting from the end and going backwards.\n    for (let i = rangeLen - 1; i > -1; i--) {\n      const view = this._viewContainerRef.get(i + renderedStartIndex) as\n          EmbeddedViewRef<CdkVirtualForOfContext<T>> | null;\n      if (view && view.rootNodes.length) {\n        lastNode = view.rootNodes[view.rootNodes.length - 1];\n        break;\n      }\n    }\n\n    return firstNode && lastNode ?\n        getOffset(orientation, 'end', lastNode) - getOffset(orientation, 'start', firstNode) : 0;\n  }\n\n  ngDoCheck() {\n    if (this._differ && this._needsUpdate) {\n      // TODO(mmalerba): We should differentiate needs update due to scrolling and a new portion of\n      // this list being rendered (can use simpler algorithm) vs needs update due to data actually\n      // changing (need to do this diff).\n      const changes = this._differ.diff(this._renderedItems);\n      if (!changes) {\n        this._updateContext();\n      } else {\n        this._applyChanges(changes);\n      }\n      this._needsUpdate = false;\n    }\n  }\n\n  ngOnDestroy() {\n    this._viewport.detach();\n\n    this._dataSourceChanges.next(undefined!);\n    this._dataSourceChanges.complete();\n    this.viewChange.complete();\n\n    this._destroyed.next();\n    this._destroyed.complete();\n    this._viewRepeater.detach();\n  }\n\n  /** React to scroll state changes in the viewport. */\n  private _onRenderedDataChange() {\n    if (!this._renderedRange) {\n      return;\n    }\n    this._renderedItems = this._data.slice(this._renderedRange.start, this._renderedRange.end);\n    if (!this._differ) {\n      // Use a wrapper function for the `trackBy` so any new values are\n      // picked up automatically without having to recreate the differ.\n      this._differ = this._differs.find(this._renderedItems).create((index, item) => {\n        return this.cdkVirtualForTrackBy ? this.cdkVirtualForTrackBy(index, item) : item;\n      });\n    }\n    this._needsUpdate = true;\n  }\n\n  /** Swap out one `DataSource` for another. */\n  private _changeDataSource(oldDs: DataSource<T> | null, newDs: DataSource<T> | null):\n      Observable<readonly T[]> {\n\n    if (oldDs) {\n      oldDs.disconnect(this);\n    }\n\n    this._needsUpdate = true;\n    return newDs ? newDs.connect(this) : observableOf();\n  }\n\n  /** Update the `CdkVirtualForOfContext` for all views. */\n  private _updateContext() {\n    const count = this._data.length;\n    let i = this._viewContainerRef.length;\n    while (i--) {\n      const view = this._viewContainerRef.get(i) as EmbeddedViewRef<CdkVirtualForOfContext<T>>;\n      view.context.index = this._renderedRange.start + i;\n      view.context.count = count;\n      this._updateComputedContextProperties(view.context);\n      view.detectChanges();\n    }\n  }\n\n  /** Apply changes to the DOM. */\n  private _applyChanges(changes: IterableChanges<T>) {\n    this._viewRepeater.applyChanges(\n        changes,\n        this._viewContainerRef,\n        (record: IterableChangeRecord<T>,\n         _adjustedPreviousIndex: number | null,\n         currentIndex: number | null) => this._getEmbeddedViewArgs(record, currentIndex!),\n        (record) => record.item);\n\n    // Update $implicit for any items that had an identity change.\n    changes.forEachIdentityChange((record: IterableChangeRecord<T>) => {\n      const view = this._viewContainerRef.get(record.currentIndex!) as\n          EmbeddedViewRef<CdkVirtualForOfContext<T>>;\n      view.context.$implicit = record.item;\n    });\n\n    // Update the context variables on all items.\n    const count = this._data.length;\n    let i = this._viewContainerRef.length;\n    while (i--) {\n      const view = this._viewContainerRef.get(i) as EmbeddedViewRef<CdkVirtualForOfContext<T>>;\n      view.context.index = this._renderedRange.start + i;\n      view.context.count = count;\n      this._updateComputedContextProperties(view.context);\n    }\n  }\n\n  /** Update the computed properties on the `CdkVirtualForOfContext`. */\n  private _updateComputedContextProperties(context: CdkVirtualForOfContext<any>) {\n    context.first = context.index === 0;\n    context.last = context.index === context.count - 1;\n    context.even = context.index % 2 === 0;\n    context.odd = !context.even;\n  }\n\n  private _getEmbeddedViewArgs(record: IterableChangeRecord<T>, index: number):\n      _ViewRepeaterItemInsertArgs<CdkVirtualForOfContext<T>> {\n    // Note that it's important that we insert the item directly at the proper index,\n    // rather than inserting it and the moving it in place, because if there's a directive\n    // on the same node that injects the `ViewContainerRef`, Angular will insert another\n    // comment node which can throw off the move when it's being repeated for all items.\n    return {\n      templateRef: this._template,\n      context: {\n        $implicit: record.item,\n        // It's guaranteed that the iterable is not \"undefined\" or \"null\" because we only\n        // generate views for elements if the \"cdkVirtualForOf\" iterable has elements.\n        cdkVirtualForOf: this._cdkVirtualForOf!,\n        index: -1,\n        count: -1,\n        first: false,\n        last: false,\n        odd: false,\n        even: false\n      },\n      index,\n    };\n  }\n\n  static ngAcceptInputType_cdkVirtualForTemplateCacheSize: NumberInput;\n}\n"]}
|