@angular/core
Version:
Angular - the core framework
191 lines • 27.3 kB
JavaScript
/**
* @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 { createWatch } from '@angular/core/primitives/signals';
import { ChangeDetectorRef } from '../../change_detection';
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 { FLAGS, EFFECTS_TO_SCHEDULE } from '../interfaces/view';
import { assertNotInReactiveContext } from './asserts';
/**
* Not public API, which guarantees `EffectScheduler` only ever comes from the application root
* injector.
*/
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.queuedEffectCount = 0;
this.queues = new Map();
}
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;
}
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));
}
}
}
}
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: ZoneAwareQueueingScheduler,
providedIn: 'root',
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.watcher = createWatch((onCleanup) => this.runEffect(onCleanup), () => this.schedule(), allowSignalWrites);
this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());
}
runEffect(onCleanup) {
try {
this.effectFn(onCleanup);
}
catch (err) {
this.errorHandler?.handleError(err);
}
}
run() {
this.watcher.run();
}
schedule() {
this.scheduler.scheduleEffect(this);
}
destroy() {
this.watcher.destroy();
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.
*
* @developerPreview
*/
export function effect(effectFn, options) {
ngDevMode &&
assertNotInReactiveContext(effect, 'Call `effect` outside of a reactive context. For example, schedule the ' +
'effect inside the component constructor.');
!options?.injector && assertInInjectionContext(effect);
const injector = options?.injector ?? inject(Injector);
const errorHandler = injector.get(ErrorHandler, null, { optional: true });
const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
const handle = new EffectHandle(injector.get(APP_EFFECT_SCHEDULER), effectFn, (typeof Zone === 'undefined') ? null : Zone.current, destroyRef, errorHandler, options?.allowSignalWrites ?? false);
// Effects need to be marked dirty manually to trigger their initial run. The timing of this
// marking matters, because the effects may read signals that track component inputs, which are
// only available after those components have had their first update pass.
//
// We inject `ChangeDetectorRef` optionally, to determine whether this effect is being created in
// the context of a component or not. If it is, then we check whether the component has already
// run its update pass, and defer the effect's initial scheduling until the update pass if it
// hasn't already run.
const cdr = injector.get(ChangeDetectorRef, null, { optional: true });
if (!cdr || !(cdr._lView[FLAGS] & 8 /* LViewFlags.FirstLViewPass */)) {
// This effect is either not running in a view injector, or the view has already
// undergone its first change detection pass, which is necessary for any required inputs to be
// set.
handle.watcher.notify();
}
else {
// Delay the initialization of the effect until the view is fully initialized.
(cdr._lView[EFFECTS_TO_SCHEDULE] ??= []).push(handle.watcher.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 {createWatch, Watch, WatchCleanupRegisterFn} from '@angular/core/primitives/signals';\n\nimport {ChangeDetectorRef} from '../../change_detection';\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 type {ViewRef} from '../view_ref';\nimport {DestroyRef} from '../../linker/destroy_ref';\nimport {FLAGS, LViewFlags, EFFECTS_TO_SCHEDULE} from '../interfaces/view';\n\nimport {assertNotInReactiveContext} from './asserts';\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 *\n * @developerPreview\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  unregisterOnDestroy: (() => void)|undefined;\n  readonly 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 = createWatch(\n        (onCleanup) => this.runEffect(onCleanup), () => this.schedule(), allowSignalWrites);\n    this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());\n  }\n\n  private runEffect(onCleanup: WatchCleanupRegisterFn): void {\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    this.scheduler.scheduleEffect(this);\n  }\n\n  destroy(): void {\n    this.watcher.destroy();\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  ngDevMode &&\n      assertNotInReactiveContext(\n          effect,\n          'Call `effect` outside of a reactive context. For example, schedule the ' +\n              'effect inside the component constructor.');\n\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 need to be marked dirty manually to trigger their initial run. The timing of this\n  // marking matters, because the effects may read signals that track component inputs, which are\n  // only available after those components have had their first update pass.\n  //\n  // We inject `ChangeDetectorRef` optionally, to determine whether this effect is being created in\n  // the context of a component or not. If it is, then we check whether the component has already\n  // run its update pass, and defer the effect's initial scheduling until the update pass if it\n  // hasn't already run.\n  const cdr = injector.get(ChangeDetectorRef, null, {optional: true}) as ViewRef<unknown>| null;\n  if (!cdr || !(cdr._lView[FLAGS] & LViewFlags.FirstLViewPass)) {\n    // This effect is either not running in a view injector, or the view has already\n    // undergone its first change detection pass, which is necessary for any required inputs to be\n    // set.\n    handle.watcher.notify();\n  } else {\n    // Delay the initialization of the effect until the view is fully initialized.\n    (cdr._lView[EFFECTS_TO_SCHEDULE] ??= []).push(handle.watcher.notify);\n  }\n\n  return handle;\n}\n"]}