@angular/core
Version:
Angular - the core framework
126 lines • 14 kB
JavaScript
/**
* @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 { EventEmitter } from '../event_emitter';
import { flatten } from '../util/array_utils';
import { getSymbolIterator } from '../util/symbol';
function symbolIterator() {
return this._results[getSymbolIterator()]();
}
/**
* An unmodifiable list of items that Angular keeps up to date when the state
* of the application changes.
*
* The type of object that {@link ViewChildren}, {@link ContentChildren}, and {@link QueryList}
* provide.
*
* Implements an iterable interface, therefore it can be used in both ES6
* javascript `for (var i of items)` loops as well as in Angular templates with
* `*ngFor="let i of myList"`.
*
* Changes can be observed by subscribing to the changes `Observable`.
*
* NOTE: In the future this class will implement an `Observable` interface.
*
* @usageNotes
* ### Example
* ```typescript
* @Component({...})
* class Container {
* @ViewChildren(Item) items:QueryList<Item>;
* }
* ```
*
* @publicApi
*/
var QueryList = /** @class */ (function () {
function QueryList() {
this.dirty = true;
this._results = [];
this.changes = new EventEmitter();
this.length = 0;
// This function should be declared on the prototype, but doing so there will cause the class
// declaration to have side-effects and become not tree-shakable. For this reason we do it in
// the constructor.
// [getSymbolIterator()](): Iterator<T> { ... }
var symbol = getSymbolIterator();
var proto = QueryList.prototype;
if (!proto[symbol])
proto[symbol] = symbolIterator;
}
/**
* See
* [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
*/
QueryList.prototype.map = function (fn) { return this._results.map(fn); };
/**
* See
* [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
*/
QueryList.prototype.filter = function (fn) {
return this._results.filter(fn);
};
/**
* See
* [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
*/
QueryList.prototype.find = function (fn) {
return this._results.find(fn);
};
/**
* See
* [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
*/
QueryList.prototype.reduce = function (fn, init) {
return this._results.reduce(fn, init);
};
/**
* See
* [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
*/
QueryList.prototype.forEach = function (fn) { this._results.forEach(fn); };
/**
* See
* [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
*/
QueryList.prototype.some = function (fn) {
return this._results.some(fn);
};
/**
* Returns a copy of the internal results list as an Array.
*/
QueryList.prototype.toArray = function () { return this._results.slice(); };
QueryList.prototype.toString = function () { return this._results.toString(); };
/**
* Updates the stored data of the query list, and resets the `dirty` flag to `false`, so that
* on change detection, it will not notify of changes to the queries, unless a new change
* occurs.
*
* @param resultsTree The results tree to store
*/
QueryList.prototype.reset = function (resultsTree) {
this._results = flatten(resultsTree);
this.dirty = false;
this.length = this._results.length;
this.last = this._results[this.length - 1];
this.first = this._results[0];
};
/**
* Triggers a change event by emitting on the `changes` {@link EventEmitter}.
*/
QueryList.prototype.notifyOnChanges = function () { this.changes.emit(this); };
/** internal */
QueryList.prototype.setDirty = function () { this.dirty = true; };
/** internal */
QueryList.prototype.destroy = function () {
this.changes.complete();
this.changes.unsubscribe();
};
return QueryList;
}());
export { QueryList };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query_list.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/linker/query_list.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 {Observable} from 'rxjs';\n\nimport {EventEmitter} from '../event_emitter';\nimport {flatten} from '../util/array_utils';\nimport {getSymbolIterator} from '../util/symbol';\n\nfunction symbolIterator<T>(this: QueryList<T>): Iterator<T> {\n  return ((this as any as{_results: Array<T>})._results as any)[getSymbolIterator()]();\n}\n\n/**\n * An unmodifiable list of items that Angular keeps up to date when the state\n * of the application changes.\n *\n * The type of object that {@link ViewChildren}, {@link ContentChildren}, and {@link QueryList}\n * provide.\n *\n * Implements an iterable interface, therefore it can be used in both ES6\n * javascript `for (var i of items)` loops as well as in Angular templates with\n * `*ngFor=\"let i of myList\"`.\n *\n * Changes can be observed by subscribing to the changes `Observable`.\n *\n * NOTE: In the future this class will implement an `Observable` interface.\n *\n * @usageNotes\n * ### Example\n * ```typescript\n * @Component({...})\n * class Container {\n *   @ViewChildren(Item) items:QueryList<Item>;\n * }\n * ```\n *\n * @publicApi\n */\nexport class QueryList<T>/* implements Iterable<T> */ {\n  public readonly dirty = true;\n  private _results: Array<T> = [];\n  public readonly changes: Observable<any> = new EventEmitter();\n\n  readonly length: number = 0;\n  // TODO(issue/24571): remove '!'.\n  readonly first !: T;\n  // TODO(issue/24571): remove '!'.\n  readonly last !: T;\n\n  constructor() {\n    // This function should be declared on the prototype, but doing so there will cause the class\n    // declaration to have side-effects and become not tree-shakable. For this reason we do it in\n    // the constructor.\n    // [getSymbolIterator()](): Iterator<T> { ... }\n    const symbol = getSymbolIterator();\n    const proto = QueryList.prototype as any;\n    if (!proto[symbol]) proto[symbol] = symbolIterator;\n  }\n\n  /**\n   * See\n   * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n   */\n  map<U>(fn: (item: T, index: number, array: T[]) => U): U[] { return this._results.map(fn); }\n\n  /**\n   * See\n   * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n   */\n  filter(fn: (item: T, index: number, array: T[]) => boolean): T[] {\n    return this._results.filter(fn);\n  }\n\n  /**\n   * See\n   * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)\n   */\n  find(fn: (item: T, index: number, array: T[]) => boolean): T|undefined {\n    return this._results.find(fn);\n  }\n\n  /**\n   * See\n   * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)\n   */\n  reduce<U>(fn: (prevValue: U, curValue: T, curIndex: number, array: T[]) => U, init: U): U {\n    return this._results.reduce(fn, init);\n  }\n\n  /**\n   * See\n   * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)\n   */\n  forEach(fn: (item: T, index: number, array: T[]) => void): void { this._results.forEach(fn); }\n\n  /**\n   * See\n   * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)\n   */\n  some(fn: (value: T, index: number, array: T[]) => boolean): boolean {\n    return this._results.some(fn);\n  }\n\n  /**\n   * Returns a copy of the internal results list as an Array.\n   */\n  toArray(): T[] { return this._results.slice(); }\n\n  toString(): string { return this._results.toString(); }\n\n  /**\n   * Updates the stored data of the query list, and resets the `dirty` flag to `false`, so that\n   * on change detection, it will not notify of changes to the queries, unless a new change\n   * occurs.\n   *\n   * @param resultsTree The results tree to store\n   */\n  reset(resultsTree: Array<T|any[]>): void {\n    this._results = flatten(resultsTree);\n    (this as{dirty: boolean}).dirty = false;\n    (this as{length: number}).length = this._results.length;\n    (this as{last: T}).last = this._results[this.length - 1];\n    (this as{first: T}).first = this._results[0];\n  }\n\n  /**\n   * Triggers a change event by emitting on the `changes` {@link EventEmitter}.\n   */\n  notifyOnChanges(): void { (this.changes as EventEmitter<any>).emit(this); }\n\n  /** internal */\n  setDirty() { (this as{dirty: boolean}).dirty = true; }\n\n  /** internal */\n  destroy(): void {\n    (this.changes as EventEmitter<any>).complete();\n    (this.changes as EventEmitter<any>).unsubscribe();\n  }\n}\n"]}