/** * @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 { RuntimeError } from '../errors'; import { removeFromArray } from '../util/array_utils'; import { assertEqual } from '../util/assert'; import { collectNativeNodes } from './collect_native_nodes'; import { checkNoChangesInternal, detectChangesInternal, markViewDirty, storeCleanupWithContext } from './instructions/shared'; import { CONTAINER_HEADER_OFFSET, VIEW_REFS } from './interfaces/container'; import { isLContainer } from './interfaces/type_checks'; import { CONTEXT, FLAGS, PARENT, TVIEW } from './interfaces/view'; import { destroyLView, detachView, renderDetachView } from './node_manipulation'; export class ViewRef { constructor( /** * This represents `LView` associated with the component when ViewRef is a ChangeDetectorRef. * * When ViewRef is created for a dynamic component, this also represents the `LView` for the * component. * * For a "regular" ViewRef created for an embedded view, this is the `LView` for the embedded * view. * * @internal */ _lView, /** * This represents the `LView` associated with the point where `ChangeDetectorRef` was * requested. * * This may be different from `_lView` if the `_cdRefInjectingView` is an embedded view. */ _cdRefInjectingView) { this._lView = _lView; this._cdRefInjectingView = _cdRefInjectingView; this._appRef = null; this._attachedToViewContainer = false; } get rootNodes() { const lView = this._lView; const tView = lView[TVIEW]; return collectNativeNodes(tView, lView, tView.firstChild, []); } get context() { return this._lView[CONTEXT]; } set context(value) { this._lView[CONTEXT] = value; } get destroyed() { return (this._lView[FLAGS] & 128 /* LViewFlags.Destroyed */) === 128 /* LViewFlags.Destroyed */; } destroy() { if (this._appRef) { this._appRef.detachView(this); } else if (this._attachedToViewContainer) { const parent = this._lView[PARENT]; if (isLContainer(parent)) { const viewRefs = parent[VIEW_REFS]; const index = viewRefs ? viewRefs.indexOf(this) : -1; if (index > -1) { ngDevMode && assertEqual(index, parent.indexOf(this._lView) - CONTAINER_HEADER_OFFSET, 'An attached view should be in the same position within its container as its ViewRef in the VIEW_REFS array.'); detachView(parent, index); removeFromArray(viewRefs, index); } } this._attachedToViewContainer = false; } destroyLView(this._lView[TVIEW], this._lView); } onDestroy(callback) { storeCleanupWithContext(this._lView[TVIEW], this._lView, null, callback); } /** * Marks a view and all of its ancestors dirty. * * 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). * * * * @usageNotes * ### Example * * ```typescript * @Component({ * selector: 'app-root', * 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); * } * } * ``` */ markForCheck() { markViewDirty(this._cdRefInjectingView || 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. * * * * * @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: ` *
  • Data {{d}}
    • * `, * }) * class GiantList { * constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) { * ref.detach(); * setInterval(() => { * this.ref.detectChanges(); * }, 5000); * } * } * * @Component({ * selector: 'app', * providers: [DataProvider], * template: ` * * `, * }) * class App { * } * ``` */ detach() { this._lView[FLAGS] &= ~64 /* LViewFlags.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. * * * * @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(); * } * } * } * * @Component({ * selector: 'app-root', * providers: [DataProvider], * template: ` * Live Update: * * `, * }) * class AppComponent { * live = true; * } * ``` */ reattach() { this._lView[FLAGS] |= 64 /* LViewFlags.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. * * * * * @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. */ detectChanges() { detectChangesInternal(this._lView[TVIEW], 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. */ checkNoChanges() { if (ngDevMode) { checkNoChangesInternal(this._lView[TVIEW], this._lView, this.context); } } attachToViewContainerRef() { if (this._appRef) { throw new RuntimeError(902 /* RuntimeErrorCode.VIEW_ALREADY_ATTACHED */, ngDevMode && 'This view is already attached directly to the ApplicationRef!'); } this._attachedToViewContainer = true; } detachFromAppRef() { this._appRef = null; renderDetachView(this._lView[TVIEW], this._lView); } attachToAppRef(appRef) { if (this._attachedToViewContainer) { throw new RuntimeError(902 /* RuntimeErrorCode.VIEW_ALREADY_ATTACHED */, ngDevMode && 'This view is already attached to a ViewContainer!'); } this._appRef = appRef; } } /** @internal */ export class RootViewRef extends ViewRef { constructor(_view) { super(_view); this._view = _view; } detectChanges() { const lView = this._view; const tView = lView[TVIEW]; const context = lView[CONTEXT]; detectChangesInternal(tView, lView, context, false); } checkNoChanges() { if (ngDevMode) { const lView = this._view; const tView = lView[TVIEW]; const context = lView[CONTEXT]; checkNoChangesInternal(tView, lView, context, false); } } get context() { return null; } } //# 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 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 {ChangeDetectorRef as viewEngine_ChangeDetectorRef} from '../change_detection/change_detector_ref';\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {EmbeddedViewRef as viewEngine_EmbeddedViewRef, InternalViewRef as viewEngine_InternalViewRef, ViewRefTracker} from '../linker/view_ref';\nimport {removeFromArray} from '../util/array_utils';\nimport {assertEqual} from '../util/assert';\n\nimport {collectNativeNodes} from './collect_native_nodes';\nimport {checkNoChangesInternal, detectChangesInternal, markViewDirty, storeCleanupWithContext} from './instructions/shared';\nimport {CONTAINER_HEADER_OFFSET, VIEW_REFS} from './interfaces/container';\nimport {isLContainer} from './interfaces/type_checks';\nimport {CONTEXT, FLAGS, LView, LViewFlags, PARENT, TVIEW} from './interfaces/view';\nimport {destroyLView, detachView, renderDetachView} from './node_manipulation';\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: ViewRefTracker|null = null;\n  private _attachedToViewContainer = false;\n\n  get rootNodes(): any[] {\n    const lView = this._lView;\n    const tView = lView[TVIEW];\n    return collectNativeNodes(tView, lView, tView.firstChild, []);\n  }\n\n  constructor(\n      /**\n       * This represents `LView` associated with the component when ViewRef is a ChangeDetectorRef.\n       *\n       * When ViewRef is created for a dynamic component, this also represents the `LView` for the\n       * component.\n       *\n       * For a \"regular\" ViewRef created for an embedded view, this is the `LView` for the embedded\n       * view.\n       *\n       * @internal\n       */\n      public _lView: LView,\n\n      /**\n       * This represents the `LView` associated with the point where `ChangeDetectorRef` was\n       * requested.\n       *\n       * This may be different from `_lView` if the `_cdRefInjectingView` is an embedded view.\n       */\n      private _cdRefInjectingView?: LView) {}\n\n  get context(): T {\n    return this._lView[CONTEXT] as unknown as T;\n  }\n\n  set context(value: T) {\n    this._lView[CONTEXT] = value as unknown as {};\n  }\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._attachedToViewContainer) {\n      const parent = this._lView[PARENT];\n      if (isLContainer(parent)) {\n        const viewRefs = parent[VIEW_REFS] as ViewRef<unknown>[] | null;\n        const index = viewRefs ? viewRefs.indexOf(this) : -1;\n        if (index > -1) {\n          ngDevMode &&\n              assertEqual(\n                  index, parent.indexOf(this._lView) - CONTAINER_HEADER_OFFSET,\n                  'An attached view should be in the same position within its container as its ViewRef in the VIEW_REFS array.');\n          detachView(parent, index);\n          removeFromArray(viewRefs!, index);\n        }\n      }\n      this._attachedToViewContainer = false;\n    }\n    destroyLView(this._lView[TVIEW], this._lView);\n  }\n\n  onDestroy(callback: Function) {\n    storeCleanupWithContext(this._lView[TVIEW], this._lView, null, callback);\n  }\n\n  /**\n   * Marks a view and all of its ancestors dirty.\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: 'app-root',\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 {\n    markViewDirty(this._cdRefInjectingView || this._lView);\n  }\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 {\n    this._lView[FLAGS] &= ~LViewFlags.Attached;\n  }\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: 'app-root',\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 {\n    this._lView[FLAGS] |= LViewFlags.Attached;\n  }\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 {\n    detectChangesInternal(this._lView[TVIEW], this._lView, this.context as unknown as {});\n  }\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 {\n    if (ngDevMode) {\n      checkNoChangesInternal(this._lView[TVIEW], this._lView, this.context as unknown as {});\n    }\n  }\n\n  attachToViewContainerRef() {\n    if (this._appRef) {\n      throw new RuntimeError(\n          RuntimeErrorCode.VIEW_ALREADY_ATTACHED,\n          ngDevMode && 'This view is already attached directly to the ApplicationRef!');\n    }\n    this._attachedToViewContainer = true;\n  }\n\n  detachFromAppRef() {\n    this._appRef = null;\n    renderDetachView(this._lView[TVIEW], this._lView);\n  }\n\n  attachToAppRef(appRef: ViewRefTracker) {\n    if (this._attachedToViewContainer) {\n      throw new RuntimeError(\n          RuntimeErrorCode.VIEW_ALREADY_ATTACHED,\n          ngDevMode && 'This view is already attached to a ViewContainer!');\n    }\n    this._appRef = appRef;\n  }\n}\n\n/** @internal */\nexport class RootViewRef<T> extends ViewRef<T> {\n  constructor(public _view: LView) {\n    super(_view);\n  }\n\n  override detectChanges(): void {\n    const lView = this._view;\n    const tView = lView[TVIEW];\n    const context = lView[CONTEXT];\n    detectChangesInternal(tView, lView, context, false);\n  }\n\n  override checkNoChanges(): void {\n    if (ngDevMode) {\n      const lView = this._view;\n      const tView = lView[TVIEW];\n      const context = lView[CONTEXT];\n      checkNoChangesInternal(tView, lView, context, false);\n    }\n  }\n\n  override get context(): T {\n    return null!;\n  }\n}\n"]}