@angular/common
Version:
Angular - commonly needed directives and services
405 lines • 35.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. 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 { Directive, Input, IterableDiffers, TemplateRef, ViewContainerRef, isDevMode } from '@angular/core';
/**
* \@publicApi
* @template T
*/
export class NgForOfContext {
/**
* @param {?} $implicit
* @param {?} ngForOf
* @param {?} index
* @param {?} count
*/
constructor($implicit, ngForOf, index, count) {
this.$implicit = $implicit;
this.ngForOf = ngForOf;
this.index = index;
this.count = count;
}
/**
* @return {?}
*/
get first() { return this.index === 0; }
/**
* @return {?}
*/
get last() { return this.index === this.count - 1; }
/**
* @return {?}
*/
get even() { return this.index % 2 === 0; }
/**
* @return {?}
*/
get odd() { return !this.even; }
}
if (false) {
/** @type {?} */
NgForOfContext.prototype.$implicit;
/** @type {?} */
NgForOfContext.prototype.ngForOf;
/** @type {?} */
NgForOfContext.prototype.index;
/** @type {?} */
NgForOfContext.prototype.count;
}
/**
* A [structural directive](guide/structural-directives) that renders
* a template for each item in a collection.
* The directive is placed on an element, which becomes the parent
* of the cloned templates.
*
* The `ngForOf` directive is generally used in the
* [shorthand form](guide/structural-directives#the-asterisk--prefix) `*ngFor`.
* In this form, the template to be rendered for each iteration is the content
* of an anchor element containing the directive.
*
* The following example shows the shorthand syntax with some options,
* contained in an `<li>` element.
*
* ```
* <li *ngFor="let item of items; index as i; trackBy: trackByFn">...</li>
* ```
*
* The shorthand form expands into a long form that uses the `ngForOf` selector
* on an `<ng-template>` element.
* The content of the `<ng-template>` element is the `<li>` element that held the
* short-form directive.
*
* Here is the expanded version of the short-form example.
*
* ```
* <ng-template ngFor let-item [ngForOf]="items" let-i="index" [ngForTrackBy]="trackByFn">
* <li>...</li>
* </ng-template>
* ```
*
* Angular automatically expands the shorthand syntax as it compiles the template.
* The context for each embedded view is logically merged to the current component
* context according to its lexical position.
*
* When using the shorthand syntax, Angular allows only [one structural directive
* on an element](guide/structural-directives#one-structural-directive-per-host-element).
* If you want to iterate conditionally, for example,
* put the `*ngIf` on a container element that wraps the `*ngFor` element.
* For futher discussion, see
* [Structural Directives](guide/structural-directives#one-per-element).
*
* \@usageNotes
*
* ### Local variables
*
* `NgForOf` provides exported values that can be aliased to local variables.
* For example:
*
* ```
* <li *ngFor="let user of userObservable | async as users; index as i; first as isFirst">
* {{i}}/{{users.length}}. {{user}} <span *ngIf="isFirst">default</span>
* </li>
* ```
*
* The following exported values can be aliased to local variables:
*
* - `$implicit: T`: The value of the individual items in the iterable (`ngForOf`).
* - `ngForOf: NgIterable<T>`: The value of the iterable expression. Useful when the expression is
* more complex then a property access, for example when using the async pipe (`userStreams |
* async`).
* - `index: number`: The index of the current item in the iterable.
* - `first: boolean`: True when the item is the first item in the iterable.
* - `last: boolean`: True when the item is the last item in the iterable.
* - `even: boolean`: True when the item has an even index in the iterable.
* - `odd: boolean`: True when the item has an odd index in the iterable.
*
* ### Change propagation
*
* When the contents of the iterator changes, `NgForOf` makes the corresponding changes to the DOM:
*
* * When an item is added, a new instance of the template is added to the DOM.
* * When an item is removed, its template instance is removed from the DOM.
* * When items are reordered, their respective templates are reordered in the DOM.
*
* Angular uses object identity to track insertions and deletions within the iterator and reproduce
* those changes in the DOM. This has important implications for animations and any stateful
* controls that are present, such as `<input>` elements that accept user input. Inserted rows can
* be animated in, deleted rows can be animated out, and unchanged rows retain any unsaved state
* such as user input.
* For more on animations, see [Transitions and Triggers](guide/transition-and-triggers).
*
* The identities of elements in the iterator can change while the data does not.
* This can happen, for example, if the iterator is produced from an RPC to the server, and that
* RPC is re-run. Even if the data hasn't changed, the second response produces objects with
* different identities, and Angular must tear down the entire DOM and rebuild it (as if all old
* elements were deleted and all new elements inserted).
*
* To avoid this expensive operation, you can customize the default tracking algorithm.
* by supplying the `trackBy` option to `NgForOf`.
* `trackBy` takes a function that has two arguments: `index` and `item`.
* If `trackBy` is given, Angular tracks changes by the return value of the function.
*
* @see [Structural Directives](guide/structural-directives)
* \@ngModule CommonModule
* \@publicApi
* @template T
*/
export class NgForOf {
/**
* @param {?} _viewContainer
* @param {?} _template
* @param {?} _differs
*/
constructor(_viewContainer, _template, _differs) {
this._viewContainer = _viewContainer;
this._template = _template;
this._differs = _differs;
this._ngForOfDirty = true;
this._differ = null;
}
/**
* The value of the iterable expression, which can be used as a
* [template input variable](guide/structural-directives#template-input-variable).
* @param {?} ngForOf
* @return {?}
*/
set ngForOf(ngForOf) {
this._ngForOf = ngForOf;
this._ngForOfDirty = true;
}
/**
* A function that defines how to track changes for items in the iterable.
*
* When items are added, moved, or removed in the iterable,
* the directive must re-render the appropriate DOM nodes.
* To minimize churn in the DOM, only nodes that have changed
* are re-rendered.
*
* By default, the change detector assumes that
* the object instance identifies the node in the iterable.
* When this function is supplied, the directive uses
* the result of calling this function to identify the item node,
* rather than the identity of the object itself.
*
* The function receives two inputs,
* the iteration index and the node object ID.
* @param {?} fn
* @return {?}
*/
set ngForTrackBy(fn) {
if (isDevMode() && fn != null && typeof fn !== 'function') {
// TODO(vicb): use a log service once there is a public one available
if ((/** @type {?} */ (console)) && (/** @type {?} */ (console.warn))) {
console.warn(`trackBy must be a function, but received ${JSON.stringify(fn)}. ` +
`See https://angular.io/docs/ts/latest/api/common/index/NgFor-directive.html#!#change-propagation for more information.`);
}
}
this._trackByFn = fn;
}
/**
* @return {?}
*/
get ngForTrackBy() { return this._trackByFn; }
/**
* A reference to the template that is stamped out for each item in the iterable.
* @see [template reference variable](guide/template-syntax#template-reference-variables--var-)
* @param {?} value
* @return {?}
*/
set ngForTemplate(value) {
// TODO(TS2.1): make TemplateRef<Partial<NgForRowOf<T>>> once we move to TS v2.1
// The current type is too restrictive; a template that just uses index, for example,
// should be acceptable.
if (value) {
this._template = value;
}
}
/**
* Applies the changes when needed.
* @return {?}
*/
ngDoCheck() {
if (this._ngForOfDirty) {
this._ngForOfDirty = false;
// React on ngForOf changes only once all inputs have been initialized
/** @type {?} */
const value = this._ngForOf;
if (!this._differ && value) {
try {
this._differ = this._differs.find(value).create(this.ngForTrackBy);
}
catch (_a) {
throw new Error(`Cannot find a differ supporting object '${value}' of type '${getTypeName(value)}'. NgFor only supports binding to Iterables such as Arrays.`);
}
}
}
if (this._differ) {
/** @type {?} */
const changes = this._differ.diff(this._ngForOf);
if (changes)
this._applyChanges(changes);
}
}
/**
* @private
* @param {?} changes
* @return {?}
*/
_applyChanges(changes) {
/** @type {?} */
const insertTuples = [];
changes.forEachOperation((/**
* @param {?} item
* @param {?} adjustedPreviousIndex
* @param {?} currentIndex
* @return {?}
*/
(item, adjustedPreviousIndex, currentIndex) => {
if (item.previousIndex == null) {
/** @type {?} */
const view = this._viewContainer.createEmbeddedView(this._template, new NgForOfContext((/** @type {?} */ (null)), this._ngForOf, -1, -1), currentIndex === null ? undefined : currentIndex);
/** @type {?} */
const tuple = new RecordViewTuple(item, view);
insertTuples.push(tuple);
}
else if (currentIndex == null) {
this._viewContainer.remove(adjustedPreviousIndex === null ? undefined : adjustedPreviousIndex);
}
else if (adjustedPreviousIndex !== null) {
/** @type {?} */
const view = (/** @type {?} */ (this._viewContainer.get(adjustedPreviousIndex)));
this._viewContainer.move(view, currentIndex);
/** @type {?} */
const tuple = new RecordViewTuple(item, (/** @type {?} */ (view)));
insertTuples.push(tuple);
}
}));
for (let i = 0; i < insertTuples.length; i++) {
this._perViewChange(insertTuples[i].view, insertTuples[i].record);
}
for (let i = 0, ilen = this._viewContainer.length; i < ilen; i++) {
/** @type {?} */
const viewRef = (/** @type {?} */ (this._viewContainer.get(i)));
viewRef.context.index = i;
viewRef.context.count = ilen;
viewRef.context.ngForOf = this._ngForOf;
}
changes.forEachIdentityChange((/**
* @param {?} record
* @return {?}
*/
(record) => {
/** @type {?} */
const viewRef = (/** @type {?} */ (this._viewContainer.get(record.currentIndex)));
viewRef.context.$implicit = record.item;
}));
}
/**
* @private
* @param {?} view
* @param {?} record
* @return {?}
*/
_perViewChange(view, record) {
view.context.$implicit = record.item;
}
/**
* Asserts the correct type of the context for the template that `NgForOf` will render.
*
* The presence of this method is a signal to the Ivy template type-check compiler that the
* `NgForOf` structural directive renders its template with a specific context type.
* @template T
* @param {?} dir
* @param {?} ctx
* @return {?}
*/
static ngTemplateContextGuard(dir, ctx) {
return true;
}
}
NgForOf.decorators = [
{ type: Directive, args: [{ selector: '[ngFor][ngForOf]' },] }
];
/** @nocollapse */
NgForOf.ctorParameters = () => [
{ type: ViewContainerRef },
{ type: TemplateRef },
{ type: IterableDiffers }
];
NgForOf.propDecorators = {
ngForOf: [{ type: Input }],
ngForTrackBy: [{ type: Input }],
ngForTemplate: [{ type: Input }]
};
if (false) {
/**
* @type {?}
* @private
*/
NgForOf.prototype._ngForOf;
/**
* @type {?}
* @private
*/
NgForOf.prototype._ngForOfDirty;
/**
* @type {?}
* @private
*/
NgForOf.prototype._differ;
/**
* @type {?}
* @private
*/
NgForOf.prototype._trackByFn;
/**
* @type {?}
* @private
*/
NgForOf.prototype._viewContainer;
/**
* @type {?}
* @private
*/
NgForOf.prototype._template;
/**
* @type {?}
* @private
*/
NgForOf.prototype._differs;
}
/**
* @template T
*/
class RecordViewTuple {
/**
* @param {?} record
* @param {?} view
*/
constructor(record, view) {
this.record = record;
this.view = view;
}
}
if (false) {
/** @type {?} */
RecordViewTuple.prototype.record;
/** @type {?} */
RecordViewTuple.prototype.view;
}
/**
* @param {?} type
* @return {?}
*/
function getTypeName(type) {
return type['name'] || typeof type;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng_for_of.js","sourceRoot":"","sources":["../../../../../../../packages/common/src/directives/ng_for_of.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {Directive, DoCheck, EmbeddedViewRef, Input, IterableChangeRecord, IterableChanges, IterableDiffer, IterableDiffers, NgIterable, TemplateRef, TrackByFunction, ViewContainerRef, forwardRef, isDevMode} from '@angular/core';\n\n/**\n * @publicApi\n */\nexport class NgForOfContext<T> {\n  constructor(\n      public $implicit: T, public ngForOf: NgIterable<T>, public index: number,\n      public count: number) {}\n\n  get first(): boolean { return this.index === 0; }\n\n  get last(): boolean { return this.index === this.count - 1; }\n\n  get even(): boolean { return this.index % 2 === 0; }\n\n  get odd(): boolean { return !this.even; }\n}\n\n/**\n * A [structural directive](guide/structural-directives) that renders\n * a template for each item in a collection.\n * The directive is placed on an element, which becomes the parent\n * of the cloned templates.\n *\n * The `ngForOf` directive is generally used in the\n * [shorthand form](guide/structural-directives#the-asterisk--prefix) `*ngFor`.\n * In this form, the template to be rendered for each iteration is the content\n * of an anchor element containing the directive.\n *\n * The following example shows the shorthand syntax with some options,\n * contained in an `<li>` element.\n *\n * ```\n * <li *ngFor=\"let item of items; index as i; trackBy: trackByFn\">...</li>\n * ```\n *\n * The shorthand form expands into a long form that uses the `ngForOf` selector\n * on an `<ng-template>` element.\n * The content of the `<ng-template>` element is the `<li>` element that held the\n * short-form directive.\n *\n * Here is the expanded version of the short-form example.\n *\n * ```\n * <ng-template ngFor let-item [ngForOf]=\"items\" let-i=\"index\" [ngForTrackBy]=\"trackByFn\">\n *   <li>...</li>\n * </ng-template>\n * ```\n *\n * Angular automatically expands the shorthand syntax as it compiles the template.\n * The context for each embedded view is logically merged to the current component\n * context according to its lexical position.\n *\n * When using the shorthand syntax, Angular allows only [one structural directive\n * on an element](guide/structural-directives#one-structural-directive-per-host-element).\n * If you want to iterate conditionally, for example,\n * put the `*ngIf` on a container element that wraps the `*ngFor` element.\n * For futher discussion, see\n * [Structural Directives](guide/structural-directives#one-per-element).\n *\n * @usageNotes\n *\n * ### Local variables\n *\n * `NgForOf` provides exported values that can be aliased to local variables.\n * For example:\n *\n *  ```\n * <li *ngFor=\"let user of userObservable | async as users; index as i; first as isFirst\">\n *    {{i}}/{{users.length}}. {{user}} <span *ngIf=\"isFirst\">default</span>\n * </li>\n * ```\n *\n * The following exported values can be aliased to local variables:\n *\n * - `$implicit: T`: The value of the individual items in the iterable (`ngForOf`).\n * - `ngForOf: NgIterable<T>`: The value of the iterable expression. Useful when the expression is\n * more complex then a property access, for example when using the async pipe (`userStreams |\n * async`).\n * - `index: number`: The index of the current item in the iterable.\n * - `first: boolean`: True when the item is the first item in the iterable.\n * - `last: boolean`: True when the item is the last item in the iterable.\n * - `even: boolean`: True when the item has an even index in the iterable.\n * - `odd: boolean`: True when the item has an odd index in the iterable.\n *\n * ### Change propagation\n *\n * When the contents of the iterator changes, `NgForOf` makes the corresponding changes to the DOM:\n *\n * * When an item is added, a new instance of the template is added to the DOM.\n * * When an item is removed, its template instance is removed from the DOM.\n * * When items are reordered, their respective templates are reordered in the DOM.\n *\n * Angular uses object identity to track insertions and deletions within the iterator and reproduce\n * those changes in the DOM. This has important implications for animations and any stateful\n * controls that are present, such as `<input>` elements that accept user input. Inserted rows can\n * be animated in, deleted rows can be animated out, and unchanged rows retain any unsaved state\n * such as user input.\n * For more on animations, see [Transitions and Triggers](guide/transition-and-triggers).\n *\n * The identities of elements in the iterator can change while the data does not.\n * This can happen, for example, if the iterator is produced from an RPC to the server, and that\n * RPC is re-run. Even if the data hasn't changed, the second response produces objects with\n * different identities, and Angular must tear down the entire DOM and rebuild it (as if all old\n * elements were deleted and all new elements inserted).\n *\n * To avoid this expensive operation, you can customize the default tracking algorithm.\n * by supplying the `trackBy` option to `NgForOf`.\n * `trackBy` takes a function that has two arguments: `index` and `item`.\n * If `trackBy` is given, Angular tracks changes by the return value of the function.\n *\n * @see [Structural Directives](guide/structural-directives)\n * @ngModule CommonModule\n * @publicApi\n */\n@Directive({selector: '[ngFor][ngForOf]'})\nexport class NgForOf<T> implements DoCheck {\n  /**\n   * The value of the iterable expression, which can be used as a\n   * [template input variable](guide/structural-directives#template-input-variable).\n   */\n  @Input()\n  set ngForOf(ngForOf: NgIterable<T>) {\n    this._ngForOf = ngForOf;\n    this._ngForOfDirty = true;\n  }\n  /**\n   * A function that defines how to track changes for items in the iterable.\n   *\n   * When items are added, moved, or removed in the iterable,\n   * the directive must re-render the appropriate DOM nodes.\n   * To minimize churn in the DOM, only nodes that have changed\n   * are re-rendered.\n   *\n   * By default, the change detector assumes that\n   * the object instance identifies the node in the iterable.\n   * When this function is supplied, the directive uses\n   * the result of calling this function to identify the item node,\n   * rather than the identity of the object itself.\n   *\n   * The function receives two inputs,\n   * the iteration index and the node object ID.\n   */\n  @Input()\n  set ngForTrackBy(fn: TrackByFunction<T>) {\n    if (isDevMode() && fn != null && typeof fn !== 'function') {\n      // TODO(vicb): use a log service once there is a public one available\n      if (<any>console && <any>console.warn) {\n        console.warn(\n            `trackBy must be a function, but received ${JSON.stringify(fn)}. ` +\n            `See https://angular.io/docs/ts/latest/api/common/index/NgFor-directive.html#!#change-propagation for more information.`);\n      }\n    }\n    this._trackByFn = fn;\n  }\n\n  get ngForTrackBy(): TrackByFunction<T> { return this._trackByFn; }\n\n  // TODO(issue/24571): remove '!'.\n  private _ngForOf !: NgIterable<T>;\n  private _ngForOfDirty: boolean = true;\n  private _differ: IterableDiffer<T>|null = null;\n  // TODO(issue/24571): remove '!'.\n  private _trackByFn !: TrackByFunction<T>;\n\n  constructor(\n      private _viewContainer: ViewContainerRef, private _template: TemplateRef<NgForOfContext<T>>,\n      private _differs: IterableDiffers) {}\n\n  /**\n   * A reference to the template that is stamped out for each item in the iterable.\n   * @see [template reference variable](guide/template-syntax#template-reference-variables--var-)\n   */\n  @Input()\n  set ngForTemplate(value: TemplateRef<NgForOfContext<T>>) {\n    // TODO(TS2.1): make TemplateRef<Partial<NgForRowOf<T>>> once we move to TS v2.1\n    // The current type is too restrictive; a template that just uses index, for example,\n    // should be acceptable.\n    if (value) {\n      this._template = value;\n    }\n  }\n\n  /**\n   * Applies the changes when needed.\n   */\n  ngDoCheck(): void {\n    if (this._ngForOfDirty) {\n      this._ngForOfDirty = false;\n      // React on ngForOf changes only once all inputs have been initialized\n      const value = this._ngForOf;\n      if (!this._differ && value) {\n        try {\n          this._differ = this._differs.find(value).create(this.ngForTrackBy);\n        } catch {\n          throw new Error(\n              `Cannot find a differ supporting object '${value}' of type '${getTypeName(value)}'. NgFor only supports binding to Iterables such as Arrays.`);\n        }\n      }\n    }\n    if (this._differ) {\n      const changes = this._differ.diff(this._ngForOf);\n      if (changes) this._applyChanges(changes);\n    }\n  }\n\n  private _applyChanges(changes: IterableChanges<T>) {\n    const insertTuples: RecordViewTuple<T>[] = [];\n    changes.forEachOperation(\n        (item: IterableChangeRecord<any>, adjustedPreviousIndex: number | null,\n         currentIndex: number | null) => {\n          if (item.previousIndex == null) {\n            const view = this._viewContainer.createEmbeddedView(\n                this._template, new NgForOfContext<T>(null !, this._ngForOf, -1, -1),\n                currentIndex === null ? undefined : currentIndex);\n            const tuple = new RecordViewTuple<T>(item, view);\n            insertTuples.push(tuple);\n          } else if (currentIndex == null) {\n            this._viewContainer.remove(\n                adjustedPreviousIndex === null ? undefined : adjustedPreviousIndex);\n          } else if (adjustedPreviousIndex !== null) {\n            const view = this._viewContainer.get(adjustedPreviousIndex) !;\n            this._viewContainer.move(view, currentIndex);\n            const tuple = new RecordViewTuple(item, <EmbeddedViewRef<NgForOfContext<T>>>view);\n            insertTuples.push(tuple);\n          }\n        });\n\n    for (let i = 0; i < insertTuples.length; i++) {\n      this._perViewChange(insertTuples[i].view, insertTuples[i].record);\n    }\n\n    for (let i = 0, ilen = this._viewContainer.length; i < ilen; i++) {\n      const viewRef = <EmbeddedViewRef<NgForOfContext<T>>>this._viewContainer.get(i);\n      viewRef.context.index = i;\n      viewRef.context.count = ilen;\n      viewRef.context.ngForOf = this._ngForOf;\n    }\n\n    changes.forEachIdentityChange((record: any) => {\n      const viewRef =\n          <EmbeddedViewRef<NgForOfContext<T>>>this._viewContainer.get(record.currentIndex);\n      viewRef.context.$implicit = record.item;\n    });\n  }\n\n  private _perViewChange(\n      view: EmbeddedViewRef<NgForOfContext<T>>, record: IterableChangeRecord<any>) {\n    view.context.$implicit = record.item;\n  }\n\n  /**\n   * Asserts the correct type of the context for the template that `NgForOf` will render.\n   *\n   * The presence of this method is a signal to the Ivy template type-check compiler that the\n   * `NgForOf` structural directive renders its template with a specific context type.\n   */\n  static ngTemplateContextGuard<T>(dir: NgForOf<T>, ctx: any): ctx is NgForOfContext<T> {\n    return true;\n  }\n}\n\nclass RecordViewTuple<T> {\n  constructor(public record: any, public view: EmbeddedViewRef<NgForOfContext<T>>) {}\n}\n\nfunction getTypeName(type: any): string {\n  return type['name'] || typeof type;\n}\n"]}