@angular/core
Version:
Angular - the core framework
232 lines • 19.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: packages/core/src/render3/interfaces/query.ts
* @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
*/
/**
* An object representing query metadata extracted from query annotations.
* @record
*/
export function TQueryMetadata() { }
if (false) {
/** @type {?} */
TQueryMetadata.prototype.predicate;
/** @type {?} */
TQueryMetadata.prototype.descendants;
/** @type {?} */
TQueryMetadata.prototype.read;
/** @type {?} */
TQueryMetadata.prototype.isStatic;
}
/**
* TQuery objects represent all the query-related data that remain the same from one view instance
* to another and can be determined on the very first template pass. Most notably TQuery holds all
* the matches for a given view.
* @record
*/
export function TQuery() { }
if (false) {
/**
* Query metadata extracted from query annotations.
* @type {?}
*/
TQuery.prototype.metadata;
/**
* Index of a query in a declaration view in case of queries propagated to en embedded view, -1
* for queries declared in a given view. We are storing this index so we can find a parent query
* to clone for an embedded view (when an embedded view is created).
* @type {?}
*/
TQuery.prototype.indexInDeclarationView;
/**
* Matches collected on the first template pass. Each match is a pair of:
* - TNode index;
* - match index;
*
* A TNode index can be either:
* - a positive number (the most common case) to indicate a matching TNode;
* - a negative number to indicate that a given query is crossing a <ng-template> element and
* results from views created based on TemplateRef should be inserted at this place.
*
* A match index is a number used to find an actual value (for a given node) when query results
* are materialized. This index can have one of the following values:
* - -2 - indicates that we need to read a special token (TemplateRef, ViewContainerRef etc.);
* - -1 - indicates that we need to read a default value based on the node type (TemplateRef for
* ng-template and ElementRef for other elements);
* - a positive number - index of an injectable to be read from the element injector.
* @type {?}
*/
TQuery.prototype.matches;
/**
* A flag indicating if a given query crosses an <ng-template> element. This flag exists for
* performance reasons: we can notice that queries not crossing any <ng-template> elements will
* have matches from a given view only (and adapt processing accordingly).
* @type {?}
*/
TQuery.prototype.crossesNgTemplate;
/**
* A method call when a given query is crossing an element (or element container). This is where a
* given TNode is matched against a query predicate.
* @param {?} tView
* @param {?} tNode
* @return {?}
*/
TQuery.prototype.elementStart = function (tView, tNode) { };
/**
* A method called when processing the elementEnd instruction - this is mostly useful to determine
* if a given content query should match any nodes past this point.
* @param {?} tNode
* @return {?}
*/
TQuery.prototype.elementEnd = function (tNode) { };
/**
* A method called when processing the template instruction. This is where a
* given TContainerNode is matched against a query predicate.
* @param {?} tView
* @param {?} tNode
* @return {?}
*/
TQuery.prototype.template = function (tView, tNode) { };
/**
* A query-related method called when an embedded TView is created based on the content of a
* <ng-template> element. We call this method to determine if a given query should be propagated
* to the embedded view and if so - return a cloned TQuery for this embedded view.
* @param {?} tNode
* @param {?} childQueryIndex
* @return {?}
*/
TQuery.prototype.embeddedTView = function (tNode, childQueryIndex) { };
}
/**
* TQueries represent a collection of individual TQuery objects tracked in a given view. Most of the
* methods on this interface are simple proxy methods to the corresponding functionality on TQuery.
* @record
*/
export function TQueries() { }
if (false) {
/**
* Returns the number of queries tracked in a given view.
* @type {?}
*/
TQueries.prototype.length;
/**
* Adds a new TQuery to a collection of queries tracked in a given view.
* @param {?} tQuery
* @return {?}
*/
TQueries.prototype.track = function (tQuery) { };
/**
* Returns a TQuery instance for at the given index in the queries array.
* @param {?} index
* @return {?}
*/
TQueries.prototype.getByIndex = function (index) { };
/**
* A proxy method that iterates over all the TQueries in a given TView and calls the corresponding
* `elementStart` on each and every TQuery.
* @param {?} tView
* @param {?} tNode
* @return {?}
*/
TQueries.prototype.elementStart = function (tView, tNode) { };
/**
* A proxy method that iterates over all the TQueries in a given TView and calls the corresponding
* `elementEnd` on each and every TQuery.
* @param {?} tNode
* @return {?}
*/
TQueries.prototype.elementEnd = function (tNode) { };
/**
* A proxy method that iterates over all the TQueries in a given TView and calls the corresponding
* `template` on each and every TQuery.
* @param {?} tView
* @param {?} tNode
* @return {?}
*/
TQueries.prototype.template = function (tView, tNode) { };
/**
* A proxy method that iterates over all the TQueries in a given TView and calls the corresponding
* `embeddedTView` on each and every TQuery.
* @param {?} tNode
* @return {?}
*/
TQueries.prototype.embeddedTView = function (tNode) { };
}
/**
* An interface that represents query-related information specific to a view instance. Most notably
* it contains:
* - materialized query matches;
* - a pointer to a QueryList where materialized query results should be reported.
* @record
* @template T
*/
export function LQuery() { }
if (false) {
/**
* Materialized query matches for a given view only (!). Results are initialized lazily so the
* array of matches is set to `null` initially.
* @type {?}
*/
LQuery.prototype.matches;
/**
* A QueryList where materialized query results should be reported.
* @type {?}
*/
LQuery.prototype.queryList;
/**
* Clones an LQuery for an embedded view. A cloned query shares the same `QueryList` but has a
* separate collection of materialized matches.
* @return {?}
*/
LQuery.prototype.clone = function () { };
/**
* Called when an embedded view, impacting results of this query, is inserted or removed.
* @return {?}
*/
LQuery.prototype.setDirty = function () { };
}
/**
* lQueries represent a collection of individual LQuery objects tracked in a given view.
* @record
*/
export function LQueries() { }
if (false) {
/**
* A collection of queries tracked in a given view.
* @type {?}
*/
LQueries.prototype.queries;
/**
* A method called when a new embedded view is created. As a result a set of LQueries applicable
* for a new embedded view is instantiated (cloned) from the declaration view.
* @param {?} tView
* @return {?}
*/
LQueries.prototype.createEmbeddedView = function (tView) { };
/**
* A method called when an embedded view is inserted into a container. As a result all impacted
* `LQuery` objects (and associated `QueryList`) are marked as dirty.
* @param {?} tView
* @return {?}
*/
LQueries.prototype.insertView = function (tView) { };
/**
* A method called when an embedded view is detached from a container. As a result all impacted
* `LQuery` objects (and associated `QueryList`) are marked as dirty.
* @param {?} tView
* @return {?}
*/
LQueries.prototype.detachView = function (tView) { };
}
// Note: This hack is necessary so we don't erroneously get a circular dependency
// failure based on types.
/** @type {?} */
export const unusedValueExportToPlacateAjd = 1;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/query.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAiBA,oCAKC;;;IAJC,mCAA8B;;IAC9B,qCAAqB;;IACrB,8BAAU;;IACV,kCAAkB;;;;;;;;AAQpB,4BAsEC;;;;;;IAlEC,0BAAyB;;;;;;;IAOzB,wCAA+B;;;;;;;;;;;;;;;;;;;IAmB/B,yBAAuB;;;;;;;IAOvB,mCAA2B;;;;;;;;IAQ3B,4DAA+C;;;;;;;IAO/C,mDAA+B;;;;;;;;IAQ/B,wDAA2C;;;;;;;;;IAS3C,uEAAkE;;;;;;;AAOpE,8BA+CC;;;;;;IA/BC,0BAAe;;;;;;IAXf,iDAA4B;;;;;;IAM5B,qDAAkC;;;;;;;;IAalC,8DAA+C;;;;;;;IAO/C,qDAA+B;;;;;;;;IAQ/B,0DAA2C;;;;;;;IAO3C,wDAA2C;;;;;;;;;;AAS7C,4BAsBC;;;;;;;IAjBC,yBAAyB;;;;;IAKzB,2BAAwB;;;;;;IAMxB,yCAAmB;;;;;IAKnB,4CAAiB;;;;;;AAMnB,8BA0BC;;;;;;IAtBC,2BAAuB;;;;;;;IAOvB,6DAAgD;;;;;;;IAOhD,qDAA+B;;;;;;;IAO/B,qDAA+B;;;;;AAMjC,MAAM,OAAO,6BAA6B,GAAG,CAAC","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 {Type} from '../../interface/type';\nimport {QueryList} from '../../linker/query_list';\n\nimport {TNode} from './node';\nimport {TView} from './view';\n\n/**\n * An object representing query metadata extracted from query annotations.\n */\nexport interface TQueryMetadata {\n  predicate: Type<any>|string[];\n  descendants: boolean;\n  read: any;\n  isStatic: boolean;\n}\n\n/**\n * TQuery objects represent all the query-related data that remain the same from one view instance\n * to another and can be determined on the very first template pass. Most notably TQuery holds all\n * the matches for a given view.\n */\nexport interface TQuery {\n  /**\n   * Query metadata extracted from query annotations.\n   */\n  metadata: TQueryMetadata;\n\n  /**\n   * Index of a query in a declaration view in case of queries propagated to en embedded view, -1\n   * for queries declared in a given view. We are storing this index so we can find a parent query\n   * to clone for an embedded view (when an embedded view is created).\n   */\n  indexInDeclarationView: number;\n\n  /**\n   * Matches collected on the first template pass. Each match is a pair of:\n   * - TNode index;\n   * - match index;\n   *\n   * A TNode index can be either:\n   * - a positive number (the most common case) to indicate a matching TNode;\n   * - a negative number to indicate that a given query is crossing a <ng-template> element and\n   * results from views created based on TemplateRef should be inserted at this place.\n   *\n   * A match index is a number used to find an actual value (for a given node) when query results\n   * are materialized. This index can have one of the following values:\n   * - -2 - indicates that we need to read a special token (TemplateRef, ViewContainerRef etc.);\n   * - -1 - indicates that we need to read a default value based on the node type (TemplateRef for\n   * ng-template and ElementRef for other elements);\n   * - a positive number - index of an injectable to be read from the element injector.\n   */\n  matches: number[]|null;\n\n  /**\n   * A flag indicating if a given query crosses an <ng-template> element. This flag exists for\n   * performance reasons: we can notice that queries not crossing any <ng-template> elements will\n   * have matches from a given view only (and adapt processing accordingly).\n   */\n  crossesNgTemplate: boolean;\n\n  /**\n   * A method call when a given query is crossing an element (or element container). This is where a\n   * given TNode is matched against a query predicate.\n   * @param tView\n   * @param tNode\n   */\n  elementStart(tView: TView, tNode: TNode): void;\n\n  /**\n   * A method called when processing the elementEnd instruction - this is mostly useful to determine\n   * if a given content query should match any nodes past this point.\n   * @param tNode\n   */\n  elementEnd(tNode: TNode): void;\n\n  /**\n   * A method called when processing the template instruction. This is where a\n   * given TContainerNode is matched against a query predicate.\n   * @param tView\n   * @param tNode\n   */\n  template(tView: TView, tNode: TNode): void;\n\n  /**\n   * A query-related method called when an embedded TView is created based on the content of a\n   * <ng-template> element. We call this method to determine if a given query should be propagated\n   * to the embedded view and if so - return a cloned TQuery for this embedded view.\n   * @param tNode\n   * @param childQueryIndex\n   */\n  embeddedTView(tNode: TNode, childQueryIndex: number): TQuery|null;\n}\n\n/**\n * TQueries represent a collection of individual TQuery objects tracked in a given view. Most of the\n * methods on this interface are simple proxy methods to the corresponding functionality on TQuery.\n */\nexport interface TQueries {\n  /**\n   * Adds a new TQuery to a collection of queries tracked in a given view.\n   * @param tQuery\n   */\n  track(tQuery: TQuery): void;\n\n  /**\n   * Returns a TQuery instance for at the given index  in the queries array.\n   * @param index\n   */\n  getByIndex(index: number): TQuery;\n\n  /**\n   * Returns the number of queries tracked in a given view.\n   */\n  length: number;\n\n  /**\n   * A proxy method that iterates over all the TQueries in a given TView and calls the corresponding\n   * `elementStart` on each and every TQuery.\n   * @param tView\n   * @param tNode\n   */\n  elementStart(tView: TView, tNode: TNode): void;\n\n  /**\n   * A proxy method that iterates over all the TQueries in a given TView and calls the corresponding\n   * `elementEnd` on each and every TQuery.\n   * @param tNode\n   */\n  elementEnd(tNode: TNode): void;\n\n  /**\n   * A proxy method that iterates over all the TQueries in a given TView and calls the corresponding\n   * `template` on each and every TQuery.\n   * @param tView\n   * @param tNode\n   */\n  template(tView: TView, tNode: TNode): void;\n\n  /**\n   * A proxy method that iterates over all the TQueries in a given TView and calls the corresponding\n   * `embeddedTView` on each and every TQuery.\n   * @param tNode\n   */\n  embeddedTView(tNode: TNode): TQueries|null;\n}\n\n/**\n * An interface that represents query-related information specific to a view instance. Most notably\n * it contains:\n * - materialized query matches;\n * - a pointer to a QueryList where materialized query results should be reported.\n */\nexport interface LQuery<T> {\n  /**\n   * Materialized query matches for a given view only (!). Results are initialized lazily so the\n   * array of matches is set to `null` initially.\n   */\n  matches: (T|null)[]|null;\n\n  /**\n   * A QueryList where materialized query results should be reported.\n   */\n  queryList: QueryList<T>;\n\n  /**\n   * Clones an LQuery for an embedded view. A cloned query shares the same `QueryList` but has a\n   * separate collection of materialized matches.\n   */\n  clone(): LQuery<T>;\n\n  /**\n   * Called when an embedded view, impacting results of this query, is inserted or removed.\n   */\n  setDirty(): void;\n}\n\n/**\n * lQueries represent a collection of individual LQuery objects tracked in a given view.\n */\nexport interface LQueries {\n  /**\n   * A collection of queries tracked in a given view.\n   */\n  queries: LQuery<any>[];\n\n  /**\n   * A method called when a new embedded view is created. As a result a set of LQueries applicable\n   * for a new embedded view is instantiated (cloned) from the declaration view.\n   * @param tView\n   */\n  createEmbeddedView(tView: TView): LQueries|null;\n\n  /**\n   * A method called when an embedded view is inserted into a container. As a result all impacted\n   * `LQuery` objects (and associated `QueryList`) are marked as dirty.\n   * @param tView\n   */\n  insertView(tView: TView): void;\n\n  /**\n   * A method called when an embedded view is detached from a container. As a result all impacted\n   * `LQuery` objects (and associated `QueryList`) are marked as dirty.\n   * @param tView\n   */\n  detachView(tView: TView): void;\n}\n\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}