@angular/core 17.0.0-next.2 → 17.0.0-next.4

package/esm2022/src/render3/reactive_lview_consumer.mjs

@@ -5,51 +5,14 @@
  * 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 { ReactiveNode, setActiveConsumer } from '../signals';
+import { REACTIVE_NODE } from '../signals';
 import { assertDefined, assertEqual } from '../util/assert';
 import { markViewDirty } from './instructions/mark_view_dirty';
-export class ReactiveLViewConsumer extends ReactiveNode {
-    constructor() {
-        super(...arguments);
-        this.consumerAllowSignalWrites = false;
-        this._lView = null;
-    }
-    set lView(lView) {
-        (typeof ngDevMode === 'undefined' || ngDevMode) &&
-            assertEqual(this._lView, null, 'Consumer already associated with a view.');
-        this._lView = lView;
-    }
-    onConsumerDependencyMayHaveChanged() {
-        (typeof ngDevMode === 'undefined' || ngDevMode) &&
-            assertDefined(this._lView, 'Updating a signal during template or host binding execution is not allowed.');
-        markViewDirty(this._lView);
-    }
-    onProducerUpdateValueVersion() {
-        // This type doesn't implement the producer side of a `ReactiveNode`.
-    }
-    get hasReadASignal() {
-        return this.hasProducers;
-    }
-    runInContext(fn, rf, ctx) {
-        const prevConsumer = setActiveConsumer(this);
-        this.trackingVersion++;
-        try {
-            fn(rf, ctx);
-        }
-        finally {
-            setActiveConsumer(prevConsumer);
-        }
-    }
-    destroy() {
-        // Incrementing the version means that every producer which tries to update this consumer will
-        // consider its record stale, and not notify.
-        this.trackingVersion++;
-    }
-}
 let currentConsumer = null;
