@angular/core
Version:
Angular - the core framework
392 lines • 31.5 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,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 { checkNoChangesInRootView, checkNoChangesInternal, detectChangesInRootView, detectChangesInternal, markViewDirty, storeCleanupFn } from './instructions/shared';
import { FLAGS, HOST, T_HOST } from './interfaces/view';
import { destroyLView, renderDetachView } from './node_manipulation';
import { findComponentView, getLViewParent } from './util/view_traversal_utils';
import { getNativeByTNode } from './util/view_utils';
/**
* @record
*/
export function viewEngine_ChangeDetectorRef_interface() { }
/**
* @template T
*/
export class ViewRef {
/**
* @param {?} _lView
* @param {?} _context
* @param {?} _componentIndex
*/
constructor(_lView, _context, _componentIndex) {
this._context = _context;
this._componentIndex = _componentIndex;
this._appRef = null;
this._viewContainerRef = null;
/**
* \@internal
*/
this._tViewNode = null;
this._lView = _lView;
}
/**
* @return {?}
*/
get rootNodes() {
if (this._lView[HOST] == null) {
/** @type {?} */
const tView = (/** @type {?} */ (this._lView[T_HOST]));
return collectNativeNodes(this._lView, tView, []);
}
return [];
}
/**
* @return {?}
*/
get context() { return this._context ? this._context : this._lookUpContext(); }
/**
* @return {?}
*/
get destroyed() {
return (this._lView[FLAGS] & 256 /* Destroyed */) === 256 /* Destroyed */;
}
/**
* @return {?}
*/
destroy() {
if (this._appRef) {
this._appRef.detachView(this);
}
else if (this._viewContainerRef) {
/** @type {?} */
const index = this._viewContainerRef.indexOf(this);
if (index > -1) {
this._viewContainerRef.detach(index);
}
this._viewContainerRef = null;
}
destroyLView(this._lView);
}
/**
* @param {?} callback
* @return {?}
*/
onDestroy(callback) { storeCleanupFn(this._lView, callback); }
/**
* Marks a view and all of its ancestors dirty.
*
* It also triggers change detection by calling `scheduleTick` internally, which coalesces
* multiple `markForCheck` calls to into one change detection run.
*
* This can be used to ensure an {\@link ChangeDetectionStrategy#OnPush OnPush} component is
* checked when it needs to be re-rendered but the two normal triggers haven't marked it
* dirty (i.e. inputs haven't changed and events haven't fired in the view).
*
* <!-- TODO: Add a link to a chapter on OnPush components -->
*
* \@usageNotes
* ### Example
*
* ```typescript
* \@Component({
* selector: 'my-app',
* template: `Number of ticks: {{numberOfTicks}}`
* changeDetection: ChangeDetectionStrategy.OnPush,
* })
* class AppComponent {
* numberOfTicks = 0;
*
* constructor(private ref: ChangeDetectorRef) {
* setInterval(() => {
* this.numberOfTicks++;
* // the following is required, otherwise the view will not be updated
* this.ref.markForCheck();
* }, 1000);
* }
* }
* ```
* @return {?}
*/
markForCheck() { markViewDirty(this._lView); }
/**
* Detaches the view from the change detection tree.
*
* Detached views will not be checked during change detection runs until they are
* re-attached, even if they are dirty. `detach` can be used in combination with
* {\@link ChangeDetectorRef#detectChanges detectChanges} to implement local change
* detection checks.
*
* <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
* <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
*
* \@usageNotes
* ### Example
*
* The following example defines a component with a large list of readonly data.
* Imagine the data changes constantly, many times per second. For performance reasons,
* we want to check and update the list every five seconds. We can do that by detaching
* the component's change detector and doing a local check every five seconds.
*
* ```typescript
* class DataProvider {
* // in a real application the returned data will be different every time
* get data() {
* return [1,2,3,4,5];
* }
* }
*
* \@Component({
* selector: 'giant-list',
* template: `
* <li *ngFor="let d of dataProvider.data">Data {{d}}</li>
* `,
* })
* class GiantList {
* constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {
* ref.detach();
* setInterval(() => {
* this.ref.detectChanges();
* }, 5000);
* }
* }
* /
* selector: 'app',
* providers: [DataProvider],
* template: `
* <giant-list><giant-list>
* `,
* })
* class App {
* }
* ```
* @return {?}
*/
detach() { this._lView[FLAGS] &= ~128 /* Attached */; }
/**
* Re-attaches a view to the change detection tree.
*
* This can be used to re-attach views that were previously detached from the tree
* using {\@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.
*
* <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
*
* \@usageNotes
* ### Example
*
* The following example creates a component displaying `live` data. The component will detach
* its change detector from the main change detector tree when the component's live property
* is set to false.
*
* ```typescript
* class DataProvider {
* data = 1;
*
* constructor() {
* setInterval(() => {
* this.data = this.data * 2;
* }, 500);
* }
* }
*
* \@Component({
* selector: 'live-data',
* inputs: ['live'],
* template: 'Data: {{dataProvider.data}}'
* })
* class LiveData {
* constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}
*
* set live(value) {
* if (value) {
* this.ref.reattach();
* } else {
* this.ref.detach();
* }
* }
* }
* /
* selector: 'my-app',
* providers: [DataProvider],
* template: `
* Live Update: <input type="checkbox" [(ngModel)]="live">
* <live-data [live]="live"><live-data>
* `,
* })
* class AppComponent {
* live = true;
* }
* ```
* @return {?}
*/
reattach() { this._lView[FLAGS] |= 128 /* Attached */; }
/**
* Checks the view and its children.
*
* This can also be used in combination with {\@link ChangeDetectorRef#detach detach} to implement
* local change detection checks.
*
* <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
* <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
*
* \@usageNotes
* ### Example
*
* The following example defines a component with a large list of readonly data.
* Imagine, the data changes constantly, many times per second. For performance reasons,
* we want to check and update the list every five seconds.
*
* We can do that by detaching the component's change detector and doing a local change detection
* check every five seconds.
*
* See {\@link ChangeDetectorRef#detach detach} for more information.
* @return {?}
*/
detectChanges() { detectChangesInternal(this._lView, this.context); }
/**
* Checks the change detector and its children, and throws if any changes are detected.
*
* This is used in development mode to verify that running change detection doesn't
* introduce other changes.
* @return {?}
*/
checkNoChanges() { checkNoChangesInternal(this._lView, this.context); }
/**
* @param {?} vcRef
* @return {?}
*/
attachToViewContainerRef(vcRef) {
if (this._appRef) {
throw new Error('This view is already attached directly to the ApplicationRef!');
}
this._viewContainerRef = vcRef;
}
/**
* @return {?}
*/
detachFromAppRef() {
this._appRef = null;
renderDetachView(this._lView);
}
/**
* @param {?} appRef
* @return {?}
*/
attachToAppRef(appRef) {
if (this._viewContainerRef) {
throw new Error('This view is already attached to a ViewContainer!');
}
this._appRef = appRef;
}
/**
* @private
* @return {?}
*/
_lookUpContext() {
return this._context = (/** @type {?} */ ((/** @type {?} */ (getLViewParent(this._lView)))[this._componentIndex]));
}
}
if (false) {
/**
* @type {?}
* @private
*/
ViewRef.prototype._appRef;
/**
* @type {?}
* @private
*/
ViewRef.prototype._viewContainerRef;
/**
* \@internal
* @type {?}
*/
ViewRef.prototype._tViewNode;
/**
* \@internal
* @type {?}
*/
ViewRef.prototype._lView;
/**
* @type {?}
* @private
*/
ViewRef.prototype._context;
/**
* @type {?}
* @private
*/
ViewRef.prototype._componentIndex;
}
/**
* \@internal
* @template T
*/
export class RootViewRef extends ViewRef {
/**
* @param {?} _view
*/
constructor(_view) {
super(_view, null, -1);
this._view = _view;
}
/**
* @return {?}
*/
detectChanges() { detectChangesInRootView(this._view); }
/**
* @return {?}
*/
checkNoChanges() { checkNoChangesInRootView(this._view); }
/**
* @return {?}
*/
get context() { return (/** @type {?} */ (null)); }
}
if (false) {
/** @type {?} */
RootViewRef.prototype._view;
}
/**
* @param {?} lView
* @param {?} parentTNode
* @param {?} result
* @return {?}
*/
function collectNativeNodes(lView, parentTNode, result) {
/** @type {?} */
let tNodeChild = parentTNode.child;
while (tNodeChild) {
/** @type {?} */
const nativeNode = getNativeByTNode(tNodeChild, lView);
nativeNode && result.push(nativeNode);
if (tNodeChild.type === 4 /* ElementContainer */) {
collectNativeNodes(lView, tNodeChild, result);
}
else if (tNodeChild.type === 1 /* Projection */) {
/** @type {?} */
const componentView = findComponentView(lView);
/** @type {?} */
const componentHost = (/** @type {?} */ (componentView[T_HOST]));
/** @type {?} */
const parentView = getLViewParent(componentView);
/** @type {?} */
let currentProjectedNode = ((/** @type {?} */ (componentHost.projection)))[(/** @type {?} */ (tNodeChild.projection))];
while (currentProjectedNode && parentView) {
result.push(getNativeByTNode(currentProjectedNode, parentView));
currentProjectedNode = currentProjectedNode.next;
}
}
tNodeChild = tNodeChild.next;
}
return result;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view_ref.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/view_ref.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 {ApplicationRef} from '../application_ref';\nimport {ChangeDetectorRef as viewEngine_ChangeDetectorRef} from '../change_detection/change_detector_ref';\nimport {ViewContainerRef as viewEngine_ViewContainerRef} from '../linker/view_container_ref';\nimport {EmbeddedViewRef as viewEngine_EmbeddedViewRef, InternalViewRef as viewEngine_InternalViewRef} from '../linker/view_ref';\n\nimport {checkNoChangesInRootView, checkNoChangesInternal, detectChangesInRootView, detectChangesInternal, markViewDirty, storeCleanupFn} from './instructions/shared';\nimport {TElementNode, TNode, TNodeType, TViewNode} from './interfaces/node';\nimport {FLAGS, HOST, LView, LViewFlags, T_HOST} from './interfaces/view';\nimport {destroyLView, renderDetachView} from './node_manipulation';\nimport {findComponentView, getLViewParent} from './util/view_traversal_utils';\nimport {getNativeByTNode} from './util/view_utils';\n\n\n\n// Needed due to tsickle downleveling where multiple `implements` with classes creates\n// multiple @extends in Closure annotations, which is illegal. This workaround fixes\n// the multiple @extends by making the annotation @implements instead\nexport interface viewEngine_ChangeDetectorRef_interface extends viewEngine_ChangeDetectorRef {}\n\nexport class ViewRef<T> implements viewEngine_EmbeddedViewRef<T>, viewEngine_InternalViewRef,\n    viewEngine_ChangeDetectorRef_interface {\n  private _appRef: ApplicationRef|null = null;\n  private _viewContainerRef: viewEngine_ViewContainerRef|null = null;\n\n  /**\n   * @internal\n   */\n  public _tViewNode: TViewNode|null = null;\n\n  /**\n   * @internal\n   */\n  public _lView: LView;\n\n  get rootNodes(): any[] {\n    if (this._lView[HOST] == null) {\n      const tView = this._lView[T_HOST] as TViewNode;\n      return collectNativeNodes(this._lView, tView, []);\n    }\n    return [];\n  }\n\n  constructor(_lView: LView, private _context: T|null, private _componentIndex: number) {\n    this._lView = _lView;\n  }\n\n  get context(): T { return this._context ? this._context : this._lookUpContext(); }\n\n  get destroyed(): boolean {\n    return (this._lView[FLAGS] & LViewFlags.Destroyed) === LViewFlags.Destroyed;\n  }\n\n  destroy(): void {\n    if (this._appRef) {\n      this._appRef.detachView(this);\n    } else if (this._viewContainerRef) {\n      const index = this._viewContainerRef.indexOf(this);\n\n      if (index > -1) {\n        this._viewContainerRef.detach(index);\n      }\n\n      this._viewContainerRef = null;\n    }\n    destroyLView(this._lView);\n  }\n\n  onDestroy(callback: Function) { storeCleanupFn(this._lView, callback); }\n\n  /**\n   * Marks a view and all of its ancestors dirty.\n   *\n   * It also triggers change detection by calling `scheduleTick` internally, which coalesces\n   * multiple `markForCheck` calls to into one change detection run.\n   *\n   * This can be used to ensure an {@link ChangeDetectionStrategy#OnPush OnPush} component is\n   * checked when it needs to be re-rendered but the two normal triggers haven't marked it\n   * dirty (i.e. inputs haven't changed and events haven't fired in the view).\n   *\n   * <!-- TODO: Add a link to a chapter on OnPush components -->\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'my-app',\n   *   template: `Number of ticks: {{numberOfTicks}}`\n   *   changeDetection: ChangeDetectionStrategy.OnPush,\n   * })\n   * class AppComponent {\n   *   numberOfTicks = 0;\n   *\n   *   constructor(private ref: ChangeDetectorRef) {\n   *     setInterval(() => {\n   *       this.numberOfTicks++;\n   *       // the following is required, otherwise the view will not be updated\n   *       this.ref.markForCheck();\n   *     }, 1000);\n   *   }\n   * }\n   * ```\n   */\n  markForCheck(): void { markViewDirty(this._lView); }\n\n  /**\n   * Detaches the view from the change detection tree.\n   *\n   * Detached views will not be checked during change detection runs until they are\n   * re-attached, even if they are dirty. `detach` can be used in combination with\n   * {@link ChangeDetectorRef#detectChanges detectChanges} to implement local change\n   * detection checks.\n   *\n   * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n   * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The following example defines a component with a large list of readonly data.\n   * Imagine the data changes constantly, many times per second. For performance reasons,\n   * we want to check and update the list every five seconds. We can do that by detaching\n   * the component's change detector and doing a local check every five seconds.\n   *\n   * ```typescript\n   * class DataProvider {\n   *   // in a real application the returned data will be different every time\n   *   get data() {\n   *     return [1,2,3,4,5];\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'giant-list',\n   *   template: `\n   *     <li *ngFor=\"let d of dataProvider.data\">Data {{d}}</li>\n   *   `,\n   * })\n   * class GiantList {\n   *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {\n   *     ref.detach();\n   *     setInterval(() => {\n   *       this.ref.detectChanges();\n   *     }, 5000);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   providers: [DataProvider],\n   *   template: `\n   *     <giant-list><giant-list>\n   *   `,\n   * })\n   * class App {\n   * }\n   * ```\n   */\n  detach(): void { this._lView[FLAGS] &= ~LViewFlags.Attached; }\n\n  /**\n   * Re-attaches a view to the change detection tree.\n   *\n   * This can be used to re-attach views that were previously detached from the tree\n   * using {@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.\n   *\n   * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The following example creates a component displaying `live` data. The component will detach\n   * its change detector from the main change detector tree when the component's live property\n   * is set to false.\n   *\n   * ```typescript\n   * class DataProvider {\n   *   data = 1;\n   *\n   *   constructor() {\n   *     setInterval(() => {\n   *       this.data = this.data * 2;\n   *     }, 500);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'live-data',\n   *   inputs: ['live'],\n   *   template: 'Data: {{dataProvider.data}}'\n   * })\n   * class LiveData {\n   *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}\n   *\n   *   set live(value) {\n   *     if (value) {\n   *       this.ref.reattach();\n   *     } else {\n   *       this.ref.detach();\n   *     }\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'my-app',\n   *   providers: [DataProvider],\n   *   template: `\n   *     Live Update: <input type=\"checkbox\" [(ngModel)]=\"live\">\n   *     <live-data [live]=\"live\"><live-data>\n   *   `,\n   * })\n   * class AppComponent {\n   *   live = true;\n   * }\n   * ```\n   */\n  reattach(): void { this._lView[FLAGS] |= LViewFlags.Attached; }\n\n  /**\n   * Checks the view and its children.\n   *\n   * This can also be used in combination with {@link ChangeDetectorRef#detach detach} to implement\n   * local change detection checks.\n   *\n   * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n   * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The following example defines a component with a large list of readonly data.\n   * Imagine, the data changes constantly, many times per second. For performance reasons,\n   * we want to check and update the list every five seconds.\n   *\n   * We can do that by detaching the component's change detector and doing a local change detection\n   * check every five seconds.\n   *\n   * See {@link ChangeDetectorRef#detach detach} for more information.\n   */\n  detectChanges(): void { detectChangesInternal(this._lView, this.context); }\n\n  /**\n   * Checks the change detector and its children, and throws if any changes are detected.\n   *\n   * This is used in development mode to verify that running change detection doesn't\n   * introduce other changes.\n   */\n  checkNoChanges(): void { checkNoChangesInternal(this._lView, this.context); }\n\n  attachToViewContainerRef(vcRef: viewEngine_ViewContainerRef) {\n    if (this._appRef) {\n      throw new Error('This view is already attached directly to the ApplicationRef!');\n    }\n    this._viewContainerRef = vcRef;\n  }\n\n  detachFromAppRef() {\n    this._appRef = null;\n    renderDetachView(this._lView);\n  }\n\n  attachToAppRef(appRef: ApplicationRef) {\n    if (this._viewContainerRef) {\n      throw new Error('This view is already attached to a ViewContainer!');\n    }\n    this._appRef = appRef;\n  }\n\n  private _lookUpContext(): T {\n    return this._context = getLViewParent(this._lView) ![this._componentIndex] as T;\n  }\n}\n\n/** @internal */\nexport class RootViewRef<T> extends ViewRef<T> {\n  constructor(public _view: LView) { super(_view, null, -1); }\n\n  detectChanges(): void { detectChangesInRootView(this._view); }\n\n  checkNoChanges(): void { checkNoChangesInRootView(this._view); }\n\n  get context(): T { return null !; }\n}\n\nfunction collectNativeNodes(lView: LView, parentTNode: TNode, result: any[]): any[] {\n  let tNodeChild = parentTNode.child;\n\n  while (tNodeChild) {\n    const nativeNode = getNativeByTNode(tNodeChild, lView);\n    nativeNode && result.push(nativeNode);\n    if (tNodeChild.type === TNodeType.ElementContainer) {\n      collectNativeNodes(lView, tNodeChild, result);\n    } else if (tNodeChild.type === TNodeType.Projection) {\n      const componentView = findComponentView(lView);\n      const componentHost = componentView[T_HOST] as TElementNode;\n      const parentView = getLViewParent(componentView);\n      let currentProjectedNode: TNode|null =\n          (componentHost.projection as(TNode | null)[])[tNodeChild.projection as number];\n\n      while (currentProjectedNode && parentView) {\n        result.push(getNativeByTNode(currentProjectedNode, parentView));\n        currentProjectedNode = currentProjectedNode.next;\n      }\n    }\n    tNodeChild = tNodeChild.next;\n  }\n\n  return result;\n}\n"]}