@angular/core 17.0.0-next.3 → 17.0.0-next.5

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

@@ -6,66 +6,154 @@
  * 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';
 /**
- * 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 w = watch(effectFn, (watch) => {
-            if (!this.all.has(watch)) {
-                return;
-            }
-            this.queue.set(watch, zone);
-        }, allowSignalWrites);
-        this.all.add(w);
-        // Effects start dirty.
-        w.notify();
-        let unregisterOnDestroy;
-        const destroy = () => {
-            w.cleanup();
-            unregisterOnDestroy?.();
-            this.all.delete(w);
-            this.queue.delete(w);
-        };
-        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.watcher =
+            watch((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);
+    }
+    notify() {
+        this.watcher.notify();
+    }
+    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.
  *
@@ -74,8 +162,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, 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 w = 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(w);\n\n    // Effects start dirty.\n    w.notify();\n\n    let unregisterOnDestroy: (() => void)|undefined;\n\n    const destroy = () => {\n      w.cleanup();\n      unregisterOnDestroy?.();\n      this.all.delete(w);\n      this.queue.delete(w);\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 {watch, Watch, 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  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    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  notify(): void {\n    this.watcher.notify();\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  !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/scope.mjs

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { isForwardRef, resolveForwardRef } from '../di/forward_ref';
+import { flatten } from '../util/array_utils';
 import { noSideEffects } from '../util/closure';
 import { EMPTY_ARRAY } from '../util/empty';
 import { extractDefListOrFactory, getNgModuleDef } from './definition';
@@ -41,6 +42,10 @@ export function ɵɵsetNgModuleScope(type, scope) {
         ngModuleDef.declarations = convertToTypeArray(scope.declarations || EMPTY_ARRAY);
         ngModuleDef.imports = convertToTypeArray(scope.imports || EMPTY_ARRAY);
         ngModuleDef.exports = convertToTypeArray(scope.exports || EMPTY_ARRAY);
+        if (scope.bootstrap) {
+            // This only happens in local compilation mode.
+            ngModuleDef.bootstrap = convertToTypeArray(scope.bootstrap);
+        }
         depsTracker.registerNgModule(type, scope);
     });
 }
@@ -48,14 +53,15 @@ function convertToTypeArray(values) {
     if (typeof values === 'function') {
         return values;
     }
-    if (values.some(isForwardRef)) {
-        return () => values.map(resolveForwardRef).map(maybeUnwrapModuleWithProviders);
+    const flattenValues = flatten(values);
+    if (flattenValues.some(isForwardRef)) {
+        return () => flattenValues.map(resolveForwardRef).map(maybeUnwrapModuleWithProviders);
     }
     else {
-        return values.map(maybeUnwrapModuleWithProviders);
+        return flattenValues.map(maybeUnwrapModuleWithProviders);
     }
 }
 function maybeUnwrapModuleWithProviders(value) {
     return isModuleWithProviders(value) ? value.ngModule : value;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/signals/index.mjs

@@ -8,9 +8,9 @@
 export { defaultEquals, isSignal, SIGNAL } from './src/api';
 export { computed } from './src/computed';
 export { setThrowInvalidWriteToSignalError } from './src/errors';
-export { consumerAfterComputation, consumerBeforeComputation, consumerDestroy, producerAccessed, producerNotifyConsumers, producerUpdatesAllowed, producerUpdateValueVersion, REACTIVE_NODE, 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 { setAlternateWeakRefImpl } from './src/weak_ref';
-//# sourceMappingURL=data:application/json;base64,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
+//# 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.
  */