-function getOrCreateCurrentLViewConsumer() {
-    currentConsumer ??= new ReactiveLViewConsumer();
-    return currentConsumer;
+export function setLViewForConsumer(node, lView) {
+    (typeof ngDevMode === 'undefined' || ngDevMode) &&
+        assertEqual(node.lView, null, 'Consumer already associated with a view.');
+    node.lView = lView;
 }
 /**
  * Create a new template consumer pointing at the specified LView.
@@ -71,11 +34,28 @@ export function getReactiveLViewConsumer(lView, slot) {
  */
 export function commitLViewConsumerIfHasProducers(lView, slot) {
     const consumer = getOrCreateCurrentLViewConsumer();
-    if (!consumer.hasReadASignal) {
+    if (!consumer.producerNode?.length) {
         return;
     }
     lView[slot] = currentConsumer;
     consumer.lView = lView;
-    currentConsumer = new ReactiveLViewConsumer();
+    currentConsumer = createLViewConsumer();
+}
+const REACTIVE_LVIEW_CONSUMER_NODE = {
+    ...REACTIVE_NODE,
+    consumerIsAlwaysLive: true,
+    consumerMarkedDirty: (node) => {
+        (typeof ngDevMode === 'undefined' || ngDevMode) &&
+            assertDefined(node.lView, 'Updating a signal during template or host binding execution is not allowed.');
+        markViewDirty(node.lView);
+    },
+    lView: null,
+};
+function createLViewConsumer() {
+    return Object.create(REACTIVE_LVIEW_CONSUMER_NODE);
+}
+function getOrCreateCurrentLViewConsumer() {
+    currentConsumer ??= createLViewConsumer();
+    return currentConsumer;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/render3/reactivity/effect.mjs

@@ -6,66 +6,166 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { assertInInjectionContext } from '../../di/contextual';
+import { InjectionToken } from '../../di/injection_token';
 import { Injector } from '../../di/injector';
 import { inject } from '../../di/injector_compatibility';
 import { ɵɵdefineInjectable } from '../../di/interface/defs';
+import { ErrorHandler } from '../../error_handler';
 import { DestroyRef } from '../../linker/destroy_ref';
-import { Watch } from '../../signals';
+import { isInNotificationPhase, watch } from '../../signals';
 /**
- * Tracks all effects registered within a given application and runs them via `flush`.
+ * Not public API, which guarantees `EffectScheduler` only ever comes from the application root
+ * injector.
  */
-export class EffectManager {
+export const APP_EFFECT_SCHEDULER = new InjectionToken('', {
+    providedIn: 'root',
+    factory: () => inject(EffectScheduler),
+});
+/**
+ * A scheduler which manages the execution of effects.
+ */
+export class EffectScheduler {
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: EffectScheduler,
+        providedIn: 'root',
+        factory: () => new ZoneAwareMicrotaskScheduler(),
+    }); }
+}
+/**
+ * An `EffectScheduler` which is capable of queueing scheduled effects per-zone, and flushing them
+ * as an explicit operation.
+ */
+export class ZoneAwareQueueingScheduler {
     constructor() {
-        this.all = new Set();
-        this.queue = new Map();
-    }
-    create(effectFn, destroyRef, allowSignalWrites) {
-        const zone = (typeof Zone === 'undefined') ? null : Zone.current;
-        const watch = new Watch(effectFn, (watch) => {
-            if (!this.all.has(watch)) {
-                return;
-            }
-            this.queue.set(watch, zone);
-        }, allowSignalWrites);
-        this.all.add(watch);
-        // Effects start dirty.
-        watch.notify();
-        let unregisterOnDestroy;
-        const destroy = () => {
-            watch.cleanup();
-            unregisterOnDestroy?.();
-            this.all.delete(watch);
-            this.queue.delete(watch);
-        };
-        unregisterOnDestroy = destroyRef?.onDestroy(destroy);
-        return {
-            destroy,
-        };
+        this.queuedEffectCount = 0;
+        this.queues = new Map();
     }
-    flush() {
-        if (this.queue.size === 0) {
+    scheduleEffect(handle) {
+        const zone = handle.creationZone;
+        if (!this.queues.has(zone)) {
+            this.queues.set(zone, new Set());
+        }
+        const queue = this.queues.get(zone);
+        if (queue.has(handle)) {
             return;
         }
-        for (const [watch, zone] of this.queue) {
-            this.queue.delete(watch);
-            if (zone) {
-                zone.run(() => watch.run());
-            }
-            else {
-                watch.run();
+        this.queuedEffectCount++;
+        queue.add(handle);
+    }
+    /**
+     * Run all scheduled effects.
+     *
+     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
+     * ordering guarantee between effects scheduled in different zones.
+     */
+    flush() {
+        while (this.queuedEffectCount > 0) {
+            for (const [zone, queue] of this.queues) {
+                // `zone` here must be defined.
+                if (zone === null) {
+                    this.flushQueue(queue);
+                }
+                else {
+                    zone.run(() => this.flushQueue(queue));
+                }
             }
         }
     }
-    get isQueueEmpty() {
-        return this.queue.size === 0;
+    flushQueue(queue) {
+        for (const handle of queue) {
+            queue.delete(handle);
+            this.queuedEffectCount--;
+            // TODO: what happens if this throws an error?
+            handle.run();
+        }
     }
     /** @nocollapse */
     static { this.ɵprov = ɵɵdefineInjectable({
-        token: EffectManager,
+        token: ZoneAwareQueueingScheduler,
         providedIn: 'root',
-        factory: () => new EffectManager(),
+        factory: () => new ZoneAwareQueueingScheduler(),
     }); }
 }
+/**
+ * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue
+ * when.
+ */
+export class ZoneAwareMicrotaskScheduler {
+    constructor() {
+        this.hasQueuedFlush = false;
+        this.delegate = new ZoneAwareQueueingScheduler();
+        this.flushTask = () => {
+            // Leave `hasQueuedFlush` as `true` so we don't queue another microtask if more effects are
+            // scheduled during flushing. The flush of the `ZoneAwareQueueingScheduler` delegate is
+            // guaranteed to empty the queue.
+            this.delegate.flush();
+            this.hasQueuedFlush = false;
+            // This is a variable initialization, not a method.
+            // tslint:disable-next-line:semicolon
+        };
+    }
+    scheduleEffect(handle) {
+        this.delegate.scheduleEffect(handle);
+        if (!this.hasQueuedFlush) {
+            queueMicrotask(this.flushTask);
+            this.hasQueuedFlush = true;
+        }
+    }
+}
+/**
+ * Core reactive node for an Angular effect.
+ *
+ * `EffectHandle` combines the reactive graph's `Watch` base node for effects with the framework's
+ * scheduling abstraction (`EffectScheduler`) as well as automatic cleanup via `DestroyRef` if
+ * available/requested.
+ */
+class EffectHandle {
+    constructor(scheduler, effectFn, creationZone, destroyRef, errorHandler, allowSignalWrites) {
+        this.scheduler = scheduler;
+        this.effectFn = effectFn;
+        this.creationZone = creationZone;
+        this.errorHandler = errorHandler;
+        this.alive = true;
+        this.watcher =
+            watch((onCleanup) => this.runEffect(onCleanup), () => this.schedule(), allowSignalWrites);
+        this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());
+    }
+    runEffect(onCleanup) {
+        if (!this.alive) {
+            // Running a destroyed effect is a no-op.
+            return;
+        }
+        if (ngDevMode && isInNotificationPhase()) {
+            throw new Error(`Schedulers cannot synchronously execute effects while scheduling.`);
+        }
+        try {
+            this.effectFn(onCleanup);
+        }
+        catch (err) {
+            this.errorHandler?.handleError(err);
+        }
+    }
+    run() {
+        this.watcher.run();
+    }
+    schedule() {
+        if (!this.alive) {
+            return;
+        }
+        this.scheduler.scheduleEffect(this);
+    }
+    notify() {
+        this.watcher.notify();
+    }
+    destroy() {
+        this.alive = false;
+        this.watcher.cleanup();
+        this.unregisterOnDestroy?.();
+        // Note: if the effect is currently scheduled, it's not un-scheduled, and so the scheduler will
+        // retain a reference to it. Attempting to execute it will be a no-op.
+    }
+}
 /**
  * Create a global `Effect` for the given reactive function.
  *
@@ -74,8 +174,11 @@ export class EffectManager {
 export function effect(effectFn, options) {
     !options?.injector && assertInInjectionContext(effect);
     const injector = options?.injector ?? inject(Injector);
-    const effectManager = injector.get(EffectManager);
+    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
     const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
-    return effectManager.create(effectFn, destroyRef, !!options?.allowSignalWrites);
+    const handle = new EffectHandle(injector.get(APP_EFFECT_SCHEDULER), effectFn, (typeof Zone === 'undefined') ? null : Zone.current, destroyRef, errorHandler, options?.allowSignalWrites ?? false);
+    // Effects start dirty.
+    handle.notify();
+    return handle;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"effect.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/reactivity/effect.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 {assertInInjectionContext} from '../../di/contextual';\nimport {Injector} from '../../di/injector';\nimport {inject} from '../../di/injector_compatibility';\nimport {ɵɵdefineInjectable} from '../../di/interface/defs';\nimport {DestroyRef} from '../../linker/destroy_ref';\nimport {Watch} from '../../signals';\n\n/**\n * An effect can, optionally, register a cleanup function. If registered, the cleanup is executed\n * before the next effect run. The cleanup function makes it possible to \"cancel\" any work that the\n * previous effect run might have started.\n *\n * @developerPreview\n */\nexport type EffectCleanupFn = () => void;\n\n/**\n * A callback passed to the effect function that makes it possible to register cleanup logic.\n */\nexport type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;\n\n/**\n * Tracks all effects registered within a given application and runs them via `flush`.\n */\nexport class EffectManager {\n  private all = new Set<Watch>();\n  private queue = new Map<Watch, Zone|null>();\n\n  create(\n      effectFn: (onCleanup: (cleanupFn: EffectCleanupFn) => void) => void,\n      destroyRef: DestroyRef|null, allowSignalWrites: boolean): EffectRef {\n    const zone = (typeof Zone === 'undefined') ? null : Zone.current;\n    const watch = new Watch(effectFn, (watch) => {\n      if (!this.all.has(watch)) {\n        return;\n      }\n\n      this.queue.set(watch, zone);\n    }, allowSignalWrites);\n\n    this.all.add(watch);\n\n    // Effects start dirty.\n    watch.notify();\n\n    let unregisterOnDestroy: (() => void)|undefined;\n\n    const destroy = () => {\n      watch.cleanup();\n      unregisterOnDestroy?.();\n      this.all.delete(watch);\n      this.queue.delete(watch);\n    };\n\n    unregisterOnDestroy = destroyRef?.onDestroy(destroy);\n\n    return {\n      destroy,\n    };\n  }\n\n  flush(): void {\n    if (this.queue.size === 0) {\n      return;\n    }\n\n    for (const [watch, zone] of this.queue) {\n      this.queue.delete(watch);\n      if (zone) {\n        zone.run(() => watch.run());\n      } else {\n        watch.run();\n      }\n    }\n  }\n\n  get isQueueEmpty(): boolean {\n    return this.queue.size === 0;\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: EffectManager,\n    providedIn: 'root',\n    factory: () => new EffectManager(),\n  });\n}\n\n/**\n * A global reactive effect, which can be manually destroyed.\n *\n * @developerPreview\n */\nexport interface EffectRef {\n  /**\n   * Shut down the effect, removing it from any upcoming scheduled executions.\n   */\n  destroy(): void;\n}\n\n/**\n * Options passed to the `effect` function.\n *\n * @developerPreview\n */\nexport interface CreateEffectOptions {\n  /**\n   * The `Injector` in which to create the effect.\n   *\n   * If this is not provided, the current [injection context](guide/dependency-injection-context)\n   * will be used instead (via `inject`).\n   */\n  injector?: Injector;\n\n  /**\n   * Whether the `effect` should require manual cleanup.\n   *\n   * If this is `false` (the default) the effect will automatically register itself to be cleaned up\n   * with the current `DestroyRef`.\n   */\n  manualCleanup?: boolean;\n\n  /**\n   * Whether the `effect` should allow writing to signals.\n   *\n   * Using effects to synchronize data by writing to signals can lead to confusing and potentially\n   * incorrect behavior, and should be enabled only when necessary.\n   */\n  allowSignalWrites?: boolean;\n}\n\n/**\n * Create a global `Effect` for the given reactive function.\n *\n * @developerPreview\n */\nexport function effect(\n    effectFn: (onCleanup: EffectCleanupRegisterFn) => void,\n    options?: CreateEffectOptions): EffectRef {\n  !options?.injector && assertInInjectionContext(effect);\n  const injector = options?.injector ?? inject(Injector);\n  const effectManager = injector.get(EffectManager);\n  const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;\n  return effectManager.create(effectFn, destroyRef, !!options?.allowSignalWrites);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"effect.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/reactivity/effect.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 {assertInInjectionContext} from '../../di/contextual';\nimport {InjectionToken} from '../../di/injection_token';\nimport {Injector} from '../../di/injector';\nimport {inject} from '../../di/injector_compatibility';\nimport {ɵɵdefineInjectable} from '../../di/interface/defs';\nimport {ErrorHandler} from '../../error_handler';\nimport {DestroyRef} from '../../linker/destroy_ref';\nimport {isInNotificationPhase, watch, Watch, WatchCleanupFn, WatchCleanupRegisterFn} from '../../signals';\n\n\n/**\n * An effect can, optionally, register a cleanup function. If registered, the cleanup is executed\n * before the next effect run. The cleanup function makes it possible to \"cancel\" any work that the\n * previous effect run might have started.\n *\n * @developerPreview\n */\nexport type EffectCleanupFn = () => void;\n\n/**\n * A callback passed to the effect function that makes it possible to register cleanup logic.\n */\nexport type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;\n\nexport interface SchedulableEffect {\n  run(): void;\n  creationZone: unknown;\n}\n\n/**\n * Not public API, which guarantees `EffectScheduler` only ever comes from the application root\n * injector.\n */\nexport const APP_EFFECT_SCHEDULER = new InjectionToken('', {\n  providedIn: 'root',\n  factory: () => inject(EffectScheduler),\n});\n\n/**\n * A scheduler which manages the execution of effects.\n */\nexport abstract class EffectScheduler {\n  /**\n   * Schedule the given effect to be executed at a later time.\n   *\n   * It is an error to attempt to execute any effects synchronously during a scheduling operation.\n   */\n  abstract scheduleEffect(e: SchedulableEffect): void;\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: EffectScheduler,\n    providedIn: 'root',\n    factory: () => new ZoneAwareMicrotaskScheduler(),\n  });\n}\n\n/**\n * Interface to an `EffectScheduler` capable of running scheduled effects synchronously.\n */\nexport interface FlushableEffectRunner {\n  /**\n   * Run any scheduled effects.\n   */\n  flush(): void;\n}\n\n/**\n * An `EffectScheduler` which is capable of queueing scheduled effects per-zone, and flushing them\n * as an explicit operation.\n */\nexport class ZoneAwareQueueingScheduler implements EffectScheduler, FlushableEffectRunner {\n  private queuedEffectCount = 0;\n  private queues = new Map<Zone|null, Set<SchedulableEffect>>();\n\n  scheduleEffect(handle: SchedulableEffect): void {\n    const zone = handle.creationZone as Zone | null;\n    if (!this.queues.has(zone)) {\n      this.queues.set(zone, new Set());\n    }\n\n    const queue = this.queues.get(zone)!;\n    if (queue.has(handle)) {\n      return;\n    }\n    this.queuedEffectCount++;\n    queue.add(handle);\n  }\n\n  /**\n   * Run all scheduled effects.\n   *\n   * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no\n   * ordering guarantee between effects scheduled in different zones.\n   */\n  flush(): void {\n    while (this.queuedEffectCount > 0) {\n      for (const [zone, queue] of this.queues) {\n        // `zone` here must be defined.\n        if (zone === null) {\n          this.flushQueue(queue);\n        } else {\n          zone.run(() => this.flushQueue(queue));\n        }\n      }\n    }\n  }\n\n  private flushQueue(queue: Set<SchedulableEffect>): void {\n    for (const handle of queue) {\n      queue.delete(handle);\n      this.queuedEffectCount--;\n\n      // TODO: what happens if this throws an error?\n      handle.run();\n    }\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: ZoneAwareQueueingScheduler,\n    providedIn: 'root',\n    factory: () => new ZoneAwareQueueingScheduler(),\n  });\n}\n\n/**\n * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue\n * when.\n */\nexport class ZoneAwareMicrotaskScheduler implements EffectScheduler {\n  private hasQueuedFlush = false;\n  private delegate = new ZoneAwareQueueingScheduler();\n  private flushTask = () => {\n    // Leave `hasQueuedFlush` as `true` so we don't queue another microtask if more effects are\n    // scheduled during flushing. The flush of the `ZoneAwareQueueingScheduler` delegate is\n    // guaranteed to empty the queue.\n    this.delegate.flush();\n    this.hasQueuedFlush = false;\n\n    // This is a variable initialization, not a method.\n    // tslint:disable-next-line:semicolon\n  };\n\n  scheduleEffect(handle: SchedulableEffect): void {\n    this.delegate.scheduleEffect(handle);\n\n    if (!this.hasQueuedFlush) {\n      queueMicrotask(this.flushTask);\n      this.hasQueuedFlush = true;\n    }\n  }\n}\n\n/**\n * Core reactive node for an Angular effect.\n *\n * `EffectHandle` combines the reactive graph's `Watch` base node for effects with the framework's\n * scheduling abstraction (`EffectScheduler`) as well as automatic cleanup via `DestroyRef` if\n * available/requested.\n */\nclass EffectHandle implements EffectRef, SchedulableEffect {\n  private alive = true;\n  unregisterOnDestroy: (() => void)|undefined;\n  protected watcher: Watch;\n\n  constructor(\n      private scheduler: EffectScheduler,\n      private effectFn: (onCleanup: EffectCleanupRegisterFn) => void,\n      public creationZone: Zone|null, destroyRef: DestroyRef|null,\n      private errorHandler: ErrorHandler|null, allowSignalWrites: boolean) {\n    this.watcher =\n        watch((onCleanup) => this.runEffect(onCleanup), () => this.schedule(), allowSignalWrites);\n    this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());\n  }\n\n  private runEffect(onCleanup: WatchCleanupRegisterFn): void {\n    if (!this.alive) {\n      // Running a destroyed effect is a no-op.\n      return;\n    }\n    if (ngDevMode && isInNotificationPhase()) {\n      throw new Error(`Schedulers cannot synchronously execute effects while scheduling.`);\n    }\n\n    try {\n      this.effectFn(onCleanup);\n    } catch (err) {\n      this.errorHandler?.handleError(err);\n    }\n  }\n\n  run(): void {\n    this.watcher.run();\n  }\n\n  private schedule(): void {\n    if (!this.alive) {\n      return;\n    }\n\n    this.scheduler.scheduleEffect(this);\n  }\n\n  notify(): void {\n    this.watcher.notify();\n  }\n\n  destroy(): void {\n    this.alive = false;\n\n    this.watcher.cleanup();\n    this.unregisterOnDestroy?.();\n\n    // Note: if the effect is currently scheduled, it's not un-scheduled, and so the scheduler will\n    // retain a reference to it. Attempting to execute it will be a no-op.\n  }\n}\n\n/**\n * A global reactive effect, which can be manually destroyed.\n *\n * @developerPreview\n */\nexport interface EffectRef {\n  /**\n   * Shut down the effect, removing it from any upcoming scheduled executions.\n   */\n  destroy(): void;\n}\n\n/**\n * Options passed to the `effect` function.\n *\n * @developerPreview\n */\nexport interface CreateEffectOptions {\n  /**\n   * The `Injector` in which to create the effect.\n   *\n   * If this is not provided, the current [injection context](guide/dependency-injection-context)\n   * will be used instead (via `inject`).\n   */\n  injector?: Injector;\n\n  /**\n   * Whether the `effect` should require manual cleanup.\n   *\n   * If this is `false` (the default) the effect will automatically register itself to be cleaned up\n   * with the current `DestroyRef`.\n   */\n  manualCleanup?: boolean;\n\n  /**\n   * Whether the `effect` should allow writing to signals.\n   *\n   * Using effects to synchronize data by writing to signals can lead to confusing and potentially\n   * incorrect behavior, and should be enabled only when necessary.\n   */\n  allowSignalWrites?: boolean;\n}\n\n/**\n * Create a global `Effect` for the given reactive function.\n *\n * @developerPreview\n */\nexport function effect(\n    effectFn: (onCleanup: EffectCleanupRegisterFn) => void,\n    options?: CreateEffectOptions): EffectRef {\n  !options?.injector && assertInInjectionContext(effect);\n  const injector = options?.injector ?? inject(Injector);\n  const errorHandler = injector.get(ErrorHandler, null, {optional: true});\n  const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;\n\n  const handle = new EffectHandle(\n      injector.get(APP_EFFECT_SCHEDULER), effectFn,\n      (typeof Zone === 'undefined') ? null : Zone.current, destroyRef, errorHandler,\n      options?.allowSignalWrites ?? false);\n\n  // Effects start dirty.\n  handle.notify();\n\n  return handle;\n}\n"]}

package/esm2022/src/render3/util/injector_utils.mjs

@@ -45,4 +45,4 @@ export function getParentInjectorView(location, startView) {
     }
     return parentView;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/render3/view_manipulation.mjs

@@ -5,6 +5,7 @@
  * 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 { hasInSkipHydrationBlockFlag } from '../hydration/skip_hydration';
 import { assertDefined } from '../util/assert';
 import { assertLContainer, assertLView, assertTNodeForLView } from './assert';
 import { renderView } from './instructions/render';
@@ -19,7 +20,7 @@ export function createAndRenderEmbeddedLView(declarationLView, templateTNode, co
     // Embedded views follow the change detection strategy of the view they're declared in.
     const isSignalView = declarationLView[FLAGS] & 4096 /* LViewFlags.SignalView */;
     const viewFlags = isSignalView ? 4096 /* LViewFlags.SignalView */ : 16 /* LViewFlags.CheckAlways */;
-    const embeddedLView = createLView(declarationLView, embeddedTView, context, viewFlags, null, templateTNode, null, null, null, options?.injector ?? null, options?.hydrationInfo ?? null);
+    const embeddedLView = createLView(declarationLView, embeddedTView, context, viewFlags, null, templateTNode, null, null, null, options?.injector ?? null, options?.dehydratedView ?? null);
     const declarationLContainer = declarationLView[templateTNode.index];
     ngDevMode && assertLContainer(declarationLContainer);
     embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;
@@ -41,6 +42,16 @@ export function getLViewFromLContainer(lContainer, index) {
     }
     return undefined;
 }
+/**
+ * Returns whether an elements that belong to a view should be
+ * inserted into the DOM. For client-only cases, DOM elements are
+ * always inserted. For hydration cases, we check whether serialized
+ * info is available for a view and the view is not in a "skip hydration"
+ * block (in which case view contents was re-created, thus needing insertion).
+ */
+export function shouldAddViewToDom(tNode, dehydratedView) {
+    return !dehydratedView || hasInSkipHydrationBlockFlag(tNode);
+}
 export function addLViewToLContainer(lContainer, lView, index, addToDOM = true) {
     const tView = lView[TVIEW];
     // insert to the view tree so the new view can be change-detected
@@ -62,4 +73,4 @@ export function removeLViewFromLContainer(lContainer, index) {
     }
     return lView;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view_manipulation.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/view_manipulation.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 {Injector} from '../di/injector';\nimport {DehydratedContainerView} from '../hydration/interfaces';\nimport {assertDefined} from '../util/assert';\n\nimport {assertLContainer, assertLView, assertTNodeForLView} from './assert';\nimport {renderView} from './instructions/render';\nimport {createLView} from './instructions/shared';\nimport {CONTAINER_HEADER_OFFSET, LContainer, NATIVE} from './interfaces/container';\nimport {TNode} from './interfaces/node';\nimport {RComment, RElement} from './interfaces/renderer_dom';\nimport {DECLARATION_LCONTAINER, FLAGS, LView, LViewFlags, QUERIES, RENDERER, T_HOST, TVIEW} from './interfaces/view';\nimport {addViewToDOM, destroyLView, detachView, getBeforeNodeForView, insertView, nativeParentNode} from './node_manipulation';\n\nexport function createAndRenderEmbeddedLView<T>(\n    declarationLView: LView<unknown>, templateTNode: TNode, context: T,\n    options?: {injector?: Injector, hydrationInfo?: DehydratedContainerView}): LView<T> {\n  const embeddedTView = templateTNode.tView!;\n  ngDevMode && assertDefined(embeddedTView, 'TView must be defined for a template node.');\n  ngDevMode && assertTNodeForLView(templateTNode, declarationLView);\n\n  // Embedded views follow the change detection strategy of the view they're declared in.\n  const isSignalView = declarationLView[FLAGS] & LViewFlags.SignalView;\n  const viewFlags = isSignalView ? LViewFlags.SignalView : LViewFlags.CheckAlways;\n  const embeddedLView = createLView<T>(\n      declarationLView, embeddedTView, context, viewFlags, null, templateTNode, null, null, null,\n      options?.injector ?? null, options?.hydrationInfo ?? null);\n\n  const declarationLContainer = declarationLView[templateTNode.index];\n  ngDevMode && assertLContainer(declarationLContainer);\n  embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;\n\n  const declarationViewLQueries = declarationLView[QUERIES];\n  if (declarationViewLQueries !== null) {\n    embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);\n  }\n\n  // execute creation mode of a view\n  renderView(embeddedTView, embeddedLView, context);\n\n  return embeddedLView;\n}\n\nexport function getLViewFromLContainer<T>(lContainer: LContainer, index: number): LView<T>|\n    undefined {\n  const adjustedIndex = CONTAINER_HEADER_OFFSET + index;\n  // avoid reading past the array boundaries\n  if (adjustedIndex < lContainer.length) {\n    const lView = lContainer[adjustedIndex];\n    ngDevMode && assertLView(lView);\n    return lView as LView<T>;\n  }\n  return undefined;\n}\n\nexport function addLViewToLContainer(\n    lContainer: LContainer, lView: LView<unknown>, index: number, addToDOM = true): void {\n  const tView = lView[TVIEW];\n\n  // insert to the view tree so the new view can be change-detected\n  insertView(tView, lView, lContainer, index);\n\n  // insert to the view to the DOM tree\n  if (addToDOM) {\n    const beforeNode = getBeforeNodeForView(index, lContainer);\n    const renderer = lView[RENDERER];\n    const parentRNode = nativeParentNode(renderer, lContainer[NATIVE] as RElement | RComment);\n    if (parentRNode !== null) {\n      addViewToDOM(tView, lContainer[T_HOST], renderer, lView, parentRNode, beforeNode);\n    }\n  }\n}\n\nexport function removeLViewFromLContainer(lContainer: LContainer, index: number): LView<unknown>|\n    undefined {\n  const lView = detachView(lContainer, index);\n  if (lView !== undefined) {\n    destroyLView(lView[TVIEW], lView);\n  }\n  return lView;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view_manipulation.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/view_manipulation.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 {Injector} from '../di/injector';\nimport {DehydratedContainerView} from '../hydration/interfaces';\nimport {hasInSkipHydrationBlockFlag} from '../hydration/skip_hydration';\nimport {assertDefined} from '../util/assert';\n\nimport {assertLContainer, assertLView, assertTNodeForLView} from './assert';\nimport {renderView} from './instructions/render';\nimport {createLView} from './instructions/shared';\nimport {CONTAINER_HEADER_OFFSET, LContainer, NATIVE} from './interfaces/container';\nimport {TNode} from './interfaces/node';\nimport {RComment, RElement} from './interfaces/renderer_dom';\nimport {DECLARATION_LCONTAINER, FLAGS, LView, LViewFlags, QUERIES, RENDERER, T_HOST, TVIEW} from './interfaces/view';\nimport {addViewToDOM, destroyLView, detachView, getBeforeNodeForView, insertView, nativeParentNode} from './node_manipulation';\n\nexport function createAndRenderEmbeddedLView<T>(\n    declarationLView: LView<unknown>, templateTNode: TNode, context: T,\n    options?: {injector?: Injector, dehydratedView?: DehydratedContainerView|null}): LView<T> {\n  const embeddedTView = templateTNode.tView!;\n  ngDevMode && assertDefined(embeddedTView, 'TView must be defined for a template node.');\n  ngDevMode && assertTNodeForLView(templateTNode, declarationLView);\n\n  // Embedded views follow the change detection strategy of the view they're declared in.\n  const isSignalView = declarationLView[FLAGS] & LViewFlags.SignalView;\n  const viewFlags = isSignalView ? LViewFlags.SignalView : LViewFlags.CheckAlways;\n  const embeddedLView = createLView<T>(\n      declarationLView, embeddedTView, context, viewFlags, null, templateTNode, null, null, null,\n      options?.injector ?? null, options?.dehydratedView ?? null);\n\n  const declarationLContainer = declarationLView[templateTNode.index];\n  ngDevMode && assertLContainer(declarationLContainer);\n  embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;\n\n  const declarationViewLQueries = declarationLView[QUERIES];\n  if (declarationViewLQueries !== null) {\n    embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);\n  }\n\n  // execute creation mode of a view\n  renderView(embeddedTView, embeddedLView, context);\n\n  return embeddedLView;\n}\n\nexport function getLViewFromLContainer<T>(lContainer: LContainer, index: number): LView<T>|\n    undefined {\n  const adjustedIndex = CONTAINER_HEADER_OFFSET + index;\n  // avoid reading past the array boundaries\n  if (adjustedIndex < lContainer.length) {\n    const lView = lContainer[adjustedIndex];\n    ngDevMode && assertLView(lView);\n    return lView as LView<T>;\n  }\n  return undefined;\n}\n\n/**\n * Returns whether an elements that belong to a view should be\n * inserted into the DOM. For client-only cases, DOM elements are\n * always inserted. For hydration cases, we check whether serialized\n * info is available for a view and the view is not in a \"skip hydration\"\n * block (in which case view contents was re-created, thus needing insertion).\n */\nexport function shouldAddViewToDom(\n    tNode: TNode, dehydratedView?: DehydratedContainerView|null): boolean {\n  return !dehydratedView || hasInSkipHydrationBlockFlag(tNode);\n}\n\nexport function addLViewToLContainer(\n    lContainer: LContainer, lView: LView<unknown>, index: number, addToDOM = true): void {\n  const tView = lView[TVIEW];\n\n  // insert to the view tree so the new view can be change-detected\n  insertView(tView, lView, lContainer, index);\n\n  // insert to the view to the DOM tree\n  if (addToDOM) {\n    const beforeNode = getBeforeNodeForView(index, lContainer);\n    const renderer = lView[RENDERER];\n    const parentRNode = nativeParentNode(renderer, lContainer[NATIVE] as RElement | RComment);\n    if (parentRNode !== null) {\n      addViewToDOM(tView, lContainer[T_HOST], renderer, lView, parentRNode, beforeNode);\n    }\n  }\n}\n\nexport function removeLViewFromLContainer(lContainer: LContainer, index: number): LView<unknown>|\n    undefined {\n  const lView = detachView(lContainer, index);\n  if (lView !== undefined) {\n    destroyLView(lView[TVIEW], lView);\n  }\n  return lView;\n}\n"]}

package/esm2022/src/signals/index.mjs

@@ -5,12 +5,12 @@
  * 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 { createSignalFromFunction, defaultEquals, isSignal } from './src/api';
+export { defaultEquals, isSignal, SIGNAL } from './src/api';
 export { computed } from './src/computed';
 export { setThrowInvalidWriteToSignalError } from './src/errors';
-export { ReactiveNode, setActiveConsumer } from './src/graph';
+export { consumerAfterComputation, consumerBeforeComputation, consumerDestroy, isInNotificationPhase, producerAccessed, producerNotifyConsumers, producerUpdatesAllowed, producerUpdateValueVersion, REACTIVE_NODE, setActiveConsumer } from './src/graph';
 export { setPostSignalSetFn, signal } from './src/signal';
 export { untracked } from './src/untracked';
-export { Watch } from './src/watch';
+export { watch } from './src/watch';
 export { setAlternateWeakRefImpl } from './src/weak_ref';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9zaWduYWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyx3QkFBd0IsRUFBRSxhQUFhLEVBQUUsUUFBUSxFQUEwQixNQUFNLFdBQVcsQ0FBQztBQUNyRyxPQUFPLEVBQUMsUUFBUSxFQUF3QixNQUFNLGdCQUFnQixDQUFDO0FBQy9ELE9BQU8sRUFBQyxpQ0FBaUMsRUFBQyxNQUFNLGNBQWMsQ0FBQztBQUMvRCxPQUFPLEVBQUMsWUFBWSxFQUFFLGlCQUFpQixFQUFDLE1BQU0sYUFBYSxDQUFDO0FBQzVELE9BQU8sRUFBc0Isa0JBQWtCLEVBQUUsTUFBTSxFQUFpQixNQUFNLGNBQWMsQ0FBQztBQUM3RixPQUFPLEVBQUMsU0FBUyxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxFQUFDLEtBQUssRUFBaUIsTUFBTSxhQUFhLENBQUM7QUFDbEQsT0FBTyxFQUFDLHVCQUF1QixFQUFDLE1BQU0sZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHtjcmVhdGVTaWduYWxGcm9tRnVuY3Rpb24sIGRlZmF1bHRFcXVhbHMsIGlzU2lnbmFsLCBTaWduYWwsIFZhbHVlRXF1YWxpdHlGbn0gZnJvbSAnLi9zcmMvYXBpJztcbmV4cG9ydCB7Y29tcHV0ZWQsIENyZWF0ZUNvbXB1dGVkT3B0aW9uc30gZnJvbSAnLi9zcmMvY29tcHV0ZWQnO1xuZXhwb3J0IHtzZXRUaHJvd0ludmFsaWRXcml0ZVRvU2lnbmFsRXJyb3J9IGZyb20gJy4vc3JjL2Vycm9ycyc7XG5leHBvcnQge1JlYWN0aXZlTm9kZSwgc2V0QWN0aXZlQ29uc3VtZXJ9IGZyb20gJy4vc3JjL2dyYXBoJztcbmV4cG9ydCB7Q3JlYXRlU2lnbmFsT3B0aW9ucywgc2V0UG9zdFNpZ25hbFNldEZuLCBzaWduYWwsIFdyaXRhYmxlU2lnbmFsfSBmcm9tICcuL3NyYy9zaWduYWwnO1xuZXhwb3J0IHt1bnRyYWNrZWR9IGZyb20gJy4vc3JjL3VudHJhY2tlZCc7XG5leHBvcnQge1dhdGNoLCBXYXRjaENsZWFudXBGbn0gZnJvbSAnLi9zcmMvd2F0Y2gnO1xuZXhwb3J0IHtzZXRBbHRlcm5hdGVXZWFrUmVmSW1wbH0gZnJvbSAnLi9zcmMvd2Vha19yZWYnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/signals/src/api.mjs

@@ -10,7 +10,7 @@
  *
  * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
  */
-const SIGNAL = Symbol('SIGNAL');
+export const SIGNAL = Symbol('SIGNAL');
 /**
  * Checks if the given `value` is a reactive `Signal`.
  *
@@ -19,15 +19,6 @@ const SIGNAL = Symbol('SIGNAL');
 export function isSignal(value) {
     return typeof value === 'function' && value[SIGNAL] !== undefined;
 }
-/**
- * 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(node, fn, extraApi = {}) {
-    fn[SIGNAL] = node;
-    // 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.
@@ -45,4 +36,4 @@ export function defaultEquals(a, b) {
     // as objects (`typeof null === 'object'`).
     return (a === null || typeof a !== 'object') && Object.is(a, b);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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