@angular/core 15.2.1 → 16.0.0-next.1

package/esm2020/src/render3/view_ref.mjs

@@ -9,11 +9,12 @@ 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 { checkNoChangesInternal, detectChangesInternal, markViewDirty } 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';
+import { storeLViewOnDestroy } from './util/view_utils';
 export class ViewRef {
     get rootNodes() {
         const lView = this._lView;
@@ -75,7 +76,7 @@ export class ViewRef {
         destroyLView(this._lView[TVIEW], this._lView);
     }
     onDestroy(callback) {
-        storeCleanupWithContext(this._lView[TVIEW], this._lView, null, callback);
+        storeLViewOnDestroy(this._lView, callback);
     }
     /**
      * Marks a view and all of its ancestors dirty.
@@ -302,4 +303,4 @@ export class RootViewRef extends ViewRef {
         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"]}
+//# 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} 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';\nimport {storeLViewOnDestroy} 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: 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    storeLViewOnDestroy(this._lView, callback as () => void);\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"]}

package/esm2020/src/sanitization/sanitizer.mjs

@@ -11,7 +11,7 @@ import { ɵɵdefineInjectable } from '../di/interface/defs';
  *
  * @publicApi
  */
-export class Sanitizer {
+class Sanitizer {
 }
 /** @nocollapse */
 Sanitizer.ɵprov = ɵɵdefineInjectable({
@@ -19,4 +19,5 @@ Sanitizer.ɵprov = ɵɵdefineInjectable({
     providedIn: 'root',
     factory: () => null,
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FuaXRpemVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvc2FuaXRpemF0aW9uL3Nhbml0aXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsa0JBQWtCLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUd4RDs7OztHQUlHO0FBQ0gsTUFBTSxPQUFnQixTQUFTOztBQUU3QixrQkFBa0I7QUFDWCxlQUFLLEdBQTZCLGtCQUFrQixDQUFDO0lBQzFELEtBQUssRUFBRSxTQUFTO0lBQ2hCLFVBQVUsRUFBRSxNQUFNO0lBQ2xCLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxJQUFJO0NBQ3BCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge8m1ybVkZWZpbmVJbmplY3RhYmxlfSBmcm9tICcuLi9kaS9pbnRlcmZhY2UvZGVmcyc7XG5pbXBvcnQge1NlY3VyaXR5Q29udGV4dH0gZnJvbSAnLi9zZWN1cml0eSc7XG5cbi8qKlxuICogU2FuaXRpemVyIGlzIHVzZWQgYnkgdGhlIHZpZXdzIHRvIHNhbml0aXplIHBvdGVudGlhbGx5IGRhbmdlcm91cyB2YWx1ZXMuXG4gKlxuICogQHB1YmxpY0FwaVxuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgU2FuaXRpemVyIHtcbiAgYWJzdHJhY3Qgc2FuaXRpemUoY29udGV4dDogU2VjdXJpdHlDb250ZXh0LCB2YWx1ZToge318c3RyaW5nfG51bGwpOiBzdHJpbmd8bnVsbDtcbiAgLyoqIEBub2NvbGxhcHNlICovXG4gIHN0YXRpYyDJtXByb3YgPSAvKiogQHB1cmVPckJyZWFrTXlDb2RlICovIMm1ybVkZWZpbmVJbmplY3RhYmxlKHtcbiAgICB0b2tlbjogU2FuaXRpemVyLFxuICAgIHByb3ZpZGVkSW46ICdyb290JyxcbiAgICBmYWN0b3J5OiAoKSA9PiBudWxsLFxuICB9KTtcbn1cbiJdfQ==
+export { Sanitizer };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FuaXRpemVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvc2FuaXRpemF0aW9uL3Nhbml0aXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsa0JBQWtCLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUd4RDs7OztHQUlHO0FBQ0gsTUFBc0IsU0FBUzs7QUFFN0Isa0JBQWtCO0FBQ1gsZUFBSyxHQUE2QixrQkFBa0IsQ0FBQztJQUMxRCxLQUFLLEVBQUUsU0FBUztJQUNoQixVQUFVLEVBQUUsTUFBTTtJQUNsQixPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMsSUFBSTtDQUNwQixDQUFDLENBQUM7U0FQaUIsU0FBUyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge8m1ybVkZWZpbmVJbmplY3RhYmxlfSBmcm9tICcuLi9kaS9pbnRlcmZhY2UvZGVmcyc7XG5pbXBvcnQge1NlY3VyaXR5Q29udGV4dH0gZnJvbSAnLi9zZWN1cml0eSc7XG5cbi8qKlxuICogU2FuaXRpemVyIGlzIHVzZWQgYnkgdGhlIHZpZXdzIHRvIHNhbml0aXplIHBvdGVudGlhbGx5IGRhbmdlcm91cyB2YWx1ZXMuXG4gKlxuICogQHB1YmxpY0FwaVxuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgU2FuaXRpemVyIHtcbiAgYWJzdHJhY3Qgc2FuaXRpemUoY29udGV4dDogU2VjdXJpdHlDb250ZXh0LCB2YWx1ZToge318c3RyaW5nfG51bGwpOiBzdHJpbmd8bnVsbDtcbiAgLyoqIEBub2NvbGxhcHNlICovXG4gIHN0YXRpYyDJtXByb3YgPSAvKiogQHB1cmVPckJyZWFrTXlDb2RlICovIMm1ybVkZWZpbmVJbmplY3RhYmxlKHtcbiAgICB0b2tlbjogU2FuaXRpemVyLFxuICAgIHByb3ZpZGVkSW46ICdyb290JyxcbiAgICBmYWN0b3J5OiAoKSA9PiBudWxsLFxuICB9KTtcbn1cbiJdfQ==

package/esm2020/src/signals/index.mjs

@@ -0,0 +1,15 @@
+/**
+ * @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
+ */
+export { isSignal } from './src/api';
+export { computed } from './src/computed';
+export { effect } from './src/effect';
+export { setActiveConsumer } from './src/graph';
+export { signal } from './src/signal';
+export { untracked } from './src/untracked';
+export { Watch } from './src/watch';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9zaWduYWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxRQUFRLEVBQTBCLE1BQU0sV0FBVyxDQUFDO0FBQzVELE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUN4QyxPQUFPLEVBQUMsTUFBTSxFQUFTLE1BQU0sY0FBYyxDQUFDO0FBQzVDLE9BQU8sRUFBQyxpQkFBaUIsRUFBQyxNQUFNLGFBQWEsQ0FBQztBQUM5QyxPQUFPLEVBQWlCLE1BQU0sRUFBQyxNQUFNLGNBQWMsQ0FBQztBQUNwRCxPQUFPLEVBQUMsU0FBUyxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxFQUFDLEtBQUssRUFBQyxNQUFNLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQge2lzU2lnbmFsLCBTaWduYWwsIFZhbHVlRXF1YWxpdHlGbn0gZnJvbSAnLi9zcmMvYXBpJztcbmV4cG9ydCB7Y29tcHV0ZWR9IGZyb20gJy4vc3JjL2NvbXB1dGVkJztcbmV4cG9ydCB7ZWZmZWN0LCBFZmZlY3R9IGZyb20gJy4vc3JjL2VmZmVjdCc7XG5leHBvcnQge3NldEFjdGl2ZUNvbnN1bWVyfSBmcm9tICcuL3NyYy9ncmFwaCc7XG5leHBvcnQge1NldHRhYmxlU2lnbmFsLCBzaWduYWx9IGZyb20gJy4vc3JjL3NpZ25hbCc7XG5leHBvcnQge3VudHJhY2tlZH0gZnJvbSAnLi9zcmMvdW50cmFja2VkJztcbmV4cG9ydCB7V2F0Y2h9IGZyb20gJy4vc3JjL3dhdGNoJztcbiJdfQ==

package/esm2020/src/signals/src/api.mjs

@@ -0,0 +1,46 @@
+/**
+ * @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
+ */
+/**
+ * Symbol used to tell `Signal`s apart from other functions.
+ *
+ * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
+ */
+const SIGNAL = Symbol('SIGNAL');
+/**
+ * Checks if the given `value` function is a reactive `Signal`.
+ */
+export function isSignal(value) {
+    return value[SIGNAL] ?? false;
+}
+/**
+ * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`), and
+ * potentially add some set of extra properties (passed as an object record `extraApi`).
+ */
+export function createSignalFromFunction(fn, extraApi = {}) {
+    fn[SIGNAL] = true;
+    // Copy properties from `extraApi` to `fn` to complete the desired API of the `Signal`.
+    return Object.assign(fn, extraApi);
+}
+/**
+ * The default equality function used for `signal` and `computed`, which treats objects and arrays
+ * as never equal, and all other primitive values using identity semantics.
+ *
+ * This allows signals to hold non-primitive values (arrays, objects, other collections) and still
+ * propagate change notification upon explicit mutation without identity change.
+ *
+ * @developerPreview
+ */
+export function defaultEquals(a, b) {
+    // `Object.is` compares two values using identity semantics which is desired behavior for
+    // primitive values. If `Object.is` determines two values to be equal we need to make sure that
+    // those don't represent objects (we want to make sure that 2 objects are always considered
+    // "unequal"). The null check is needed for the special case of JavaScript reporting null values
+    // as objects (`typeof null === 'object'`).
+    return (a === null || typeof a !== 'object') && Object.is(a, b);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvc2lnbmFscy9zcmMvYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7O0dBSUc7QUFDSCxNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUM7QUFnQmhDOztHQUVHO0FBQ0gsTUFBTSxVQUFVLFFBQVEsQ0FBQyxLQUFlO0lBQ3RDLE9BQVEsS0FBeUIsQ0FBQyxNQUFNLENBQUMsSUFBSSxLQUFLLENBQUM7QUFDckQsQ0FBQztBQW9CRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsd0JBQXdCLENBQ3BDLEVBQVcsRUFBRSxXQUFlLEVBQVE7SUFDckMsRUFBVSxDQUFDLE1BQU0sQ0FBQyxHQUFHLElBQUksQ0FBQztJQUMzQix1RkFBdUY7SUFDdkYsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxRQUFRLENBQW1CLENBQUM7QUFDdkQsQ0FBQztBQVNEOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FBSSxDQUFJLEVBQUUsQ0FBSTtJQUN6Qyx5RkFBeUY7SUFDekYsK0ZBQStGO0lBQy9GLDJGQUEyRjtJQUMzRixnR0FBZ0c7SUFDaEcsMkNBQTJDO0lBQzNDLE9BQU8sQ0FBQyxDQUFDLEtBQUssSUFBSSxJQUFJLE9BQU8sQ0FBQyxLQUFLLFFBQVEsQ0FBQyxJQUFJLE1BQU0sQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQ2xFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBTeW1ib2wgdXNlZCB0byB0ZWxsIGBTaWduYWxgcyBhcGFydCBmcm9tIG90aGVyIGZ1bmN0aW9ucy5cbiAqXG4gKiBUaGlzIGNhbiBiZSB1c2VkIHRvIGF1dG8tdW53cmFwIHNpZ25hbHMgaW4gdmFyaW91cyBjYXNlcywgb3IgdG8gYXV0by13cmFwIG5vbi1zaWduYWwgdmFsdWVzLlxuICovXG5jb25zdCBTSUdOQUwgPSBTeW1ib2woJ1NJR05BTCcpO1xuXG4vKipcbiAqIEEgcmVhY3RpdmUgdmFsdWUgd2hpY2ggbm90aWZpZXMgY29uc3VtZXJzIG9mIGFueSBjaGFuZ2VzLlxuICpcbiAqIFNpZ25hbHMgYXJlIGZ1bmN0aW9ucyB3aGljaCByZXR1cm5zIHRoZWlyIGN1cnJlbnQgdmFsdWUuIFRvIGFjY2VzcyB0aGUgY3VycmVudCB2YWx1ZSBvZiBhIHNpZ25hbCxcbiAqIGNhbGwgaXQuXG4gKlxuICogT3JkaW5hcnkgdmFsdWVzIGNhbiBiZSB0dXJuZWQgaW50byBgU2lnbmFsYHMgd2l0aCB0aGUgYHNpZ25hbGAgZnVuY3Rpb24uXG4gKlxuICogQGRldmVsb3BlclByZXZpZXdcbiAqL1xuZXhwb3J0IHR5cGUgU2lnbmFsPFQ+ID0gKCgpID0+IFQpJntcbiAgW1NJR05BTF06IHRydWU7XG59O1xuXG4vKipcbiAqIENoZWNrcyBpZiB0aGUgZ2l2ZW4gYHZhbHVlYCBmdW5jdGlvbiBpcyBhIHJlYWN0aXZlIGBTaWduYWxgLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNTaWduYWwodmFsdWU6IEZ1bmN0aW9uKTogdmFsdWUgaXMgU2lnbmFsPHVua25vd24+IHtcbiAgcmV0dXJuICh2YWx1ZSBhcyBTaWduYWw8dW5rbm93bj4pW1NJR05BTF0gPz8gZmFsc2U7XG59XG5cbi8qKlxuICogQ29udmVydHMgYGZuYCBpbnRvIGEgbWFya2VkIHNpZ25hbCBmdW5jdGlvbiAod2hlcmUgYGlzU2lnbmFsKGZuKWAgd2lsbCBiZSBgdHJ1ZWApLlxuICpcbiAqIEBwYXJhbSBmbiBBIHplcm8tYXJndW1lbnQgZnVuY3Rpb24gd2hpY2ggd2lsbCBiZSBjb252ZXJ0ZWQgaW50byBhIGBTaWduYWxgLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlU2lnbmFsRnJvbUZ1bmN0aW9uPFQ+KGZuOiAoKSA9PiBUKTogU2lnbmFsPFQ+O1xuXG4vKipcbiAqIENvbnZlcnRzIGBmbmAgaW50byBhIG1hcmtlZCBzaWduYWwgZnVuY3Rpb24gKHdoZXJlIGBpc1NpZ25hbChmbilgIHdpbGwgYmUgYHRydWVgKSwgYW5kXG4gKiBwb3RlbnRpYWxseSBhZGQgc29tZSBzZXQgb2YgZXh0cmEgcHJvcGVydGllcyAocGFzc2VkIGFzIGFuIG9iamVjdCByZWNvcmQgYGV4dHJhQXBpYCkuXG4gKlxuICogQHBhcmFtIGZuIEEgemVyby1hcmd1bWVudCBmdW5jdGlvbiB3aGljaCB3aWxsIGJlIGNvbnZlcnRlZCBpbnRvIGEgYFNpZ25hbGAuXG4gKiBAcGFyYW0gZXh0cmFBcGkgQW4gb2JqZWN0IHdob3NlIHByb3BlcnRpZXMgd2lsbCBiZSBjb3BpZWQgb250byBgZm5gIGluIG9yZGVyIHRvIGNyZWF0ZSBhIHNwZWNpZmljXG4gKiAgICAgZGVzaXJlZCBpbnRlcmZhY2UgZm9yIHRoZSBgU2lnbmFsYC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZVNpZ25hbEZyb21GdW5jdGlvbjxULCBVIGV4dGVuZHMgUmVjb3JkPHN0cmluZywgdW5rbm93bj4+KFxuICAgIGZuOiAoKSA9PiBULCBleHRyYUFwaTogVSk6IFNpZ25hbDxUPiZVO1xuXG4vKipcbiAqIENvbnZlcnRzIGBmbmAgaW50byBhIG1hcmtlZCBzaWduYWwgZnVuY3Rpb24gKHdoZXJlIGBpc1NpZ25hbChmbilgIHdpbGwgYmUgYHRydWVgKSwgYW5kXG4gKiBwb3RlbnRpYWxseSBhZGQgc29tZSBzZXQgb2YgZXh0cmEgcHJvcGVydGllcyAocGFzc2VkIGFzIGFuIG9iamVjdCByZWNvcmQgYGV4dHJhQXBpYCkuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVTaWduYWxGcm9tRnVuY3Rpb248VCwgVSBleHRlbmRzIFJlY29yZDxzdHJpbmcsIHVua25vd24+ID0ge30+KFxuICAgIGZuOiAoKSA9PiBULCBleHRyYUFwaTogVSA9ICh7fSBhcyBVKSk6IFNpZ25hbDxUPiZVIHtcbiAgKGZuIGFzIGFueSlbU0lHTkFMXSA9IHRydWU7XG4gIC8vIENvcHkgcHJvcGVydGllcyBmcm9tIGBleHRyYUFwaWAgdG8gYGZuYCB0byBjb21wbGV0ZSB0aGUgZGVzaXJlZCBBUEkgb2YgdGhlIGBTaWduYWxgLlxuICByZXR1cm4gT2JqZWN0LmFzc2lnbihmbiwgZXh0cmFBcGkpIGFzIChTaWduYWw8VD4mIFUpO1xufVxuXG4vKipcbiAqIEEgY29tcGFyaXNvbiBmdW5jdGlvbiB3aGljaCBjYW4gZGV0ZXJtaW5lIGlmIHR3byB2YWx1ZXMgYXJlIGVxdWFsLlxuICpcbiAqIEBkZXZlbG9wZXJQcmV2aWV3XG4gKi9cbmV4cG9ydCB0eXBlIFZhbHVlRXF1YWxpdHlGbjxUPiA9IChhOiBULCBiOiBUKSA9PiBib29sZWFuO1xuXG4vKipcbiAqIFRoZSBkZWZhdWx0IGVxdWFsaXR5IGZ1bmN0aW9uIHVzZWQgZm9yIGBzaWduYWxgIGFuZCBgY29tcHV0ZWRgLCB3aGljaCB0cmVhdHMgb2JqZWN0cyBhbmQgYXJyYXlzXG4gKiBhcyBuZXZlciBlcXVhbCwgYW5kIGFsbCBvdGhlciBwcmltaXRpdmUgdmFsdWVzIHVzaW5nIGlkZW50aXR5IHNlbWFudGljcy5cbiAqXG4gKiBUaGlzIGFsbG93cyBzaWduYWxzIHRvIGhvbGQgbm9uLXByaW1pdGl2ZSB2YWx1ZXMgKGFycmF5cywgb2JqZWN0cywgb3RoZXIgY29sbGVjdGlvbnMpIGFuZCBzdGlsbFxuICogcHJvcGFnYXRlIGNoYW5nZSBub3RpZmljYXRpb24gdXBvbiBleHBsaWNpdCBtdXRhdGlvbiB3aXRob3V0IGlkZW50aXR5IGNoYW5nZS5cbiAqXG4gKiBAZGV2ZWxvcGVyUHJldmlld1xuICovXG5leHBvcnQgZnVuY3Rpb24gZGVmYXVsdEVxdWFsczxUPihhOiBULCBiOiBUKSB7XG4gIC8vIGBPYmplY3QuaXNgIGNvbXBhcmVzIHR3byB2YWx1ZXMgdXNpbmcgaWRlbnRpdHkgc2VtYW50aWNzIHdoaWNoIGlzIGRlc2lyZWQgYmVoYXZpb3IgZm9yXG4gIC8vIHByaW1pdGl2ZSB2YWx1ZXMuIElmIGBPYmplY3QuaXNgIGRldGVybWluZXMgdHdvIHZhbHVlcyB0byBiZSBlcXVhbCB3ZSBuZWVkIHRvIG1ha2Ugc3VyZSB0aGF0XG4gIC8vIHRob3NlIGRvbid0IHJlcHJlc2VudCBvYmplY3RzICh3ZSB3YW50IHRvIG1ha2Ugc3VyZSB0aGF0IDIgb2JqZWN0cyBhcmUgYWx3YXlzIGNvbnNpZGVyZWRcbiAgLy8gXCJ1bmVxdWFsXCIpLiBUaGUgbnVsbCBjaGVjayBpcyBuZWVkZWQgZm9yIHRoZSBzcGVjaWFsIGNhc2Ugb2YgSmF2YVNjcmlwdCByZXBvcnRpbmcgbnVsbCB2YWx1ZXNcbiAgLy8gYXMgb2JqZWN0cyAoYHR5cGVvZiBudWxsID09PSAnb2JqZWN0J2ApLlxuICByZXR1cm4gKGEgPT09IG51bGwgfHwgdHlwZW9mIGEgIT09ICdvYmplY3QnKSAmJiBPYmplY3QuaXMoYSwgYik7XG59XG4iXX0=

package/esm2020/src/signals/src/computed.mjs

@@ -0,0 +1,142 @@
+/**
+ * @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 { createSignalFromFunction, defaultEquals } from './api';
+import { consumerPollValueStatus, nextReactiveId, producerAccessed, producerNotifyConsumers, setActiveConsumer } from './graph';
+import { WeakRef } from './weak_ref';
+/**
+ * Create a computed `Signal` which derives a reactive value from an expression.
+ *
+ * @developerPreview
+ */
+export function computed(computation, equal = defaultEquals) {
+    const node = new ComputedImpl(computation, equal);
+    return createSignalFromFunction(node.signal.bind(node));
+}
+/**
+ * A dedicated symbol used before a computed value has been calculated for the first time.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const UNSET = Symbol('UNSET');
+/**
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * is in progress. Used to detect cycles in computation chains.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const COMPUTING = Symbol('COMPUTING');
+/**
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * failed. The thrown error is cached until the computation gets dirty again.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const ERRORED = Symbol('ERRORED');
+/**
+ * A computation, which derives a value from a declarative reactive expression.
+ *
+ * `Computed`s are both `Producer`s and `Consumer`s of reactivity.
+ */
+class ComputedImpl {
+    constructor(computation, equal) {
+        this.computation = computation;
+        this.equal = equal;
+        /**
+         * Current value of the computation.
+         *
+         * This can also be one of the special values `UNSET`, `COMPUTING`, or `ERRORED`.
+         */
+        this.value = UNSET;
+        /**
+         * If `value` is `ERRORED`, the error caught from the last computation attempt which will
+         * be re-thrown.
+         */
+        this.error = null;
+        /**
+         * Flag indicating that the computation is currently stale, meaning that one of the
+         * dependencies has notified of a potential change.
+         *
+         * It's possible that no dependency has _actually_ changed, in which case the `stale`
+         * state can be resolved without recomputing the value.
+         */
+        this.stale = true;
+        this.id = nextReactiveId();
+        this.ref = new WeakRef(this);
+        this.producers = new Map();
+        this.consumers = new Map();
+        this.trackingVersion = 0;
+        this.valueVersion = 0;
+    }
+    checkForChangedValue() {
+        if (!this.stale) {
+            // The current value and its version are already up to date.
+            return;
+        }
+        // The current value is stale. Check whether we need to produce a new one.
+        if (this.value !== UNSET && this.value !== COMPUTING && !consumerPollValueStatus(this)) {
+            // Even though we were previously notified of a potential dependency update, all of
+            // our dependencies report that they have not actually changed in value, so we can
+            // resolve the stale state without needing to recompute the current value.
+            this.stale = false;
+            return;
+        }
+        // The current value is stale, and needs to be recomputed. It still may not change -
+        // that depends on whether the newly computed value is equal to the old.
+        this.recomputeValue();
+    }
+    recomputeValue() {
+        if (this.value === COMPUTING) {
+            // Our computation somehow led to a cyclic read of itself.
+            throw new Error('Detected cycle in computations.');
+        }
+        const oldValue = this.value;
+        this.value = COMPUTING;
+        // As we're re-running the computation, update our dependent tracking version number.
+        this.trackingVersion++;
+        const prevConsumer = setActiveConsumer(this);
+        let newValue;
+        try {
+            newValue = this.computation();
+        }
+        catch (err) {
+            newValue = ERRORED;
+            this.error = err;
+        }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
+        this.stale = false;
+        if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+            this.equal(oldValue, newValue)) {
+            // No change to `valueVersion` - old and new values are
+            // semantically equivalent.
+            this.value = oldValue;
+            return;
+        }
+        this.value = newValue;
+        this.valueVersion++;
+    }
+    notify() {
+        if (this.stale) {
+            // We've already notified consumers that this value has potentially changed.
+            return;
+        }
+        // Record that the currently cached value may be stale.
+        this.stale = true;
+        // Notify any consumers about the potential change.
+        producerNotifyConsumers(this);
+    }
+    signal() {
+        // Check if the value needs updating before returning it.
+        this.checkForChangedValue();
+        // Record that someone looked at this signal.
+        producerAccessed(this);
+        if (this.value === ERRORED) {
+            throw this.error;
+        }
+        return this.value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computed.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/signals/src/computed.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 {createSignalFromFunction, defaultEquals, Signal, ValueEqualityFn} from './api';\nimport {Consumer, ConsumerId, consumerPollValueStatus, Edge, nextReactiveId, Producer, producerAccessed, ProducerId, producerNotifyConsumers, setActiveConsumer} from './graph';\nimport {WeakRef} from './weak_ref';\n\n/**\n * Create a computed `Signal` which derives a reactive value from an expression.\n *\n * @developerPreview\n */\nexport function computed<T>(\n    computation: () => T, equal: ValueEqualityFn<T> = defaultEquals): Signal<T> {\n  const node = new ComputedImpl(computation, equal);\n  return createSignalFromFunction(node.signal.bind(node));\n}\n\n/**\n * A dedicated symbol used before a computed value has been calculated for the first time.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst UNSET: any = Symbol('UNSET');\n\n/**\n * A dedicated symbol used in place of a computed signal value to indicate that a given computation\n * is in progress. Used to detect cycles in computation chains.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst COMPUTING: any = Symbol('COMPUTING');\n\n/**\n * A dedicated symbol used in place of a computed signal value to indicate that a given computation\n * failed. The thrown error is cached until the computation gets dirty again.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst ERRORED: any = Symbol('ERRORED');\n\n/**\n * A computation, which derives a value from a declarative reactive expression.\n *\n * `Computed`s are both `Producer`s and `Consumer`s of reactivity.\n */\nclass ComputedImpl<T> implements Producer, Consumer {\n  /**\n   * Current value of the computation.\n   *\n   * This can also be one of the special values `UNSET`, `COMPUTING`, or `ERRORED`.\n   */\n  private value: T = UNSET;\n\n  /**\n   * If `value` is `ERRORED`, the error caught from the last computation attempt which will\n   * be re-thrown.\n   */\n  private error: unknown = null;\n\n  /**\n   * Flag indicating that the computation is currently stale, meaning that one of the\n   * dependencies has notified of a potential change.\n   *\n   * It's possible that no dependency has _actually_ changed, in which case the `stale`\n   * state can be resolved without recomputing the value.\n   */\n  private stale = true;\n\n  readonly id = nextReactiveId();\n  readonly ref = new WeakRef(this);\n  readonly producers = new Map<ProducerId, Edge>();\n  readonly consumers = new Map<ConsumerId, Edge>();\n  trackingVersion = 0;\n  valueVersion = 0;\n\n  constructor(private computation: () => T, private equal: (oldValue: T, newValue: T) => boolean) {}\n\n  checkForChangedValue(): void {\n    if (!this.stale) {\n      // The current value and its version are already up to date.\n      return;\n    }\n\n    // The current value is stale. Check whether we need to produce a new one.\n\n    if (this.value !== UNSET && this.value !== COMPUTING && !consumerPollValueStatus(this)) {\n      // Even though we were previously notified of a potential dependency update, all of\n      // our dependencies report that they have not actually changed in value, so we can\n      // resolve the stale state without needing to recompute the current value.\n      this.stale = false;\n      return;\n    }\n\n    // The current value is stale, and needs to be recomputed. It still may not change -\n    // that depends on whether the newly computed value is equal to the old.\n    this.recomputeValue();\n  }\n\n  private recomputeValue(): void {\n    if (this.value === COMPUTING) {\n      // Our computation somehow led to a cyclic read of itself.\n      throw new Error('Detected cycle in computations.');\n    }\n\n    const oldValue = this.value;\n    this.value = COMPUTING;\n\n    // As we're re-running the computation, update our dependent tracking version number.\n    this.trackingVersion++;\n    const prevConsumer = setActiveConsumer(this);\n    let newValue: T;\n    try {\n      newValue = this.computation();\n    } catch (err) {\n      newValue = ERRORED;\n      this.error = err;\n    } finally {\n      setActiveConsumer(prevConsumer);\n    }\n\n    this.stale = false;\n\n    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&\n        this.equal(oldValue, newValue)) {\n      // No change to `valueVersion` - old and new values are\n      // semantically equivalent.\n      this.value = oldValue;\n      return;\n    }\n\n    this.value = newValue;\n    this.valueVersion++;\n  }\n\n  notify(): void {\n    if (this.stale) {\n      // We've already notified consumers that this value has potentially changed.\n      return;\n    }\n\n    // Record that the currently cached value may be stale.\n    this.stale = true;\n\n    // Notify any consumers about the potential change.\n    producerNotifyConsumers(this);\n  }\n\n  signal(): T {\n    // Check if the value needs updating before returning it.\n    this.checkForChangedValue();\n\n    // Record that someone looked at this signal.\n    producerAccessed(this);\n\n    if (this.value === ERRORED) {\n      throw this.error;\n    }\n\n    return this.value;\n  }\n}\n"]}

package/esm2020/src/signals/src/effect.mjs

@@ -0,0 +1,69 @@
+/**
+ * @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 { Watch } from './watch';
+/**
+ * Create a global `Effect` for the given reactive function.
+ *
+ * @developerPreview
+ */
+export function effect(effectFn) {
+    const watch = new Watch(effectFn, queueWatch);
+    globalWatches.add(watch);
+    // Effects start dirty.
+    watch.notify();
+    return {
+        consumer: watch,
+        schedule: watch.notify.bind(watch),
+        destroy: () => {
+            queuedWatches.delete(watch);
+            globalWatches.delete(watch);
+        },
+    };
+}
+/**
+ * Get a `Promise` that resolves when any scheduled effects have resolved.
+ */
+export function effectsDone() {
+    return watchQueuePromise?.promise ?? Promise.resolve();
+}
+/**
+ * Shut down all active effects.
+ */
+export function resetEffects() {
+    queuedWatches.clear();
+    globalWatches.clear();
+}
+const globalWatches = new Set();
+const queuedWatches = new Set();
+let watchQueuePromise = null;
+function queueWatch(watch) {
+    if (queuedWatches.has(watch) || !globalWatches.has(watch)) {
+        return;
+    }
+    queuedWatches.add(watch);
+    if (watchQueuePromise === null) {
+        Promise.resolve().then(runWatchQueue);
+        let resolveFn;
+        const promise = new Promise((resolve) => {
+            resolveFn = resolve;
+        });
+        watchQueuePromise = {
+            promise,
+            resolveFn,
+        };
+    }
+}
+function runWatchQueue() {
+    for (const watch of queuedWatches) {
+        queuedWatches.delete(watch);
+        watch.run();
+    }
+    watchQueuePromise.resolveFn();
+    watchQueuePromise = null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/signals/src/graph.mjs

@@ -0,0 +1,114 @@
+/**
+ * @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
+ */
+/**
+ * Tracks the currently active reactive context (or `null` if there is no active
+ * context).
+ */
+let activeConsumer = null;
+/**
+ * Counter tracking the next `ProducerId` or `ConsumerId`.
+ */
+let _nextReactiveId = 0;
+/**
+ * Get a new `ProducerId` or `ConsumerId`, allocated from the global sequence.
+ *
+ * The value returned is a type intersection of both branded types, and thus can be assigned to
+ * either.
+ */
+export function nextReactiveId() {
+    return _nextReactiveId++;
+}
+/**
+ * Set `consumer` as the active reactive context, and return the previous `Consumer`
+ * (if any) for later restoration.
+ */
+export function setActiveConsumer(consumer) {
+    const prevConsumer = activeConsumer;
+    activeConsumer = consumer;
+    return prevConsumer;
+}
+/**
+ * Notify all `Consumer`s of the given `Producer` that its value may have changed.
+ */
+export function producerNotifyConsumers(producer) {
+    for (const [consumerId, edge] of producer.consumers) {
+        const consumer = edge.consumerRef.deref();
+        if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {
+            producer.consumers.delete(consumerId);
+            consumer?.producers.delete(producer.id);
+            continue;
+        }
+        consumer.notify();
+    }
+}
+/**
+ * Record a dependency on the given `Producer` by the current reactive `Consumer` if
+ * one is present.
+ */
+export function producerAccessed(producer) {
+    if (activeConsumer === null) {
+        return;
+    }
+    // Either create or update the dependency `Edge` in both directions.
+    let edge = activeConsumer.producers.get(producer.id);
+    if (edge === undefined) {
+        edge = {
+            consumerRef: activeConsumer.ref,
+            producerRef: producer.ref,
+            seenValueVersion: producer.valueVersion,
+            atTrackingVersion: activeConsumer.trackingVersion,
+        };
+        activeConsumer.producers.set(producer.id, edge);
+        producer.consumers.set(activeConsumer.id, edge);
+    }
+    else {
+        edge.seenValueVersion = producer.valueVersion;
+        edge.atTrackingVersion = activeConsumer.trackingVersion;
+    }
+}
+/**
+ * Checks if a `Producer` has a current value which is different than the value
+ * last seen at a specific version by a `Consumer` which recorded a dependency on
+ * this `Producer`.
+ */
+function producerPollStatus(producer, lastSeenValueVersion) {
+    // `producer.valueVersion` may be stale, but a mismatch still means that the value
+    // last seen by the `Consumer` is also stale.
+    if (producer.valueVersion !== lastSeenValueVersion) {
+        return true;
+    }
+    // Trigger the `Producer` to update its `valueVersion` if necessary.
+    producer.checkForChangedValue();
+    // At this point, we can trust `producer.valueVersion`.
+    return producer.valueVersion !== lastSeenValueVersion;
+}
+/**
+ * Function called to check the stale status of dependencies (producers) for a given consumer. This
+ * is a verification step before refreshing a given consumer: if none of the the dependencies
+ * reports a semantically new value, then the `Consumer` has not observed a real dependency change
+ * (even though it may have been notified of one).
+ */
+export function consumerPollValueStatus(consumer) {
+    for (const [producerId, edge] of consumer.producers) {
+        const producer = edge.producerRef.deref();
+        if (producer === undefined || edge.atTrackingVersion !== consumer.trackingVersion) {
+            // This dependency edge is stale, so remove it.
+            consumer.producers.delete(producerId);
+            producer?.consumers.delete(consumer.id);
+            continue;
+        }
+        if (producerPollStatus(producer, edge.seenValueVersion)) {
+            // One of the dependencies reports a real value change.
+            return true;
+        }
+    }
+    // No dependency reported a real value change, so the `Consumer` has also not been
+    // impacted.
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/signals/src/graph.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 {WeakRef} from './weak_ref';\n\n/**\n * Identifier for a `Producer`, which is a branded `number`.\n *\n * Note that `ProducerId` and `ConsumerId` are assigned from the same sequence, so the same `number`\n * will never be used for both.\n *\n * Branding provides additional type safety by ensuring that `ProducerId` and `ConsumerId` are\n * mutually unassignable without a cast. Since several `Map`s are keyed by these IDs, this prevents\n * `ProducerId`s from being inadvertently used to look up `Consumer`s or vice versa.\n */\nexport type ProducerId = number&{__producer: true};\n\n/**\n * Identifier for a `Consumer`, which is a branded `number`.\n *\n * Note that `ProducerId` and `ConsumerId` are assigned from the same sequence, so the same `number`\n * will never be used for both.\n *\n * Branding provides additional type safety by ensuring that `ProducerId` and `ConsumerId` are\n * mutually unassignable without a cast. Since several `Map`s are keyed by these IDs, this prevents\n * `ConsumerId`s from being inadvertently used to look up `Producer`s or vice versa.\n */\nexport type ConsumerId = number&{__consumer: true};\n\n/**\n * Tracks the currently active reactive context (or `null` if there is no active\n * context).\n */\nlet activeConsumer: Consumer|null = null;\n\n/**\n * Counter tracking the next `ProducerId` or `ConsumerId`.\n */\nlet _nextReactiveId: number = 0;\n\n/**\n * Get a new `ProducerId` or `ConsumerId`, allocated from the global sequence.\n *\n * The value returned is a type intersection of both branded types, and thus can be assigned to\n * either.\n */\nexport function nextReactiveId(): ProducerId&ConsumerId {\n  return (_nextReactiveId++ as ProducerId & ConsumerId);\n}\n\n/**\n * Set `consumer` as the active reactive context, and return the previous `Consumer`\n * (if any) for later restoration.\n */\nexport function setActiveConsumer(consumer: Consumer|null): Consumer|null {\n  const prevConsumer = activeConsumer;\n  activeConsumer = consumer;\n  return prevConsumer;\n}\n\n/**\n * A bidirectional edge in the producer-consumer dependency graph.\n */\nexport interface Edge {\n  /**\n   * Weakly held reference to the `Consumer` side of this edge.\n   */\n  readonly consumerRef: WeakRef<Consumer>;\n\n  /**\n   * Weakly held reference to the `Producer` side of this edge.\n   */\n  readonly producerRef: WeakRef<Producer>;\n\n  /**\n   * `trackingVersion` of the `Consumer` at which this dependency edge was last observed.\n   *\n   * If this doesn't match the `Consumer`'s current `trackingVersion`, then this dependency record\n   * is stale, and needs to be cleaned up.\n   */\n  atTrackingVersion: number;\n\n  /**\n   * `valueVersion` of the `Producer` at the time this dependency was last accessed.\n   *\n   * This is used by `consumerPollValueStatus` to determine whether a `Consumer`'s dependencies have\n   * semantically changed.\n   */\n  seenValueVersion: number;\n}\n\n/**\n * Represents a value that can be read reactively, and can notify readers (`Consumer`s)\n * when it changes.\n *\n * Producers maintain a weak reference to any `Consumer`s which may depend on the\n * producer's value.\n *\n * Implementers of `Producer` expose a monotonic `valueVersion` counter, and are responsible\n * for incrementing this version when their value semantically changes. Some Producers may\n * produce this value lazily and thus at times need to be polled for potential updates to\n * their value (and by extension their `valueVersion`). This is accomplished via the\n * `checkForChangedValue` method for Producers, which should perform whatever calculations\n * are necessary to ensure `valueVersion` is up to date.\n *\n * `Producer`s support two operations:\n *   * `producerNotifyConsumers`\n *   * `producerAccessed`\n */\nexport interface Producer {\n  /**\n   * Numeric identifier of this `Producer`.\n   *\n   * May also be used to satisfy the interface for `Consumer`.\n   */\n  readonly id: ProducerId;\n\n  /**\n   * A `WeakRef` to this `Producer` instance.\n   *\n   * An implementer provides this as a cached value to avoid the need to instantiate\n   * multiple `WeakRef` instances for the same `Producer`.\n   *\n   * May also be used to satisfy the interface for `Consumer`.\n   */\n  readonly ref: WeakRef<Producer>;\n\n  /**\n   * A map of dependency `Edge`s to `Consumer`s, keyed by the `ConsumerId`.\n   *\n   * Used when the produced value changes to notify interested `Consumer`s.\n   */\n  readonly consumers: Map<ConsumerId, Edge>;\n\n  /**\n   * Monotonically increasing counter which increases when the value of this `Producer`\n   * semantically changes.\n   */\n  readonly valueVersion: number;\n\n  /**\n   * Ensure that `valueVersion` is up to date for the `Producer`'s value.\n   *\n   * Some `Producer`s may produce values lazily, and thus require polling before their\n   * `valueVersion` can be compared with the version captured during a previous read.\n   */\n  checkForChangedValue(): void;\n}\n\n/**\n * Notify all `Consumer`s of the given `Producer` that its value may have changed.\n */\nexport function producerNotifyConsumers(producer: Producer): void {\n  for (const [consumerId, edge] of producer.consumers) {\n    const consumer = edge.consumerRef.deref();\n    if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {\n      producer.consumers.delete(consumerId);\n      consumer?.producers.delete(producer.id);\n      continue;\n    }\n\n    consumer.notify();\n  }\n}\n\n/**\n * Record a dependency on the given `Producer` by the current reactive `Consumer` if\n * one is present.\n */\nexport function producerAccessed(producer: Producer): void {\n  if (activeConsumer === null) {\n    return;\n  }\n\n  // Either create or update the dependency `Edge` in both directions.\n  let edge = activeConsumer.producers.get(producer.id);\n  if (edge === undefined) {\n    edge = {\n      consumerRef: activeConsumer.ref,\n      producerRef: producer.ref,\n      seenValueVersion: producer.valueVersion,\n      atTrackingVersion: activeConsumer.trackingVersion,\n    };\n    activeConsumer.producers.set(producer.id, edge);\n    producer.consumers.set(activeConsumer.id, edge);\n  } else {\n    edge.seenValueVersion = producer.valueVersion;\n    edge.atTrackingVersion = activeConsumer.trackingVersion;\n  }\n}\n\n/**\n * Checks if a `Producer` has a current value which is different than the value\n * last seen at a specific version by a `Consumer` which recorded a dependency on\n * this `Producer`.\n */\nfunction producerPollStatus(producer: Producer, lastSeenValueVersion: number): boolean {\n  // `producer.valueVersion` may be stale, but a mismatch still means that the value\n  // last seen by the `Consumer` is also stale.\n  if (producer.valueVersion !== lastSeenValueVersion) {\n    return true;\n  }\n\n  // Trigger the `Producer` to update its `valueVersion` if necessary.\n  producer.checkForChangedValue();\n\n  // At this point, we can trust `producer.valueVersion`.\n  return producer.valueVersion !== lastSeenValueVersion;\n}\n\n/**\n * Represents a reader that can depend on reactive values (`Producer`s) and receive\n * notifications when those values change.\n *\n * `Consumer`s do not wrap the reads they consume themselves, but rather can be set\n * as the active reader via `setActiveConsumer`.\n *\n * The set of dependencies of a `Consumer` is dynamic. Implementers expose a\n * monotonically increasing `trackingVersion` counter, which increments whenever\n * the `Consumer` is about to re-run any reactive reads it needs and establish a\n * new set of dependencies as a result.\n *\n * `Producer`s store the last `trackingVersion` they've seen from `Consumer`s which\n * have read them. This allows a `Producer` to identify whether its record of the\n * dependency is current or stale, by comparing the `Consumer`'s `trackingVersion`\n * to the version at which the dependency was established.\n */\nexport interface Consumer {\n  /**\n   * Numeric identifier of this `Producer`.\n   *\n   * May also be used to satisfy the interface for `Producer`.\n   */\n  readonly id: ConsumerId;\n\n  /**\n   * A `WeakRef` to this `Consumer` instance.\n   *\n   * An implementer provides this as a cached value to avoid the need to instantiate\n   * multiple `WeakRef` instances for the same `Consumer`.\n   *\n   * May also be used to satisfy the interface for `Producer`.\n   */\n  readonly ref: WeakRef<Consumer>;\n\n  /**\n   * A map of `Edge`s to `Producer` dependencies, keyed by the `ProducerId`.\n   *\n   * Used to poll `Producer`s to determine if the `Consumer` has really updated\n   * or not.\n   */\n  readonly producers: Map<ProducerId, Edge>;\n\n  /**\n   * Monotonically increasing counter representing a version of this `Consumer`'s\n   * dependencies.\n   */\n  readonly trackingVersion: number;\n\n  /**\n   * Called when a `Producer` dependency of this `Consumer` indicates it may\n   * have a new value.\n   *\n   * Notification alone does not mean the `Producer` has definitely produced a\n   * semantically different value, only that it _may_ have changed. Before a\n   * `Consumer` re-runs any computations or side effects, it should use the\n   * `consumerPollValueStatus` method to poll the `Producer`s on which it depends\n   * and determine if any of them have actually updated.\n   */\n  notify(): void;\n}\n\n/**\n * Function called to check the stale status of dependencies (producers) for a given consumer. This\n * is a verification step before refreshing a given consumer: if none of the the dependencies\n * reports a semantically new value, then the `Consumer` has not observed a real dependency change\n * (even though it may have been notified of one).\n */\nexport function consumerPollValueStatus(consumer: Consumer): boolean {\n  for (const [producerId, edge] of consumer.producers) {\n    const producer = edge.producerRef.deref();\n\n    if (producer === undefined || edge.atTrackingVersion !== consumer.trackingVersion) {\n      // This dependency edge is stale, so remove it.\n      consumer.producers.delete(producerId);\n      producer?.consumers.delete(consumer.id);\n      continue;\n    }\n\n    if (producerPollStatus(producer, edge.seenValueVersion)) {\n      // One of the dependencies reports a real value change.\n      return true;\n    }\n  }\n\n  // No dependency reported a real value change, so the `Consumer` has also not been\n  // impacted.\n  return false;\n}\n"]}