-export const SIGNAL = Symbol('SIGNAL');
+export const SIGNAL = /* @__PURE__ */ Symbol('SIGNAL');
 /**
  * Checks if the given `value` is a reactive `Signal`.
  *
@@ -36,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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvc2lnbmFscy9zcmMvYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsZUFBZSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztBQWdCdkQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxRQUFRLENBQUMsS0FBYztJQUNyQyxPQUFPLE9BQU8sS0FBSyxLQUFLLFVBQVUsSUFBSyxLQUF5QixDQUFDLE1BQU0sQ0FBQyxLQUFLLFNBQVMsQ0FBQztBQUN6RixDQUFDO0FBU0Q7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLFVBQVUsYUFBYSxDQUFJLENBQUksRUFBRSxDQUFJO0lBQ3pDLHlGQUF5RjtJQUN6RiwrRkFBK0Y7SUFDL0YsMkZBQTJGO0lBQzNGLGdHQUFnRztJQUNoRywyQ0FBMkM7SUFDM0MsT0FBTyxDQUFDLENBQUMsS0FBSyxJQUFJLElBQUksT0FBTyxDQUFDLEtBQUssUUFBUSxDQUFDLElBQUksTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFDbEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vKipcbiAqIFN5bWJvbCB1c2VkIHRvIHRlbGwgYFNpZ25hbGBzIGFwYXJ0IGZyb20gb3RoZXIgZnVuY3Rpb25zLlxuICpcbiAqIFRoaXMgY2FuIGJlIHVzZWQgdG8gYXV0by11bndyYXAgc2lnbmFscyBpbiB2YXJpb3VzIGNhc2VzLCBvciB0byBhdXRvLXdyYXAgbm9uLXNpZ25hbCB2YWx1ZXMuXG4gKi9cbmV4cG9ydCBjb25zdCBTSUdOQUwgPSAvKiBAX19QVVJFX18gKi8gU3ltYm9sKCdTSUdOQUwnKTtcblxuLyoqXG4gKiBBIHJlYWN0aXZlIHZhbHVlIHdoaWNoIG5vdGlmaWVzIGNvbnN1bWVycyBvZiBhbnkgY2hhbmdlcy5cbiAqXG4gKiBTaWduYWxzIGFyZSBmdW5jdGlvbnMgd2hpY2ggcmV0dXJucyB0aGVpciBjdXJyZW50IHZhbHVlLiBUbyBhY2Nlc3MgdGhlIGN1cnJlbnQgdmFsdWUgb2YgYSBzaWduYWwsXG4gKiBjYWxsIGl0LlxuICpcbiAqIE9yZGluYXJ5IHZhbHVlcyBjYW4gYmUgdHVybmVkIGludG8gYFNpZ25hbGBzIHdpdGggdGhlIGBzaWduYWxgIGZ1bmN0aW9uLlxuICpcbiAqIEBkZXZlbG9wZXJQcmV2aWV3XG4gKi9cbmV4cG9ydCB0eXBlIFNpZ25hbDxUPiA9ICgoKSA9PiBUKSZ7XG4gIFtTSUdOQUxdOiB1bmtub3duO1xufTtcblxuLyoqXG4gKiBDaGVja3MgaWYgdGhlIGdpdmVuIGB2YWx1ZWAgaXMgYSByZWFjdGl2ZSBgU2lnbmFsYC5cbiAqXG4gKiBAZGV2ZWxvcGVyUHJldmlld1xuICovXG5leHBvcnQgZnVuY3Rpb24gaXNTaWduYWwodmFsdWU6IHVua25vd24pOiB2YWx1ZSBpcyBTaWduYWw8dW5rbm93bj4ge1xuICByZXR1cm4gdHlwZW9mIHZhbHVlID09PSAnZnVuY3Rpb24nICYmICh2YWx1ZSBhcyBTaWduYWw8dW5rbm93bj4pW1NJR05BTF0gIT09IHVuZGVmaW5lZDtcbn1cblxuLyoqXG4gKiBBIGNvbXBhcmlzb24gZnVuY3Rpb24gd2hpY2ggY2FuIGRldGVybWluZSBpZiB0d28gdmFsdWVzIGFyZSBlcXVhbC5cbiAqXG4gKiBAZGV2ZWxvcGVyUHJldmlld1xuICovXG5leHBvcnQgdHlwZSBWYWx1ZUVxdWFsaXR5Rm48VD4gPSAoYTogVCwgYjogVCkgPT4gYm9vbGVhbjtcblxuLyoqXG4gKiBUaGUgZGVmYXVsdCBlcXVhbGl0eSBmdW5jdGlvbiB1c2VkIGZvciBgc2lnbmFsYCBhbmQgYGNvbXB1dGVkYCwgd2hpY2ggdHJlYXRzIG9iamVjdHMgYW5kIGFycmF5c1xuICogYXMgbmV2ZXIgZXF1YWwsIGFuZCBhbGwgb3RoZXIgcHJpbWl0aXZlIHZhbHVlcyB1c2luZyBpZGVudGl0eSBzZW1hbnRpY3MuXG4gKlxuICogVGhpcyBhbGxvd3Mgc2lnbmFscyB0byBob2xkIG5vbi1wcmltaXRpdmUgdmFsdWVzIChhcnJheXMsIG9iamVjdHMsIG90aGVyIGNvbGxlY3Rpb25zKSBhbmQgc3RpbGxcbiAqIHByb3BhZ2F0ZSBjaGFuZ2Ugbm90aWZpY2F0aW9uIHVwb24gZXhwbGljaXQgbXV0YXRpb24gd2l0aG91dCBpZGVudGl0eSBjaGFuZ2UuXG4gKlxuICogQGRldmVsb3BlclByZXZpZXdcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGRlZmF1bHRFcXVhbHM8VD4oYTogVCwgYjogVCkge1xuICAvLyBgT2JqZWN0LmlzYCBjb21wYXJlcyB0d28gdmFsdWVzIHVzaW5nIGlkZW50aXR5IHNlbWFudGljcyB3aGljaCBpcyBkZXNpcmVkIGJlaGF2aW9yIGZvclxuICAvLyBwcmltaXRpdmUgdmFsdWVzLiBJZiBgT2JqZWN0LmlzYCBkZXRlcm1pbmVzIHR3byB2YWx1ZXMgdG8gYmUgZXF1YWwgd2UgbmVlZCB0byBtYWtlIHN1cmUgdGhhdFxuICAvLyB0aG9zZSBkb24ndCByZXByZXNlbnQgb2JqZWN0cyAod2Ugd2FudCB0byBtYWtlIHN1cmUgdGhhdCAyIG9iamVjdHMgYXJlIGFsd2F5cyBjb25zaWRlcmVkXG4gIC8vIFwidW5lcXVhbFwiKS4gVGhlIG51bGwgY2hlY2sgaXMgbmVlZGVkIGZvciB0aGUgc3BlY2lhbCBjYXNlIG9mIEphdmFTY3JpcHQgcmVwb3J0aW5nIG51bGwgdmFsdWVzXG4gIC8vIGFzIG9iamVjdHMgKGB0eXBlb2YgbnVsbCA9PT0gJ29iamVjdCdgKS5cbiAgcmV0dXJuIChhID09PSBudWxsIHx8IHR5cGVvZiBhICE9PSAnb2JqZWN0JykgJiYgT2JqZWN0LmlzKGEsIGIpO1xufVxuIl19

package/esm2022/src/signals/src/computed.mjs

@@ -33,58 +33,63 @@ export function computed(computation, options) {
  * 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');
+const UNSET = /* @__PURE__ */ 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');
+const COMPUTING = /* @__PURE__ */ 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');
-const COMPUTED_NODE = {
-    ...REACTIVE_NODE,
-    value: UNSET,
-    dirty: true,
-    error: null,
-    equal: defaultEquals,
-    producerMustRecompute(node) {
-        // Force a recomputation if there's no current value, or if the current value is in the process
-        // of being calculated (which should throw an error).
-        return node.value === UNSET || node.value === COMPUTING;
-    },
-    producerRecomputeValue(node) {
-        if (node.value === COMPUTING) {
-            // Our computation somehow led to a cyclic read of itself.
-            throw new Error('Detected cycle in computations.');
-        }
-        const oldValue = node.value;
-        node.value = COMPUTING;
-        const prevConsumer = consumerBeforeComputation(node);
-        let newValue;
-        try {
-            newValue = node.computation();
-        }
-        catch (err) {
-            newValue = ERRORED;
-            node.error = err;
-        }
-        finally {
-            consumerAfterComputation(node, prevConsumer);
-        }
-        if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
-            node.equal(oldValue, newValue)) {
-            // No change to `valueVersion` - old and new values are
-            // semantically equivalent.
-            node.value = oldValue;
-            return;
-        }
-        node.value = newValue;
-        node.version++;
-    },
-};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computed.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/signals/src/computed.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,aAAa,EAAE,MAAM,EAA0B,MAAM,OAAO,CAAC;AACrE,OAAO,EAAC,wBAAwB,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,aAAa,EAAe,MAAM,SAAS,CAAC;AAcvJ;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAI,WAAoB,EAAE,OAAkC;IAClF,MAAM,IAAI,GAAoB,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IAC3D,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IAC/B,OAAO,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAE/C,MAAM,QAAQ,GAAG,GAAG,EAAE;QACpB,yDAAyD;QACzD,0BAA0B,CAAC,IAAI,CAAC,CAAC;QAEjC,6CAA6C;QAC7C,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAEvB,IAAI,IAAI,CAAC,KAAK,KAAK,OAAO,EAAE;YAC1B,MAAM,IAAI,CAAC,KAAK,CAAC;SAClB;QAED,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC,CAAC;IACD,QAAgB,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IACjC,OAAO,QAA4B,CAAC;AACtC,CAAC;AAGD;;;GAGG;AACH,MAAM,KAAK,GAAQ,MAAM,CAAC,OAAO,CAAC,CAAC;AAEnC;;;;GAIG;AACH,MAAM,SAAS,GAAQ,MAAM,CAAC,WAAW,CAAC,CAAC;AAE3C;;;;GAIG;AACH,MAAM,OAAO,GAAQ,MAAM,CAAC,SAAS,CAAC,CAAC;AA4BvC,MAAM,aAAa,GAAG;IACpB,GAAG,aAAa;IAChB,KAAK,EAAE,KAAK;IACZ,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,aAAa;IAEpB,qBAAqB,CAAC,IAA2B;QAC/C,+FAA+F;QAC/F,qDAAqD;QACrD,OAAO,IAAI,CAAC,KAAK,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,CAAC;IAC1D,CAAC;IAED,sBAAsB,CAAC,IAA2B;QAChD,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE;YAC5B,0DAA0D;YAC1D,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;SACpD;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;QAEvB,MAAM,YAAY,GAAG,yBAAyB,CAAC,IAAI,CAAC,CAAC;QACrD,IAAI,QAAiB,CAAC;QACtB,IAAI;YACF,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;SAC/B;QAAC,OAAO,GAAG,EAAE;YACZ,QAAQ,GAAG,OAAO,CAAC;YACnB,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC;SAClB;gBAAS;YACR,wBAAwB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;SAC9C;QAED,IAAI,QAAQ,KAAK,KAAK,IAAI,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,OAAO;YAClE,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE;YAClC,uDAAuD;YACvD,2BAA2B;YAC3B,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;YACtB,OAAO;SACR;QAED,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;QACtB,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;CACF,CAAC","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 {defaultEquals, SIGNAL, Signal, ValueEqualityFn} from './api';\nimport {consumerAfterComputation, consumerBeforeComputation, producerAccessed, producerUpdateValueVersion, REACTIVE_NODE, ReactiveNode} from './graph';\n\n/**\n * Options passed to the `computed` creation function.\n *\n * @developerPreview\n */\nexport interface CreateComputedOptions<T> {\n  /**\n   * A comparison function which defines equality for computed values.\n   */\n  equal?: ValueEqualityFn<T>;\n}\n\n/**\n * Create a computed `Signal` which derives a reactive value from an expression.\n *\n * @developerPreview\n */\nexport function computed<T>(computation: () => T, options?: CreateComputedOptions<T>): Signal<T> {\n  const node: ComputedNode<T> = Object.create(COMPUTED_NODE);\n  node.computation = computation;\n  options?.equal && (node.equal = options.equal);\n\n  const computed = () => {\n    // Check if the value needs updating before returning it.\n    producerUpdateValueVersion(node);\n\n    // Record that someone looked at this signal.\n    producerAccessed(node);\n\n    if (node.value === ERRORED) {\n      throw node.error;\n    }\n\n    return node.value;\n  };\n  (computed as any)[SIGNAL] = node;\n  return computed as any as Signal<T>;\n}\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 producers and consumers of reactivity.\n */\ninterface ComputedNode<T> extends ReactiveNode {\n  /**\n   * Current value of the computation, or one of the sentinel values above (`UNSET`, `COMPUTING`,\n   * `ERROR`).\n   */\n  value: T;\n\n  /**\n   * If `value` is `ERRORED`, the error caught from the last computation attempt which will\n   * be re-thrown.\n   */\n  error: unknown;\n\n  /**\n   * The computation function which will produce a new value.\n   */\n  computation: () => T;\n\n  equal: ValueEqualityFn<T>;\n}\n\nconst COMPUTED_NODE = {\n  ...REACTIVE_NODE,\n  value: UNSET,\n  dirty: true,\n  error: null,\n  equal: defaultEquals,\n\n  producerMustRecompute(node: ComputedNode<unknown>): boolean {\n    // Force a recomputation if there's no current value, or if the current value is in the process\n    // of being calculated (which should throw an error).\n    return node.value === UNSET || node.value === COMPUTING;\n  },\n\n  producerRecomputeValue(node: ComputedNode<unknown>): void {\n    if (node.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 = node.value;\n    node.value = COMPUTING;\n\n    const prevConsumer = consumerBeforeComputation(node);\n    let newValue: unknown;\n    try {\n      newValue = node.computation();\n    } catch (err) {\n      newValue = ERRORED;\n      node.error = err;\n    } finally {\n      consumerAfterComputation(node, prevConsumer);\n    }\n\n    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&\n        node.equal(oldValue, newValue)) {\n      // No change to `valueVersion` - old and new values are\n      // semantically equivalent.\n      node.value = oldValue;\n      return;\n    }\n\n    node.value = newValue;\n    node.version++;\n  },\n};\n"]}
+const ERRORED = /* @__PURE__ */ Symbol('ERRORED');
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const COMPUTED_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        value: UNSET,
+        dirty: true,
+        error: null,
+        equal: defaultEquals,
+        producerMustRecompute(node) {
+            // Force a recomputation if there's no current value, or if the current value is in the
+            // process of being calculated (which should throw an error).
+            return node.value === UNSET || node.value === COMPUTING;
+        },
+        producerRecomputeValue(node) {
+            if (node.value === COMPUTING) {
+                // Our computation somehow led to a cyclic read of itself.
+                throw new Error('Detected cycle in computations.');
+            }
+            const oldValue = node.value;
+            node.value = COMPUTING;
+            const prevConsumer = consumerBeforeComputation(node);
+            let newValue;
+            try {
+                newValue = node.computation();
+            }
+            catch (err) {
+                newValue = ERRORED;
+                node.error = err;
+            }
+            finally {
+                consumerAfterComputation(node, prevConsumer);
+            }
+            if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+                node.equal(oldValue, newValue)) {
+                // No change to `valueVersion` - old and new values are
+                // semantically equivalent.
+                node.value = oldValue;
+                return;
+            }
+            node.value = newValue;
+            node.version++;
+        },
+    };
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computed.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/signals/src/computed.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,aAAa,EAAE,MAAM,EAA0B,MAAM,OAAO,CAAC;AACrE,OAAO,EAAC,wBAAwB,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,aAAa,EAAe,MAAM,SAAS,CAAC;AAcvJ;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAI,WAAoB,EAAE,OAAkC;IAClF,MAAM,IAAI,GAAoB,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IAC3D,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IAC/B,OAAO,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAE/C,MAAM,QAAQ,GAAG,GAAG,EAAE;QACpB,yDAAyD;QACzD,0BAA0B,CAAC,IAAI,CAAC,CAAC;QAEjC,6CAA6C;QAC7C,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAEvB,IAAI,IAAI,CAAC,KAAK,KAAK,OAAO,EAAE;YAC1B,MAAM,IAAI,CAAC,KAAK,CAAC;SAClB;QAED,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC,CAAC;IACD,QAAgB,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IACjC,OAAO,QAA4B,CAAC;AACtC,CAAC;AAGD;;;GAGG;AACH,MAAM,KAAK,GAAQ,eAAe,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAEnD;;;;GAIG;AACH,MAAM,SAAS,GAAQ,eAAe,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;AAE3D;;;;GAIG;AACH,MAAM,OAAO,GAAQ,eAAe,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AA4BvD,kFAAkF;AAClF,2EAA2E;AAC3E,8EAA8E;AAC9E,MAAM,aAAa,GAAG,eAAe,CAAC,CAAC,GAAG,EAAE;IAC1C,OAAO;QACL,GAAG,aAAa;QAChB,KAAK,EAAE,KAAK;QACZ,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,aAAa;QAEpB,qBAAqB,CAAC,IAA2B;YAC/C,uFAAuF;YACvF,6DAA6D;YAC7D,OAAO,IAAI,CAAC,KAAK,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,CAAC;QAC1D,CAAC;QAED,sBAAsB,CAAC,IAA2B;YAChD,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE;gBAC5B,0DAA0D;gBAC1D,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;aACpD;YAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC;YAC5B,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;YAEvB,MAAM,YAAY,GAAG,yBAAyB,CAAC,IAAI,CAAC,CAAC;YACrD,IAAI,QAAiB,CAAC;YACtB,IAAI;gBACF,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;aAC/B;YAAC,OAAO,GAAG,EAAE;gBACZ,QAAQ,GAAG,OAAO,CAAC;gBACnB,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC;aAClB;oBAAS;gBACR,wBAAwB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;aAC9C;YAED,IAAI,QAAQ,KAAK,KAAK,IAAI,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,OAAO;gBAClE,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE;gBAClC,uDAAuD;gBACvD,2BAA2B;gBAC3B,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;gBACtB,OAAO;aACR;YAED,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;YACtB,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC,CAAC,EAAE,CAAC","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 {defaultEquals, SIGNAL, Signal, ValueEqualityFn} from './api';\nimport {consumerAfterComputation, consumerBeforeComputation, producerAccessed, producerUpdateValueVersion, REACTIVE_NODE, ReactiveNode} from './graph';\n\n/**\n * Options passed to the `computed` creation function.\n *\n * @developerPreview\n */\nexport interface CreateComputedOptions<T> {\n  /**\n   * A comparison function which defines equality for computed values.\n   */\n  equal?: ValueEqualityFn<T>;\n}\n\n/**\n * Create a computed `Signal` which derives a reactive value from an expression.\n *\n * @developerPreview\n */\nexport function computed<T>(computation: () => T, options?: CreateComputedOptions<T>): Signal<T> {\n  const node: ComputedNode<T> = Object.create(COMPUTED_NODE);\n  node.computation = computation;\n  options?.equal && (node.equal = options.equal);\n\n  const computed = () => {\n    // Check if the value needs updating before returning it.\n    producerUpdateValueVersion(node);\n\n    // Record that someone looked at this signal.\n    producerAccessed(node);\n\n    if (node.value === ERRORED) {\n      throw node.error;\n    }\n\n    return node.value;\n  };\n  (computed as any)[SIGNAL] = node;\n  return computed as any as Signal<T>;\n}\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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ Symbol('ERRORED');\n\n/**\n * A computation, which derives a value from a declarative reactive expression.\n *\n * `Computed`s are both producers and consumers of reactivity.\n */\ninterface ComputedNode<T> extends ReactiveNode {\n  /**\n   * Current value of the computation, or one of the sentinel values above (`UNSET`, `COMPUTING`,\n   * `ERROR`).\n   */\n  value: T;\n\n  /**\n   * If `value` is `ERRORED`, the error caught from the last computation attempt which will\n   * be re-thrown.\n   */\n  error: unknown;\n\n  /**\n   * The computation function which will produce a new value.\n   */\n  computation: () => T;\n\n  equal: ValueEqualityFn<T>;\n}\n\n// Note: Using an IIFE here to ensure that the spread assignment is not considered\n// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.\n// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.\nconst COMPUTED_NODE = /* @__PURE__ */ (() => {\n  return {\n    ...REACTIVE_NODE,\n    value: UNSET,\n    dirty: true,\n    error: null,\n    equal: defaultEquals,\n\n    producerMustRecompute(node: ComputedNode<unknown>): boolean {\n      // Force a recomputation if there's no current value, or if the current value is in the\n      // process of being calculated (which should throw an error).\n      return node.value === UNSET || node.value === COMPUTING;\n    },\n\n    producerRecomputeValue(node: ComputedNode<unknown>): void {\n      if (node.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 = node.value;\n      node.value = COMPUTING;\n\n      const prevConsumer = consumerBeforeComputation(node);\n      let newValue: unknown;\n      try {\n        newValue = node.computation();\n      } catch (err) {\n        newValue = ERRORED;\n        node.error = err;\n      } finally {\n        consumerAfterComputation(node, prevConsumer);\n      }\n\n      if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&\n          node.equal(oldValue, newValue)) {\n        // No change to `valueVersion` - old and new values are\n        // semantically equivalent.\n        node.value = oldValue;\n        return;\n      }\n\n      node.value = newValue;\n      node.version++;\n    },\n  };\n})();\n"]}