@angular/core
Version:
Angular - the core framework
170 lines • 19 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { EventEmitter } from '../event_emitter';
import { arrayEquals, flatten } from '../util/array_utils';
function symbolIterator() {
// @ts-expect-error accessing a private member
return this._results[Symbol.iterator]();
}
/**
* 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
*/
export class QueryList {
static { Symbol.iterator; }
/**
* Returns `Observable` of `QueryList` notifying the subscriber of changes.
*/
get changes() {
return (this._changes ??= new EventEmitter());
}
/**
* @param emitDistinctChangesOnly Whether `QueryList.changes` should fire only when actual change
* has occurred. Or if it should fire when query is recomputed. (recomputing could resolve in
* the same result)
*/
constructor(_emitDistinctChangesOnly = false) {
this._emitDistinctChangesOnly = _emitDistinctChangesOnly;
this.dirty = true;
this._onDirty = undefined;
this._results = [];
this._changesDetected = false;
this._changes = undefined;
this.length = 0;
this.first = undefined;
this.last = undefined;
// 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.
// [Symbol.iterator](): Iterator<T> { ... }
const proto = QueryList.prototype;
if (!proto[Symbol.iterator])
proto[Symbol.iterator] = symbolIterator;
}
/**
* Returns the QueryList entry at `index`.
*/
get(index) {
return this._results[index];
}
/**
* See
* [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
*/
map(fn) {
return this._results.map(fn);
}
filter(fn) {
return this._results.filter(fn);
}
/**
* See
* [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
*/
find(fn) {
return this._results.find(fn);
}
/**
* See
* [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
*/
reduce(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)
*/
forEach(fn) {
this._results.forEach(fn);
}
/**
* See
* [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
*/
some(fn) {
return this._results.some(fn);
}
/**
* Returns a copy of the internal results list as an Array.
*/
toArray() {
return this._results.slice();
}
toString() {
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 query results to store
* @param identityAccessor Optional function for extracting stable object identity from a value
* in the array. This function is executed for each element of the query result list while
* comparing current query list with the new one (provided as a first argument of the `reset`
* function) to detect if the lists are different. If the function is not provided, elements
* are compared as is (without any pre-processing).
*/
reset(resultsTree, identityAccessor) {
this.dirty = false;
const newResultFlat = flatten(resultsTree);
if ((this._changesDetected = !arrayEquals(this._results, newResultFlat, identityAccessor))) {
this._results = newResultFlat;
this.length = newResultFlat.length;
this.last = newResultFlat[this.length - 1];
this.first = newResultFlat[0];
}
}
/**
* Triggers a change event by emitting on the `changes` {@link EventEmitter}.
*/
notifyOnChanges() {
if (this._changes !== undefined && (this._changesDetected || !this._emitDistinctChangesOnly))
this._changes.emit(this);
}
/** @internal */
onDirty(cb) {
this._onDirty = cb;
}
/** internal */
setDirty() {
this.dirty = true;
this._onDirty?.();
}
/** internal */
destroy() {
if (this._changes !== undefined) {
this._changes.complete();
this._changes.unsubscribe();
}
}
}
//# 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 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 {Observable} from 'rxjs';\n\nimport {EventEmitter} from '../event_emitter';\nimport {Writable} from '../interface/type';\nimport {arrayEquals, flatten} from '../util/array_utils';\n\nfunction symbolIterator<T>(this: QueryList<T>): Iterator<T> {\n  // @ts-expect-error accessing a private member\n  return this._results[Symbol.iterator]();\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 _onDirty?: () => void = undefined;\n  private _results: Array<T> = [];\n  private _changesDetected: boolean = false;\n  private _changes: EventEmitter<QueryList<T>> | undefined = undefined;\n\n  readonly length: number = 0;\n  readonly first: T = undefined!;\n  readonly last: T = undefined!;\n\n  /**\n   * Returns `Observable` of `QueryList` notifying the subscriber of changes.\n   */\n  get changes(): Observable<any> {\n    return (this._changes ??= new EventEmitter());\n  }\n\n  /**\n   * @param emitDistinctChangesOnly Whether `QueryList.changes` should fire only when actual change\n   *     has occurred. Or if it should fire when query is recomputed. (recomputing could resolve in\n   *     the same result)\n   */\n  constructor(private _emitDistinctChangesOnly: boolean = false) {\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    // [Symbol.iterator](): Iterator<T> { ... }\n    const proto = QueryList.prototype;\n    if (!proto[Symbol.iterator]) proto[Symbol.iterator] = symbolIterator;\n  }\n\n  /**\n   * Returns the QueryList entry at `index`.\n   */\n  get(index: number): T | undefined {\n    return this._results[index];\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[] {\n    return this._results.map(fn);\n  }\n\n  /**\n   * See\n   * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n   */\n  filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S): S[];\n  filter(predicate: (value: T, index: number, array: readonly T[]) => unknown): T[];\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 {\n    this._results.forEach(fn);\n  }\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[] {\n    return this._results.slice();\n  }\n\n  toString(): string {\n    return this._results.toString();\n  }\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 query results to store\n   * @param identityAccessor Optional function for extracting stable object identity from a value\n   *    in the array. This function is executed for each element of the query result list while\n   *    comparing current query list with the new one (provided as a first argument of the `reset`\n   *    function) to detect if the lists are different. If the function is not provided, elements\n   *    are compared as is (without any pre-processing).\n   */\n  reset(resultsTree: Array<T | any[]>, identityAccessor?: (value: T) => unknown): void {\n    (this as {dirty: boolean}).dirty = false;\n    const newResultFlat = flatten(resultsTree);\n    if ((this._changesDetected = !arrayEquals(this._results, newResultFlat, identityAccessor))) {\n      this._results = newResultFlat;\n      (this as Writable<this>).length = newResultFlat.length;\n      (this as Writable<this>).last = newResultFlat[this.length - 1];\n      (this as Writable<this>).first = newResultFlat[0];\n    }\n  }\n\n  /**\n   * Triggers a change event by emitting on the `changes` {@link EventEmitter}.\n   */\n  notifyOnChanges(): void {\n    if (this._changes !== undefined && (this._changesDetected || !this._emitDistinctChangesOnly))\n      this._changes.emit(this);\n  }\n\n  /** @internal */\n  onDirty(cb: () => void) {\n    this._onDirty = cb;\n  }\n\n  /** internal */\n  setDirty() {\n    (this as {dirty: boolean}).dirty = true;\n    this._onDirty?.();\n  }\n\n  /** internal */\n  destroy(): void {\n    if (this._changes !== undefined) {\n      this._changes.complete();\n      this._changes.unsubscribe();\n    }\n  }\n\n  // The implementation of `Symbol.iterator` should be declared here, but this would cause\n  // tree-shaking issues with `QueryList. So instead, it's added in the constructor (see comments\n  // there) and this declaration is left here to ensure that TypeScript considers QueryList to\n  // implement the Iterable interface. This is required for template type-checking of NgFor loops\n  // over QueryLists to work correctly, since QueryList must be assignable to NgIterable.\n  [Symbol.iterator]!: () => Iterator<T>;\n}\n"]}