@angular/core 16.0.0-next.5 → 16.0.0-next.7

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

@@ -8,11 +8,60 @@
 import { assertInInjectionContext } from '../../di/contextual';
 import { Injector } from '../../di/injector';
 import { inject } from '../../di/injector_compatibility';
+import { ɵɵdefineInjectable } from '../../di/interface/defs';
 import { DestroyRef } from '../../linker/destroy_ref';
 import { Watch } from '../../signals';
-const globalWatches = new Set();
-const queuedWatches = new Map();
-let watchQueuePromise = null;
+/**
+ * Tracks all effects registered within a given application and runs them via `flush`.
+ */
+class EffectManager {
+    constructor() {
+        this.all = new Set();
+        this.queue = new Map();
+    }
+    create(effectFn, destroyRef, allowSignalWrites) {
+        const zone = 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,
+        };
+    }
+    flush() {
+        if (this.queue.size === 0) {
+            return;
+        }
+        for (const [watch, zone] of this.queue) {
+            this.queue.delete(watch);
+            zone.run(() => watch.run());
+        }
+    }
+    get isQueueEmpty() {
+        return this.queue.size === 0;
+    }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: EffectManager,
+        providedIn: 'root',
+        factory: () => new EffectManager(),
+    }); }
+}
+export { EffectManager };
 /**
  * Create a global `Effect` for the given reactive function.
  *
@@ -20,48 +69,9 @@ let watchQueuePromise = null;
  */
 export function effect(effectFn, options) {
     !options?.injector && assertInInjectionContext(effect);
-    const zone = Zone.current;
-    const watch = new Watch(effectFn, (watch) => queueWatch(watch, zone));
     const injector = options?.injector ?? inject(Injector);
+    const effectManager = injector.get(EffectManager);
     const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
-    globalWatches.add(watch);
-    // Effects start dirty.
-    watch.notify();
-    let unregisterOnDestroy;
-    const destroy = () => {
-        watch.cleanup();
-        unregisterOnDestroy?.();
-        queuedWatches.delete(watch);
-        globalWatches.delete(watch);
-    };
-    unregisterOnDestroy = destroyRef?.onDestroy(destroy);
-    return {
-        destroy,
-    };
-}
-function queueWatch(watch, zone) {
-    if (queuedWatches.has(watch) || !globalWatches.has(watch)) {
-        return;
-    }
-    queuedWatches.set(watch, zone);
-    if (watchQueuePromise === null) {
-        Promise.resolve().then(runWatchQueue);
-        let resolveFn;
-        const promise = new Promise((resolve) => {
-            resolveFn = resolve;
-        });
-        watchQueuePromise = {
-            promise,
-            resolveFn,
-        };
-    }
-}
-function runWatchQueue() {
-    for (const [watch, zone] of queuedWatches) {
-        queuedWatches.delete(watch);
-        zone.run(() => watch.run());
-    }
-    watchQueuePromise.resolveFn();
-    watchQueuePromise = null;
+    return effectManager.create(effectFn, destroyRef, !!options?.allowSignalWrites);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWZmZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvcmVuZGVyMy9yZWFjdGl2aXR5L2VmZmVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsd0JBQXdCLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUM3RCxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sbUJBQW1CLENBQUM7QUFDM0MsT0FBTyxFQUFDLE1BQU0sRUFBQyxNQUFNLGlDQUFpQyxDQUFDO0FBQ3ZELE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSwwQkFBMEIsQ0FBQztBQUNwRCxPQUFPLEVBQUMsS0FBSyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBV3BDLE1BQU0sYUFBYSxHQUFHLElBQUksR0FBRyxFQUFTLENBQUM7QUFDdkMsTUFBTSxhQUFhLEdBQUcsSUFBSSxHQUFHLEVBQWUsQ0FBQztBQUU3QyxJQUFJLGlCQUFpQixHQUEwRCxJQUFJLENBQUM7QUFvQ3BGOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsTUFBTSxDQUNsQixRQUFzQyxFQUFFLE9BQTZCO0lBQ3ZFLENBQUMsT0FBTyxFQUFFLFFBQVEsSUFBSSx3QkFBd0IsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUV2RCxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQzFCLE1BQU0sS0FBSyxHQUFHLElBQUksS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBRXRFLE1BQU0sUUFBUSxHQUFHLE9BQU8sRUFBRSxRQUFRLElBQUksTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3ZELE1BQU0sVUFBVSxHQUFHLE9BQU8sRUFBRSxhQUFhLEtBQUssSUFBSSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7SUFFckYsYUFBYSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUV6Qix1QkFBdUI7SUFDdkIsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBRWYsSUFBSSxtQkFBMkMsQ0FBQztJQUVoRCxNQUFNLE9BQU8sR0FBRyxHQUFHLEVBQUU7UUFDbkIsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2hCLG1CQUFtQixFQUFFLEVBQUUsQ0FBQztRQUN4QixhQUFhLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzVCLGFBQWEsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDOUIsQ0FBQyxDQUFDO0lBRUYsbUJBQW1CLEdBQUcsVUFBVSxFQUFFLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUVyRCxPQUFPO1FBQ0wsT0FBTztLQUNSLENBQUM7QUFDSixDQUFDO0FBRUQsU0FBUyxVQUFVLENBQUMsS0FBWSxFQUFFLElBQVU7SUFDMUMsSUFBSSxhQUFhLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsRUFBRTtRQUN6RCxPQUFPO0tBQ1I7SUFFRCxhQUFhLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztJQUUvQixJQUFJLGlCQUFpQixLQUFLLElBQUksRUFBRTtRQUM5QixPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBRXRDLElBQUksU0FBc0IsQ0FBQztRQUMzQixNQUFNLE9BQU8sR0FBRyxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxFQUFFO1lBQzVDLFNBQVMsR0FBRyxPQUFPLENBQUM7UUFDdEIsQ0FBQyxDQUFDLENBQUM7UUFFSCxpQkFBaUIsR0FBRztZQUNsQixPQUFPO1lBQ1AsU0FBUztTQUNWLENBQUM7S0FDSDtBQUNILENBQUM7QUFFRCxTQUFTLGFBQWE7SUFDcEIsS0FBSyxNQUFNLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxJQUFJLGFBQWEsRUFBRTtRQUN6QyxhQUFhLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzVCLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUM7S0FDN0I7SUFFRCxpQkFBa0IsQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUMvQixpQkFBaUIsR0FBRyxJQUFJLENBQUM7QUFDM0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge2Fzc2VydEluSW5qZWN0aW9uQ29udGV4dH0gZnJvbSAnLi4vLi4vZGkvY29udGV4dHVhbCc7XG5pbXBvcnQge0luamVjdG9yfSBmcm9tICcuLi8uLi9kaS9pbmplY3Rvcic7XG5pbXBvcnQge2luamVjdH0gZnJvbSAnLi4vLi4vZGkvaW5qZWN0b3JfY29tcGF0aWJpbGl0eSc7XG5pbXBvcnQge0Rlc3Ryb3lSZWZ9IGZyb20gJy4uLy4uL2xpbmtlci9kZXN0cm95X3JlZic7XG5pbXBvcnQge1dhdGNofSBmcm9tICcuLi8uLi9zaWduYWxzJztcblxuLyoqXG4gKiBBbiBlZmZlY3QgY2FuLCBvcHRpb25hbGx5LCByZXR1cm4gYSBjbGVhbnVwIGZ1bmN0aW9uLiBJZiByZXR1cm5lZCwgdGhlIGNsZWFudXAgaXMgZXhlY3V0ZWQgYmVmb3JlXG4gKiB0aGUgbmV4dCBlZmZlY3QgcnVuLiBUaGUgY2xlYW51cCBmdW5jdGlvbiBtYWtlcyBpdCBwb3NzaWJsZSB0byBcImNhbmNlbFwiIGFueSB3b3JrIHRoYXQgdGhlXG4gKiBwcmV2aW91cyBlZmZlY3QgcnVuIG1pZ2h0IGhhdmUgc3RhcnRlZC5cbiAqXG4gKiBAZGV2ZWxvcGVyUHJldmlld1xuICovXG5leHBvcnQgdHlwZSBFZmZlY3RDbGVhbnVwRm4gPSAoKSA9PiB2b2lkO1xuXG5jb25zdCBnbG9iYWxXYXRjaGVzID0gbmV3IFNldDxXYXRjaD4oKTtcbmNvbnN0IHF1ZXVlZFdhdGNoZXMgPSBuZXcgTWFwPFdhdGNoLCBab25lPigpO1xuXG5sZXQgd2F0Y2hRdWV1ZVByb21pc2U6IHtwcm9taXNlOiBQcm9taXNlPHZvaWQ+OyByZXNvbHZlRm46ICgpID0+IHZvaWQ7fXxudWxsID0gbnVsbDtcblxuLyoqXG4gKiBBIGdsb2JhbCByZWFjdGl2ZSBlZmZlY3QsIHdoaWNoIGNhbiBiZSBtYW51YWxseSBkZXN0cm95ZWQuXG4gKlxuICogQGRldmVsb3BlclByZXZpZXdcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBFZmZlY3RSZWYge1xuICAvKipcbiAgICogU2h1dCBkb3duIHRoZSBlZmZlY3QsIHJlbW92aW5nIGl0IGZyb20gYW55IHVwY29taW5nIHNjaGVkdWxlZCBleGVjdXRpb25zLlxuICAgKi9cbiAgZGVzdHJveSgpOiB2b2lkO1xufVxuXG4vKipcbiAqIE9wdGlvbnMgcGFzc2VkIHRvIHRoZSBgZWZmZWN0YCBmdW5jdGlvbi5cbiAqXG4gKiBAZGV2ZWxvcGVyUHJldmlld1xuICovXG5leHBvcnQgaW50ZXJmYWNlIENyZWF0ZUVmZmVjdE9wdGlvbnMge1xuICAvKipcbiAgICogVGhlIGBJbmplY3RvcmAgaW4gd2hpY2ggdG8gY3JlYXRlIHRoZSBlZmZlY3QuXG4gICAqXG4gICAqIElmIHRoaXMgaXMgbm90IHByb3ZpZGVkLCB0aGUgY3VycmVudCBpbmplY3Rpb24gY29udGV4dCB3aWxsIGJlIHVzZWQgaW5zdGVhZCAodmlhIGBpbmplY3RgKS5cbiAgICovXG4gIGluamVjdG9yPzogSW5qZWN0b3I7XG5cbiAgLyoqXG4gICAqIFdoZXRoZXIgdGhlIGBlZmZlY3RgIHNob3VsZCByZXF1aXJlIG1hbnVhbCBjbGVhbnVwLlxuICAgKlxuICAgKiBJZiB0aGlzIGlzIGBmYWxzZWAgKHRoZSBkZWZhdWx0KSB0aGUgZWZmZWN0IHdpbGwgYXV0b21hdGljYWxseSByZWdpc3RlciBpdHNlbGYgdG8gYmUgY2xlYW5lZCB1cFxuICAgKiB3aXRoIHRoZSBjdXJyZW50IGBEZXN0cm95UmVmYC5cbiAgICovXG4gIG1hbnVhbENsZWFudXA/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIENyZWF0ZSBhIGdsb2JhbCBgRWZmZWN0YCBmb3IgdGhlIGdpdmVuIHJlYWN0aXZlIGZ1bmN0aW9uLlxuICpcbiAqIEBkZXZlbG9wZXJQcmV2aWV3XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBlZmZlY3QoXG4gICAgZWZmZWN0Rm46ICgpID0+IEVmZmVjdENsZWFudXBGbiB8IHZvaWQsIG9wdGlvbnM/OiBDcmVhdGVFZmZlY3RPcHRpb25zKTogRWZmZWN0UmVmIHtcbiAgIW9wdGlvbnM/LmluamVjdG9yICYmIGFzc2VydEluSW5qZWN0aW9uQ29udGV4dChlZmZlY3QpO1xuXG4gIGNvbnN0IHpvbmUgPSBab25lLmN1cnJlbnQ7XG4gIGNvbnN0IHdhdGNoID0gbmV3IFdhdGNoKGVmZmVjdEZuLCAod2F0Y2gpID0+IHF1ZXVlV2F0Y2god2F0Y2gsIHpvbmUpKTtcblxuICBjb25zdCBpbmplY3RvciA9IG9wdGlvbnM/LmluamVjdG9yID8/IGluamVjdChJbmplY3Rvcik7XG4gIGNvbnN0IGRlc3Ryb3lSZWYgPSBvcHRpb25zPy5tYW51YWxDbGVhbnVwICE9PSB0cnVlID8gaW5qZWN0b3IuZ2V0KERlc3Ryb3lSZWYpIDogbnVsbDtcblxuICBnbG9iYWxXYXRjaGVzLmFkZCh3YXRjaCk7XG5cbiAgLy8gRWZmZWN0cyBzdGFydCBkaXJ0eS5cbiAgd2F0Y2gubm90aWZ5KCk7XG5cbiAgbGV0IHVucmVnaXN0ZXJPbkRlc3Ryb3k6ICgoKSA9PiB2b2lkKXx1bmRlZmluZWQ7XG5cbiAgY29uc3QgZGVzdHJveSA9ICgpID0+IHtcbiAgICB3YXRjaC5jbGVhbnVwKCk7XG4gICAgdW5yZWdpc3Rlck9uRGVzdHJveT8uKCk7XG4gICAgcXVldWVkV2F0Y2hlcy5kZWxldGUod2F0Y2gpO1xuICAgIGdsb2JhbFdhdGNoZXMuZGVsZXRlKHdhdGNoKTtcbiAgfTtcblxuICB1bnJlZ2lzdGVyT25EZXN0cm95ID0gZGVzdHJveVJlZj8ub25EZXN0cm95KGRlc3Ryb3kpO1xuXG4gIHJldHVybiB7XG4gICAgZGVzdHJveSxcbiAgfTtcbn1cblxuZnVuY3Rpb24gcXVldWVXYXRjaCh3YXRjaDogV2F0Y2gsIHpvbmU6IFpvbmUpOiB2b2lkIHtcbiAgaWYgKHF1ZXVlZFdhdGNoZXMuaGFzKHdhdGNoKSB8fCAhZ2xvYmFsV2F0Y2hlcy5oYXMod2F0Y2gpKSB7XG4gICAgcmV0dXJuO1xuICB9XG5cbiAgcXVldWVkV2F0Y2hlcy5zZXQod2F0Y2gsIHpvbmUpO1xuXG4gIGlmICh3YXRjaFF1ZXVlUHJvbWlzZSA9PT0gbnVsbCkge1xuICAgIFByb21pc2UucmVzb2x2ZSgpLnRoZW4ocnVuV2F0Y2hRdWV1ZSk7XG5cbiAgICBsZXQgcmVzb2x2ZUZuITogKCkgPT4gdm9pZDtcbiAgICBjb25zdCBwcm9taXNlID0gbmV3IFByb21pc2U8dm9pZD4oKHJlc29sdmUpID0+IHtcbiAgICAgIHJlc29sdmVGbiA9IHJlc29sdmU7XG4gICAgfSk7XG5cbiAgICB3YXRjaFF1ZXVlUHJvbWlzZSA9IHtcbiAgICAgIHByb21pc2UsXG4gICAgICByZXNvbHZlRm4sXG4gICAgfTtcbiAgfVxufVxuXG5mdW5jdGlvbiBydW5XYXRjaFF1ZXVlKCk6IHZvaWQge1xuICBmb3IgKGNvbnN0IFt3YXRjaCwgem9uZV0gb2YgcXVldWVkV2F0Y2hlcykge1xuICAgIHF1ZXVlZFdhdGNoZXMuZGVsZXRlKHdhdGNoKTtcbiAgICB6b25lLnJ1bigoKSA9PiB3YXRjaC5ydW4oKSk7XG4gIH1cblxuICB3YXRjaFF1ZXVlUHJvbWlzZSEucmVzb2x2ZUZuKCk7XG4gIHdhdGNoUXVldWVQcm9taXNlID0gbnVsbDtcbn1cbiJdfQ==
+//# 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, return a cleanup function. If returned, the cleanup is executed before\n * 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 * 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>();\n\n  create(effectFn: () => void, destroyRef: DestroyRef|null, allowSignalWrites: boolean): EffectRef {\n    const zone = 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      zone.run(() => watch.run());\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 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: () => EffectCleanupFn | void, 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"]}

package/esm2022/src/sanitization/sanitization.mjs

@@ -8,7 +8,7 @@
 import { XSS_SECURITY_URL } from '../error_details_base_url';
 import { RuntimeError } from '../errors';
 import { getDocument } from '../render3/interfaces/document';
-import { SANITIZER } from '../render3/interfaces/view';
+import { ENVIRONMENT } from '../render3/interfaces/view';
 import { getLView } from '../render3/state';
 import { renderStringify } from '../render3/util/stringify_utils';
 import { trustedHTMLFromString, trustedScriptURLFromString } from '../util/security/trusted_types';
@@ -234,6 +234,6 @@ export function validateAgainstEventAttributes(name) {
 }
 function getSanitizer() {
     const lView = getLView();
-    return lView && lView[SANITIZER];
+    return lView && lView[ENVIRONMENT].sanitizer;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sanitization.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/sanitization/sanitization.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 {XSS_SECURITY_URL} from '../error_details_base_url';\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {getDocument} from '../render3/interfaces/document';\nimport {SANITIZER} from '../render3/interfaces/view';\nimport {getLView} from '../render3/state';\nimport {renderStringify} from '../render3/util/stringify_utils';\nimport {TrustedHTML, TrustedScript, TrustedScriptURL} from '../util/security/trusted_type_defs';\nimport {trustedHTMLFromString, trustedScriptURLFromString} from '../util/security/trusted_types';\nimport {trustedHTMLFromStringBypass, trustedScriptFromStringBypass, trustedScriptURLFromStringBypass} from '../util/security/trusted_types_bypass';\n\nimport {allowSanitizationBypassAndThrow, BypassType, unwrapSafeValue} from './bypass';\nimport {_sanitizeHtml as _sanitizeHtml} from './html_sanitizer';\nimport {Sanitizer} from './sanitizer';\nimport {SecurityContext} from './security';\nimport {_sanitizeUrl as _sanitizeUrl} from './url_sanitizer';\n\n\n\n/**\n * An `html` sanitizer which converts untrusted `html` **string** into trusted string by removing\n * dangerous content.\n *\n * This method parses the `html` and locates potentially dangerous content (such as urls and\n * javascript) and removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustHtml}.\n *\n * @param unsafeHtml untrusted `html`, typically from the user.\n * @returns `html` string which is safe to display to user, because all of the dangerous javascript\n * and urls have been removed.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeHtml(unsafeHtml: any): TrustedHTML|string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return trustedHTMLFromStringBypass(sanitizer.sanitize(SecurityContext.HTML, unsafeHtml) || '');\n  }\n  if (allowSanitizationBypassAndThrow(unsafeHtml, BypassType.Html)) {\n    return trustedHTMLFromStringBypass(unwrapSafeValue(unsafeHtml));\n  }\n  return _sanitizeHtml(getDocument(), renderStringify(unsafeHtml));\n}\n\n/**\n * A `style` sanitizer which converts untrusted `style` **string** into trusted string by removing\n * dangerous content.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustStyle}.\n *\n * @param unsafeStyle untrusted `style`, typically from the user.\n * @returns `style` string which is safe to bind to the `style` properties.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeStyle(unsafeStyle: any): string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return sanitizer.sanitize(SecurityContext.STYLE, unsafeStyle) || '';\n  }\n  if (allowSanitizationBypassAndThrow(unsafeStyle, BypassType.Style)) {\n    return unwrapSafeValue(unsafeStyle);\n  }\n  return renderStringify(unsafeStyle);\n}\n\n/**\n * A `url` sanitizer which converts untrusted `url` **string** into trusted string by removing\n * dangerous\n * content.\n *\n * This method parses the `url` and locates potentially dangerous content (such as javascript) and\n * removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustUrl}.\n *\n * @param unsafeUrl untrusted `url`, typically from the user.\n * @returns `url` string which is safe to bind to the `src` properties such as `<img src>`, because\n * all of the dangerous javascript has been removed.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeUrl(unsafeUrl: any): string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return sanitizer.sanitize(SecurityContext.URL, unsafeUrl) || '';\n  }\n  if (allowSanitizationBypassAndThrow(unsafeUrl, BypassType.Url)) {\n    return unwrapSafeValue(unsafeUrl);\n  }\n  return _sanitizeUrl(renderStringify(unsafeUrl));\n}\n\n/**\n * A `url` sanitizer which only lets trusted `url`s through.\n *\n * This passes only `url`s marked trusted by calling {@link bypassSanitizationTrustResourceUrl}.\n *\n * @param unsafeResourceUrl untrusted `url`, typically from the user.\n * @returns `url` string which is safe to bind to the `src` properties such as `<img src>`, because\n * only trusted `url`s have been allowed to pass.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeResourceUrl(unsafeResourceUrl: any): TrustedScriptURL|string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return trustedScriptURLFromStringBypass(\n        sanitizer.sanitize(SecurityContext.RESOURCE_URL, unsafeResourceUrl) || '');\n  }\n  if (allowSanitizationBypassAndThrow(unsafeResourceUrl, BypassType.ResourceUrl)) {\n    return trustedScriptURLFromStringBypass(unwrapSafeValue(unsafeResourceUrl));\n  }\n  throw new RuntimeError(\n      RuntimeErrorCode.UNSAFE_VALUE_IN_RESOURCE_URL,\n      ngDevMode && `unsafe value used in a resource URL context (see ${XSS_SECURITY_URL})`);\n}\n\n/**\n * A `script` sanitizer which only lets trusted javascript through.\n *\n * This passes only `script`s marked trusted by calling {@link\n * bypassSanitizationTrustScript}.\n *\n * @param unsafeScript untrusted `script`, typically from the user.\n * @returns `url` string which is safe to bind to the `<script>` element such as `<img src>`,\n * because only trusted `scripts` have been allowed to pass.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeScript(unsafeScript: any): TrustedScript|string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return trustedScriptFromStringBypass(\n        sanitizer.sanitize(SecurityContext.SCRIPT, unsafeScript) || '');\n  }\n  if (allowSanitizationBypassAndThrow(unsafeScript, BypassType.Script)) {\n    return trustedScriptFromStringBypass(unwrapSafeValue(unsafeScript));\n  }\n  throw new RuntimeError(\n      RuntimeErrorCode.UNSAFE_VALUE_IN_SCRIPT,\n      ngDevMode && 'unsafe value used in a script context');\n}\n\n/**\n * A template tag function for promoting the associated constant literal to a\n * TrustedHTML. Interpolation is explicitly not allowed.\n *\n * @param html constant template literal containing trusted HTML.\n * @returns TrustedHTML wrapping `html`.\n *\n * @security This is a security-sensitive function and should only be used to\n * convert constant values of attributes and properties found in\n * application-provided Angular templates to TrustedHTML.\n *\n * @codeGenApi\n */\nexport function ɵɵtrustConstantHtml(html: TemplateStringsArray): TrustedHTML|string {\n  // The following runtime check ensures that the function was called as a\n  // template tag (e.g. ɵɵtrustConstantHtml`content`), without any interpolation\n  // (e.g. not ɵɵtrustConstantHtml`content ${variable}`). A TemplateStringsArray\n  // is an array with a `raw` property that is also an array. The associated\n  // template literal has no interpolation if and only if the length of the\n  // TemplateStringsArray is 1.\n  if (ngDevMode && (!Array.isArray(html) || !Array.isArray(html.raw) || html.length !== 1)) {\n    throw new Error(`Unexpected interpolation in trusted HTML constant: ${html.join('?')}`);\n  }\n  return trustedHTMLFromString(html[0]);\n}\n\n/**\n * A template tag function for promoting the associated constant literal to a\n * TrustedScriptURL. Interpolation is explicitly not allowed.\n *\n * @param url constant template literal containing a trusted script URL.\n * @returns TrustedScriptURL wrapping `url`.\n *\n * @security This is a security-sensitive function and should only be used to\n * convert constant values of attributes and properties found in\n * application-provided Angular templates to TrustedScriptURL.\n *\n * @codeGenApi\n */\nexport function ɵɵtrustConstantResourceUrl(url: TemplateStringsArray): TrustedScriptURL|string {\n  // The following runtime check ensures that the function was called as a\n  // template tag (e.g. ɵɵtrustConstantResourceUrl`content`), without any\n  // interpolation (e.g. not ɵɵtrustConstantResourceUrl`content ${variable}`). A\n  // TemplateStringsArray is an array with a `raw` property that is also an\n  // array. The associated template literal has no interpolation if and only if\n  // the length of the TemplateStringsArray is 1.\n  if (ngDevMode && (!Array.isArray(url) || !Array.isArray(url.raw) || url.length !== 1)) {\n    throw new Error(`Unexpected interpolation in trusted URL constant: ${url.join('?')}`);\n  }\n  return trustedScriptURLFromString(url[0]);\n}\n\n/**\n * Detects which sanitizer to use for URL property, based on tag name and prop name.\n *\n * The rules are based on the RESOURCE_URL context config from\n * `packages/compiler/src/schema/dom_security_schema.ts`.\n * If tag and prop names don't match Resource URL schema, use URL sanitizer.\n */\nexport function getUrlSanitizer(tag: string, prop: string) {\n  if ((prop === 'src' &&\n       (tag === 'embed' || tag === 'frame' || tag === 'iframe' || tag === 'media' ||\n        tag === 'script')) ||\n      (prop === 'href' && (tag === 'base' || tag === 'link'))) {\n    return ɵɵsanitizeResourceUrl;\n  }\n  return ɵɵsanitizeUrl;\n}\n\n/**\n * Sanitizes URL, selecting sanitizer function based on tag and property names.\n *\n * This function is used in case we can't define security context at compile time, when only prop\n * name is available. This happens when we generate host bindings for Directives/Components. The\n * host element is unknown at compile time, so we defer calculation of specific sanitizer to\n * runtime.\n *\n * @param unsafeUrl untrusted `url`, typically from the user.\n * @param tag target element tag name.\n * @param prop name of the property that contains the value.\n * @returns `url` string which is safe to bind.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeUrlOrResourceUrl(unsafeUrl: any, tag: string, prop: string): any {\n  return getUrlSanitizer(tag, prop)(unsafeUrl);\n}\n\nexport function validateAgainstEventProperties(name: string) {\n  if (name.toLowerCase().startsWith('on')) {\n    const errorMessage =\n        `Binding to event property '${name}' is disallowed for security reasons, ` +\n        `please use (${name.slice(2)})=...` +\n        `\\nIf '${name}' is a directive input, make sure the directive is imported by the` +\n        ` current module.`;\n    throw new RuntimeError(RuntimeErrorCode.INVALID_EVENT_BINDING, errorMessage);\n  }\n}\n\nexport function validateAgainstEventAttributes(name: string) {\n  if (name.toLowerCase().startsWith('on')) {\n    const errorMessage =\n        `Binding to event attribute '${name}' is disallowed for security reasons, ` +\n        `please use (${name.slice(2)})=...`;\n    throw new RuntimeError(RuntimeErrorCode.INVALID_EVENT_BINDING, errorMessage);\n  }\n}\n\nfunction getSanitizer(): Sanitizer|null {\n  const lView = getLView();\n  return lView && lView[SANITIZER];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sanitization.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/sanitization/sanitization.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 {XSS_SECURITY_URL} from '../error_details_base_url';\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {getDocument} from '../render3/interfaces/document';\nimport {ENVIRONMENT} from '../render3/interfaces/view';\nimport {getLView} from '../render3/state';\nimport {renderStringify} from '../render3/util/stringify_utils';\nimport {TrustedHTML, TrustedScript, TrustedScriptURL} from '../util/security/trusted_type_defs';\nimport {trustedHTMLFromString, trustedScriptURLFromString} from '../util/security/trusted_types';\nimport {trustedHTMLFromStringBypass, trustedScriptFromStringBypass, trustedScriptURLFromStringBypass} from '../util/security/trusted_types_bypass';\n\nimport {allowSanitizationBypassAndThrow, BypassType, unwrapSafeValue} from './bypass';\nimport {_sanitizeHtml as _sanitizeHtml} from './html_sanitizer';\nimport {Sanitizer} from './sanitizer';\nimport {SecurityContext} from './security';\nimport {_sanitizeUrl as _sanitizeUrl} from './url_sanitizer';\n\n\n\n/**\n * An `html` sanitizer which converts untrusted `html` **string** into trusted string by removing\n * dangerous content.\n *\n * This method parses the `html` and locates potentially dangerous content (such as urls and\n * javascript) and removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustHtml}.\n *\n * @param unsafeHtml untrusted `html`, typically from the user.\n * @returns `html` string which is safe to display to user, because all of the dangerous javascript\n * and urls have been removed.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeHtml(unsafeHtml: any): TrustedHTML|string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return trustedHTMLFromStringBypass(sanitizer.sanitize(SecurityContext.HTML, unsafeHtml) || '');\n  }\n  if (allowSanitizationBypassAndThrow(unsafeHtml, BypassType.Html)) {\n    return trustedHTMLFromStringBypass(unwrapSafeValue(unsafeHtml));\n  }\n  return _sanitizeHtml(getDocument(), renderStringify(unsafeHtml));\n}\n\n/**\n * A `style` sanitizer which converts untrusted `style` **string** into trusted string by removing\n * dangerous content.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustStyle}.\n *\n * @param unsafeStyle untrusted `style`, typically from the user.\n * @returns `style` string which is safe to bind to the `style` properties.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeStyle(unsafeStyle: any): string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return sanitizer.sanitize(SecurityContext.STYLE, unsafeStyle) || '';\n  }\n  if (allowSanitizationBypassAndThrow(unsafeStyle, BypassType.Style)) {\n    return unwrapSafeValue(unsafeStyle);\n  }\n  return renderStringify(unsafeStyle);\n}\n\n/**\n * A `url` sanitizer which converts untrusted `url` **string** into trusted string by removing\n * dangerous\n * content.\n *\n * This method parses the `url` and locates potentially dangerous content (such as javascript) and\n * removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustUrl}.\n *\n * @param unsafeUrl untrusted `url`, typically from the user.\n * @returns `url` string which is safe to bind to the `src` properties such as `<img src>`, because\n * all of the dangerous javascript has been removed.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeUrl(unsafeUrl: any): string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return sanitizer.sanitize(SecurityContext.URL, unsafeUrl) || '';\n  }\n  if (allowSanitizationBypassAndThrow(unsafeUrl, BypassType.Url)) {\n    return unwrapSafeValue(unsafeUrl);\n  }\n  return _sanitizeUrl(renderStringify(unsafeUrl));\n}\n\n/**\n * A `url` sanitizer which only lets trusted `url`s through.\n *\n * This passes only `url`s marked trusted by calling {@link bypassSanitizationTrustResourceUrl}.\n *\n * @param unsafeResourceUrl untrusted `url`, typically from the user.\n * @returns `url` string which is safe to bind to the `src` properties such as `<img src>`, because\n * only trusted `url`s have been allowed to pass.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeResourceUrl(unsafeResourceUrl: any): TrustedScriptURL|string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return trustedScriptURLFromStringBypass(\n        sanitizer.sanitize(SecurityContext.RESOURCE_URL, unsafeResourceUrl) || '');\n  }\n  if (allowSanitizationBypassAndThrow(unsafeResourceUrl, BypassType.ResourceUrl)) {\n    return trustedScriptURLFromStringBypass(unwrapSafeValue(unsafeResourceUrl));\n  }\n  throw new RuntimeError(\n      RuntimeErrorCode.UNSAFE_VALUE_IN_RESOURCE_URL,\n      ngDevMode && `unsafe value used in a resource URL context (see ${XSS_SECURITY_URL})`);\n}\n\n/**\n * A `script` sanitizer which only lets trusted javascript through.\n *\n * This passes only `script`s marked trusted by calling {@link\n * bypassSanitizationTrustScript}.\n *\n * @param unsafeScript untrusted `script`, typically from the user.\n * @returns `url` string which is safe to bind to the `<script>` element such as `<img src>`,\n * because only trusted `scripts` have been allowed to pass.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeScript(unsafeScript: any): TrustedScript|string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return trustedScriptFromStringBypass(\n        sanitizer.sanitize(SecurityContext.SCRIPT, unsafeScript) || '');\n  }\n  if (allowSanitizationBypassAndThrow(unsafeScript, BypassType.Script)) {\n    return trustedScriptFromStringBypass(unwrapSafeValue(unsafeScript));\n  }\n  throw new RuntimeError(\n      RuntimeErrorCode.UNSAFE_VALUE_IN_SCRIPT,\n      ngDevMode && 'unsafe value used in a script context');\n}\n\n/**\n * A template tag function for promoting the associated constant literal to a\n * TrustedHTML. Interpolation is explicitly not allowed.\n *\n * @param html constant template literal containing trusted HTML.\n * @returns TrustedHTML wrapping `html`.\n *\n * @security This is a security-sensitive function and should only be used to\n * convert constant values of attributes and properties found in\n * application-provided Angular templates to TrustedHTML.\n *\n * @codeGenApi\n */\nexport function ɵɵtrustConstantHtml(html: TemplateStringsArray): TrustedHTML|string {\n  // The following runtime check ensures that the function was called as a\n  // template tag (e.g. ɵɵtrustConstantHtml`content`), without any interpolation\n  // (e.g. not ɵɵtrustConstantHtml`content ${variable}`). A TemplateStringsArray\n  // is an array with a `raw` property that is also an array. The associated\n  // template literal has no interpolation if and only if the length of the\n  // TemplateStringsArray is 1.\n  if (ngDevMode && (!Array.isArray(html) || !Array.isArray(html.raw) || html.length !== 1)) {\n    throw new Error(`Unexpected interpolation in trusted HTML constant: ${html.join('?')}`);\n  }\n  return trustedHTMLFromString(html[0]);\n}\n\n/**\n * A template tag function for promoting the associated constant literal to a\n * TrustedScriptURL. Interpolation is explicitly not allowed.\n *\n * @param url constant template literal containing a trusted script URL.\n * @returns TrustedScriptURL wrapping `url`.\n *\n * @security This is a security-sensitive function and should only be used to\n * convert constant values of attributes and properties found in\n * application-provided Angular templates to TrustedScriptURL.\n *\n * @codeGenApi\n */\nexport function ɵɵtrustConstantResourceUrl(url: TemplateStringsArray): TrustedScriptURL|string {\n  // The following runtime check ensures that the function was called as a\n  // template tag (e.g. ɵɵtrustConstantResourceUrl`content`), without any\n  // interpolation (e.g. not ɵɵtrustConstantResourceUrl`content ${variable}`). A\n  // TemplateStringsArray is an array with a `raw` property that is also an\n  // array. The associated template literal has no interpolation if and only if\n  // the length of the TemplateStringsArray is 1.\n  if (ngDevMode && (!Array.isArray(url) || !Array.isArray(url.raw) || url.length !== 1)) {\n    throw new Error(`Unexpected interpolation in trusted URL constant: ${url.join('?')}`);\n  }\n  return trustedScriptURLFromString(url[0]);\n}\n\n/**\n * Detects which sanitizer to use for URL property, based on tag name and prop name.\n *\n * The rules are based on the RESOURCE_URL context config from\n * `packages/compiler/src/schema/dom_security_schema.ts`.\n * If tag and prop names don't match Resource URL schema, use URL sanitizer.\n */\nexport function getUrlSanitizer(tag: string, prop: string) {\n  if ((prop === 'src' &&\n       (tag === 'embed' || tag === 'frame' || tag === 'iframe' || tag === 'media' ||\n        tag === 'script')) ||\n      (prop === 'href' && (tag === 'base' || tag === 'link'))) {\n    return ɵɵsanitizeResourceUrl;\n  }\n  return ɵɵsanitizeUrl;\n}\n\n/**\n * Sanitizes URL, selecting sanitizer function based on tag and property names.\n *\n * This function is used in case we can't define security context at compile time, when only prop\n * name is available. This happens when we generate host bindings for Directives/Components. The\n * host element is unknown at compile time, so we defer calculation of specific sanitizer to\n * runtime.\n *\n * @param unsafeUrl untrusted `url`, typically from the user.\n * @param tag target element tag name.\n * @param prop name of the property that contains the value.\n * @returns `url` string which is safe to bind.\n *\n * @codeGenApi\n */\nexport function ɵɵsanitizeUrlOrResourceUrl(unsafeUrl: any, tag: string, prop: string): any {\n  return getUrlSanitizer(tag, prop)(unsafeUrl);\n}\n\nexport function validateAgainstEventProperties(name: string) {\n  if (name.toLowerCase().startsWith('on')) {\n    const errorMessage =\n        `Binding to event property '${name}' is disallowed for security reasons, ` +\n        `please use (${name.slice(2)})=...` +\n        `\\nIf '${name}' is a directive input, make sure the directive is imported by the` +\n        ` current module.`;\n    throw new RuntimeError(RuntimeErrorCode.INVALID_EVENT_BINDING, errorMessage);\n  }\n}\n\nexport function validateAgainstEventAttributes(name: string) {\n  if (name.toLowerCase().startsWith('on')) {\n    const errorMessage =\n        `Binding to event attribute '${name}' is disallowed for security reasons, ` +\n        `please use (${name.slice(2)})=...`;\n    throw new RuntimeError(RuntimeErrorCode.INVALID_EVENT_BINDING, errorMessage);\n  }\n}\n\nfunction getSanitizer(): Sanitizer|null {\n  const lView = getLView();\n  return lView && lView[ENVIRONMENT].sanitizer;\n}\n"]}

package/esm2022/src/sanitization/url_sanitizer.mjs

@@ -7,13 +7,14 @@
  */
 import { XSS_SECURITY_URL } from '../error_details_base_url';
 /**
- * A pattern that recognizes a commonly useful subset of URLs that are safe.
+ * A pattern that recognizes URLs that are safe wrt. XSS in URL navigation
+ * contexts.
  *
  * This regular expression matches a subset of URLs that will not cause script
  * execution if used in URL context within a HTML document. Specifically, this
- * regular expression matches if (comment from here on and regex copied from
- * Soy's EscapingConventions):
- * (1) Either an allowed protocol (http, https, mailto or ftp).
+ * regular expression matches if:
+ * (1) Either a protocol that is not javascript:, and that has valid characters
+ *     (alphanumeric or [+-.]).
  * (2) or no protocol.  A protocol must be followed by a colon. The below
  *     allows that by allowing colons only after one of the characters [/?#].
  *     A colon after a hash (#) must be in the fragment.
@@ -32,7 +33,7 @@ import { XSS_SECURITY_URL } from '../error_details_base_url';
  *
  * This regular expression was taken from the Closure sanitization library.
  */
-const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|data|ftp|tel|file|sms):|[^&:/?#]*(?:[/?#]|$))/gi;
+const SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:\/?#]*(?:[\/?#]|$))/i;
 export function _sanitizeUrl(url) {
     url = String(url);
     if (url.match(SAFE_URL_PATTERN))
@@ -42,4 +43,4 @@ export function _sanitizeUrl(url) {
     }
     return 'unsafe:' + url;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJsX3Nhbml0aXplci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL3Nhbml0aXphdGlvbi91cmxfc2FuaXRpemVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLDJCQUEyQixDQUFDO0FBRTNEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTBCRztBQUNILE1BQU0sZ0JBQWdCLEdBQUcsMkRBQTJELENBQUM7QUFDckYsTUFBTSxVQUFVLFlBQVksQ0FBQyxHQUFXO0lBQ3RDLEdBQUcsR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbEIsSUFBSSxHQUFHLENBQUMsS0FBSyxDQUFDLGdCQUFnQixDQUFDO1FBQUUsT0FBTyxHQUFHLENBQUM7SUFFNUMsSUFBSSxPQUFPLFNBQVMsS0FBSyxXQUFXLElBQUksU0FBUyxFQUFFO1FBQ2pELE9BQU8sQ0FBQyxJQUFJLENBQUMsd0NBQXdDLEdBQUcsU0FBUyxnQkFBZ0IsR0FBRyxDQUFDLENBQUM7S0FDdkY7SUFFRCxPQUFPLFNBQVMsR0FBRyxHQUFHLENBQUM7QUFDekIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge1hTU19TRUNVUklUWV9VUkx9IGZyb20gJy4uL2Vycm9yX2RldGFpbHNfYmFzZV91cmwnO1xuXG4vKipcbiAqIEEgcGF0dGVybiB0aGF0IHJlY29nbml6ZXMgVVJMcyB0aGF0IGFyZSBzYWZlIHdydC4gWFNTIGluIFVSTCBuYXZpZ2F0aW9uXG4gKiBjb250ZXh0cy5cbiAqXG4gKiBUaGlzIHJlZ3VsYXIgZXhwcmVzc2lvbiBtYXRjaGVzIGEgc3Vic2V0IG9mIFVSTHMgdGhhdCB3aWxsIG5vdCBjYXVzZSBzY3JpcHRcbiAqIGV4ZWN1dGlvbiBpZiB1c2VkIGluIFVSTCBjb250ZXh0IHdpdGhpbiBhIEhUTUwgZG9jdW1lbnQuIFNwZWNpZmljYWxseSwgdGhpc1xuICogcmVndWxhciBleHByZXNzaW9uIG1hdGNoZXMgaWY6XG4gKiAoMSkgRWl0aGVyIGEgcHJvdG9jb2wgdGhhdCBpcyBub3QgamF2YXNjcmlwdDosIGFuZCB0aGF0IGhhcyB2YWxpZCBjaGFyYWN0ZXJzXG4gKiAgICAgKGFscGhhbnVtZXJpYyBvciBbKy0uXSkuXG4gKiAoMikgb3Igbm8gcHJvdG9jb2wuICBBIHByb3RvY29sIG11c3QgYmUgZm9sbG93ZWQgYnkgYSBjb2xvbi4gVGhlIGJlbG93XG4gKiAgICAgYWxsb3dzIHRoYXQgYnkgYWxsb3dpbmcgY29sb25zIG9ubHkgYWZ0ZXIgb25lIG9mIHRoZSBjaGFyYWN0ZXJzIFsvPyNdLlxuICogICAgIEEgY29sb24gYWZ0ZXIgYSBoYXNoICgjKSBtdXN0IGJlIGluIHRoZSBmcmFnbWVudC5cbiAqICAgICBPdGhlcndpc2UsIGEgY29sb24gYWZ0ZXIgYSAoPykgbXVzdCBiZSBpbiBhIHF1ZXJ5LlxuICogICAgIE90aGVyd2lzZSwgYSBjb2xvbiBhZnRlciBhIHNpbmdsZSBzb2xpZHVzICgvKSBtdXN0IGJlIGluIGEgcGF0aC5cbiAqICAgICBPdGhlcndpc2UsIGEgY29sb24gYWZ0ZXIgYSBkb3VibGUgc29saWR1cyAoLy8pIG11c3QgYmUgaW4gdGhlIGF1dGhvcml0eVxuICogICAgIChiZWZvcmUgcG9ydCkuXG4gKlxuICogVGhlIHBhdHRlcm4gZGlzYWxsb3dzICYsIHVzZWQgaW4gSFRNTCBlbnRpdHkgZGVjbGFyYXRpb25zIGJlZm9yZVxuICogb25lIG9mIHRoZSBjaGFyYWN0ZXJzIGluIFsvPyNdLiBUaGlzIGRpc2FsbG93cyBIVE1MIGVudGl0aWVzIHVzZWQgaW4gdGhlXG4gKiBwcm90b2NvbCBuYW1lLCB3aGljaCBzaG91bGQgbmV2ZXIgaGFwcGVuLCBlLmcuIFwiaCYjMTE2O3RwXCIgZm9yIFwiaHR0cFwiLlxuICogSXQgYWxzbyBkaXNhbGxvd3MgSFRNTCBlbnRpdGllcyBpbiB0aGUgZmlyc3QgcGF0aCBwYXJ0IG9mIGEgcmVsYXRpdmUgcGF0aCxcbiAqIGUuZy4gXCJmb28mbHQ7YmFyL2JhelwiLiAgT3VyIGV4aXN0aW5nIGVzY2FwaW5nIGZ1bmN0aW9ucyBzaG91bGQgbm90IHByb2R1Y2VcbiAqIHRoYXQuIE1vcmUgaW1wb3J0YW50bHksIGl0IGRpc2FsbG93cyBtYXNraW5nIG9mIGEgY29sb24sXG4gKiBlLmcuIFwiamF2YXNjcmlwdCYjNTg7Li4uXCIuXG4gKlxuICogVGhpcyByZWd1bGFyIGV4cHJlc3Npb24gd2FzIHRha2VuIGZyb20gdGhlIENsb3N1cmUgc2FuaXRpemF0aW9uIGxpYnJhcnkuXG4gKi9cbmNvbnN0IFNBRkVfVVJMX1BBVFRFUk4gPSAvXig/IWphdmFzY3JpcHQ6KSg/OlthLXowLTkrLi1dKzp8W14mOlxcLz8jXSooPzpbXFwvPyNdfCQpKS9pO1xuZXhwb3J0IGZ1bmN0aW9uIF9zYW5pdGl6ZVVybCh1cmw6IHN0cmluZyk6IHN0cmluZyB7XG4gIHVybCA9IFN0cmluZyh1cmwpO1xuICBpZiAodXJsLm1hdGNoKFNBRkVfVVJMX1BBVFRFUk4pKSByZXR1cm4gdXJsO1xuXG4gIGlmICh0eXBlb2YgbmdEZXZNb2RlID09PSAndW5kZWZpbmVkJyB8fCBuZ0Rldk1vZGUpIHtcbiAgICBjb25zb2xlLndhcm4oYFdBUk5JTkc6IHNhbml0aXppbmcgdW5zYWZlIFVSTCB2YWx1ZSAke3VybH0gKHNlZSAke1hTU19TRUNVUklUWV9VUkx9KWApO1xuICB9XG5cbiAgcmV0dXJuICd1bnNhZmU6JyArIHVybDtcbn1cbiJdfQ==

package/esm2022/src/signals/index.mjs

@@ -5,11 +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 { isSignal } from './src/api';
+export { createSignalFromFunction, defaultEquals, isSignal } from './src/api';
 export { computed } from './src/computed';
-export { setActiveConsumer } from './src/graph';
-export { signal } from './src/signal';
+export { setThrowInvalidWriteToSignalError } from './src/errors';
+export { ReactiveNode, 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9zaWduYWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBZSxRQUFRLEVBQTBCLE1BQU0sV0FBVyxDQUFDO0FBQzFFLE9BQU8sRUFBQyxRQUFRLEVBQXdCLE1BQU0sZ0JBQWdCLENBQUM7QUFDL0QsT0FBTyxFQUFDLGlCQUFpQixFQUFDLE1BQU0sYUFBYSxDQUFDO0FBQzlDLE9BQU8sRUFBc0IsTUFBTSxFQUFpQixNQUFNLGNBQWMsQ0FBQztBQUN6RSxPQUFPLEVBQUMsU0FBUyxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxFQUFDLEtBQUssRUFBaUIsTUFBTSxhQUFhLENBQUM7QUFDbEQsT0FBTyxFQUFDLHVCQUF1QixFQUFDLE1BQU0sZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHtEZWVwUmVhZG9ubHksIGlzU2lnbmFsLCBTaWduYWwsIFZhbHVlRXF1YWxpdHlGbn0gZnJvbSAnLi9zcmMvYXBpJztcbmV4cG9ydCB7Y29tcHV0ZWQsIENyZWF0ZUNvbXB1dGVkT3B0aW9uc30gZnJvbSAnLi9zcmMvY29tcHV0ZWQnO1xuZXhwb3J0IHtzZXRBY3RpdmVDb25zdW1lcn0gZnJvbSAnLi9zcmMvZ3JhcGgnO1xuZXhwb3J0IHtDcmVhdGVTaWduYWxPcHRpb25zLCBzaWduYWwsIFdyaXRhYmxlU2lnbmFsfSBmcm9tICcuL3NyYy9zaWduYWwnO1xuZXhwb3J0IHt1bnRyYWNrZWR9IGZyb20gJy4vc3JjL3VudHJhY2tlZCc7XG5leHBvcnQge1dhdGNoLCBXYXRjaENsZWFudXBGbn0gZnJvbSAnLi9zcmMvd2F0Y2gnO1xuZXhwb3J0IHtzZXRBbHRlcm5hdGVXZWFrUmVmSW1wbH0gZnJvbSAnLi9zcmMvd2Vha19yZWYnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9zaWduYWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyx3QkFBd0IsRUFBRSxhQUFhLEVBQUUsUUFBUSxFQUEwQixNQUFNLFdBQVcsQ0FBQztBQUNyRyxPQUFPLEVBQUMsUUFBUSxFQUF3QixNQUFNLGdCQUFnQixDQUFDO0FBQy9ELE9BQU8sRUFBQyxpQ0FBaUMsRUFBQyxNQUFNLGNBQWMsQ0FBQztBQUMvRCxPQUFPLEVBQUMsWUFBWSxFQUFFLGlCQUFpQixFQUFDLE1BQU0sYUFBYSxDQUFDO0FBQzVELE9BQU8sRUFBc0Isa0JBQWtCLEVBQUUsTUFBTSxFQUFpQixNQUFNLGNBQWMsQ0FBQztBQUM3RixPQUFPLEVBQUMsU0FBUyxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxFQUFDLEtBQUssRUFBaUIsTUFBTSxhQUFhLENBQUM7QUFDbEQsT0FBTyxFQUFDLHVCQUF1QixFQUFDLE1BQU0sZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHtjcmVhdGVTaWduYWxGcm9tRnVuY3Rpb24sIGRlZmF1bHRFcXVhbHMsIGlzU2lnbmFsLCBTaWduYWwsIFZhbHVlRXF1YWxpdHlGbn0gZnJvbSAnLi9zcmMvYXBpJztcbmV4cG9ydCB7Y29tcHV0ZWQsIENyZWF0ZUNvbXB1dGVkT3B0aW9uc30gZnJvbSAnLi9zcmMvY29tcHV0ZWQnO1xuZXhwb3J0IHtzZXRUaHJvd0ludmFsaWRXcml0ZVRvU2lnbmFsRXJyb3J9IGZyb20gJy4vc3JjL2Vycm9ycyc7XG5leHBvcnQge1JlYWN0aXZlTm9kZSwgc2V0QWN0aXZlQ29uc3VtZXJ9IGZyb20gJy4vc3JjL2dyYXBoJztcbmV4cG9ydCB7Q3JlYXRlU2lnbmFsT3B0aW9ucywgc2V0UG9zdFNpZ25hbFNldEZuLCBzaWduYWwsIFdyaXRhYmxlU2lnbmFsfSBmcm9tICcuL3NyYy9zaWduYWwnO1xuZXhwb3J0IHt1bnRyYWNrZWR9IGZyb20gJy4vc3JjL3VudHJhY2tlZCc7XG5leHBvcnQge1dhdGNoLCBXYXRjaENsZWFudXBGbn0gZnJvbSAnLi9zcmMvd2F0Y2gnO1xuZXhwb3J0IHtzZXRBbHRlcm5hdGVXZWFrUmVmSW1wbH0gZnJvbSAnLi9zcmMvd2Vha19yZWYnO1xuIl19

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

@@ -43,5 +43,4 @@ export function defaultEquals(a, b) {
     // as objects (`typeof null === 'object'`).
     return (a === null || typeof a !== 'object') && Object.is(a, b);
 }
-// clang-format on
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -64,6 +64,7 @@ class ComputedImpl extends ReactiveNode {
          * state can be resolved without recomputing the value.
          */
         this.stale = true;
+        this.consumerAllowSignalWrites = false;
     }
     onConsumerDependencyMayHaveChanged() {
         if (this.stale) {
@@ -136,4 +137,4 @@ class ComputedImpl extends ReactiveNode {
         return this.value;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computed.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/signals/src/computed.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {createSignalFromFunction, defaultEquals, Signal, ValueEqualityFn} from './api';\nimport {ReactiveNode, setActiveConsumer} 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/**\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 = new ComputedImpl(computation, options?.equal ?? defaultEquals);\n\n  // Casting here is required for g3, as TS inference behavior is slightly different between our\n  // version/options and g3's.\n  return createSignalFromFunction(node, node.signal.bind(node)) as unknown as Signal<T>;\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 */\nclass ComputedImpl<T> extends ReactiveNode {\n  constructor(private computation: () => T, private equal: (oldValue: T, newValue: T) => boolean) {\n    super();\n  }\n  /**\n   * Current value of the computation.\n   *\n   * This can also be one of the special values `UNSET`, `COMPUTING`, or `ERRORED`.\n   */\n  private value: T = UNSET;\n\n  /**\n   * If `value` is `ERRORED`, the error caught from the last computation attempt which will\n   * be re-thrown.\n   */\n  private error: unknown = null;\n\n  /**\n   * Flag indicating that the computation is currently stale, meaning that one of the\n   * dependencies has notified of a potential change.\n   *\n   * It's possible that no dependency has _actually_ changed, in which case the `stale`\n   * state can be resolved without recomputing the value.\n   */\n  private stale = true;\n\n  protected override onConsumerDependencyMayHaveChanged(): void {\n    if (this.stale) {\n      // We've already notified consumers that this value has potentially changed.\n      return;\n    }\n\n    // Record that the currently cached value may be stale.\n    this.stale = true;\n\n    // Notify any consumers about the potential change.\n    this.producerMayHaveChanged();\n  }\n\n  protected override onProducerUpdateValueVersion(): void {\n    if (!this.stale) {\n      // The current value and its version are already up to date.\n      return;\n    }\n\n    // The current value is stale. Check whether we need to produce a new one.\n\n    if (this.value !== UNSET && this.value !== COMPUTING &&\n        !this.consumerPollProducersForChange()) {\n      // Even though we were previously notified of a potential dependency update, all of\n      // our dependencies report that they have not actually changed in value, so we can\n      // resolve the stale state without needing to recompute the current value.\n      this.stale = false;\n      return;\n    }\n\n    // The current value is stale, and needs to be recomputed. It still may not change -\n    // that depends on whether the newly computed value is equal to the old.\n    this.recomputeValue();\n  }\n\n  private recomputeValue(): void {\n    if (this.value === COMPUTING) {\n      // Our computation somehow led to a cyclic read of itself.\n      throw new Error('Detected cycle in computations.');\n    }\n\n    const oldValue = this.value;\n    this.value = COMPUTING;\n\n    // As we're re-running the computation, update our dependent tracking version number.\n    this.trackingVersion++;\n    const prevConsumer = setActiveConsumer(this);\n    let newValue: T;\n    try {\n      newValue = this.computation();\n    } catch (err) {\n      newValue = ERRORED;\n      this.error = err;\n    } finally {\n      setActiveConsumer(prevConsumer);\n    }\n\n    this.stale = false;\n\n    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&\n        this.equal(oldValue, newValue)) {\n      // No change to `valueVersion` - old and new values are\n      // semantically equivalent.\n      this.value = oldValue;\n      return;\n    }\n\n    this.value = newValue;\n    this.valueVersion++;\n  }\n\n  signal(): T {\n    // Check if the value needs updating before returning it.\n    this.onProducerUpdateValueVersion();\n\n    // Record that someone looked at this signal.\n    this.producerAccessed();\n\n    if (this.value === ERRORED) {\n      throw this.error;\n    }\n\n    return this.value;\n  }\n}\n"]}
+//# 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,wBAAwB,EAAE,aAAa,EAA0B,MAAM,OAAO,CAAC;AACvF,OAAO,EAAC,YAAY,EAAE,iBAAiB,EAAC,MAAM,SAAS,CAAC;AAexD;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAI,WAAoB,EAAE,OAAkC;IAClF,MAAM,IAAI,GAAG,IAAI,YAAY,CAAC,WAAW,EAAE,OAAO,EAAE,KAAK,IAAI,aAAa,CAAC,CAAC;IAE5E,8FAA8F;IAC9F,4BAA4B;IAC5B,OAAO,wBAAwB,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAyB,CAAC;AACxF,CAAC;AAED;;;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;AAEvC;;;;GAIG;AACH,MAAM,YAAgB,SAAQ,YAAY;IACxC,YAAoB,WAAoB,EAAU,KAA4C;QAC5F,KAAK,EAAE,CAAC;QADU,gBAAW,GAAX,WAAW,CAAS;QAAU,UAAK,GAAL,KAAK,CAAuC;QAG9F;;;;WAIG;QACK,UAAK,GAAM,KAAK,CAAC;QAEzB;;;WAGG;QACK,UAAK,GAAY,IAAI,CAAC;QAE9B;;;;;;WAMG;QACK,UAAK,GAAG,IAAI,CAAC;QAEO,8BAAyB,GAAG,KAAK,CAAC;IAvB9D,CAAC;IAyBkB,kCAAkC;QACnD,IAAI,IAAI,CAAC,KAAK,EAAE;YACd,4EAA4E;YAC5E,OAAO;SACR;QAED,uDAAuD;QACvD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAElB,mDAAmD;QACnD,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAEkB,4BAA4B;QAC7C,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YACf,4DAA4D;YAC5D,OAAO;SACR;QAED,0EAA0E;QAE1E,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS;YAChD,CAAC,IAAI,CAAC,8BAA8B,EAAE,EAAE;YAC1C,mFAAmF;YACnF,kFAAkF;YAClF,0EAA0E;YAC1E,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;YACnB,OAAO;SACR;QAED,oFAAoF;QACpF,wEAAwE;QACxE,IAAI,CAAC,cAAc,EAAE,CAAC;IACxB,CAAC;IAEO,cAAc;QACpB,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,qFAAqF;QACrF,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,MAAM,YAAY,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,QAAW,CAAC;QAChB,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,iBAAiB,CAAC,YAAY,CAAC,CAAC;SACjC;QAED,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,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,YAAY,EAAE,CAAC;IACtB,CAAC;IAED,MAAM;QACJ,yDAAyD;QACzD,IAAI,CAAC,4BAA4B,EAAE,CAAC;QAEpC,6CAA6C;QAC7C,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAExB,IAAI,IAAI,CAAC,KAAK,KAAK,OAAO,EAAE;YAC1B,MAAM,IAAI,CAAC,KAAK,CAAC;SAClB;QAED,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;CACF","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {createSignalFromFunction, defaultEquals, Signal, ValueEqualityFn} from './api';\nimport {ReactiveNode, setActiveConsumer} 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/**\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 = new ComputedImpl(computation, options?.equal ?? defaultEquals);\n\n  // Casting here is required for g3, as TS inference behavior is slightly different between our\n  // version/options and g3's.\n  return createSignalFromFunction(node, node.signal.bind(node)) as unknown as Signal<T>;\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 */\nclass ComputedImpl<T> extends ReactiveNode {\n  constructor(private computation: () => T, private equal: (oldValue: T, newValue: T) => boolean) {\n    super();\n  }\n  /**\n   * Current value of the computation.\n   *\n   * This can also be one of the special values `UNSET`, `COMPUTING`, or `ERRORED`.\n   */\n  private value: T = UNSET;\n\n  /**\n   * If `value` is `ERRORED`, the error caught from the last computation attempt which will\n   * be re-thrown.\n   */\n  private error: unknown = null;\n\n  /**\n   * Flag indicating that the computation is currently stale, meaning that one of the\n   * dependencies has notified of a potential change.\n   *\n   * It's possible that no dependency has _actually_ changed, in which case the `stale`\n   * state can be resolved without recomputing the value.\n   */\n  private stale = true;\n\n  protected override readonly consumerAllowSignalWrites = false;\n\n  protected override onConsumerDependencyMayHaveChanged(): void {\n    if (this.stale) {\n      // We've already notified consumers that this value has potentially changed.\n      return;\n    }\n\n    // Record that the currently cached value may be stale.\n    this.stale = true;\n\n    // Notify any consumers about the potential change.\n    this.producerMayHaveChanged();\n  }\n\n  protected override onProducerUpdateValueVersion(): void {\n    if (!this.stale) {\n      // The current value and its version are already up to date.\n      return;\n    }\n\n    // The current value is stale. Check whether we need to produce a new one.\n\n    if (this.value !== UNSET && this.value !== COMPUTING &&\n        !this.consumerPollProducersForChange()) {\n      // Even though we were previously notified of a potential dependency update, all of\n      // our dependencies report that they have not actually changed in value, so we can\n      // resolve the stale state without needing to recompute the current value.\n      this.stale = false;\n      return;\n    }\n\n    // The current value is stale, and needs to be recomputed. It still may not change -\n    // that depends on whether the newly computed value is equal to the old.\n    this.recomputeValue();\n  }\n\n  private recomputeValue(): void {\n    if (this.value === COMPUTING) {\n      // Our computation somehow led to a cyclic read of itself.\n      throw new Error('Detected cycle in computations.');\n    }\n\n    const oldValue = this.value;\n    this.value = COMPUTING;\n\n    // As we're re-running the computation, update our dependent tracking version number.\n    this.trackingVersion++;\n    const prevConsumer = setActiveConsumer(this);\n    let newValue: T;\n    try {\n      newValue = this.computation();\n    } catch (err) {\n      newValue = ERRORED;\n      this.error = err;\n    } finally {\n      setActiveConsumer(prevConsumer);\n    }\n\n    this.stale = false;\n\n    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&\n        this.equal(oldValue, newValue)) {\n      // No change to `valueVersion` - old and new values are\n      // semantically equivalent.\n      this.value = oldValue;\n      return;\n    }\n\n    this.value = newValue;\n    this.valueVersion++;\n  }\n\n  signal(): T {\n    // Check if the value needs updating before returning it.\n    this.onProducerUpdateValueVersion();\n\n    // Record that someone looked at this signal.\n    this.producerAccessed();\n\n    if (this.value === ERRORED) {\n      throw this.error;\n    }\n\n    return this.value;\n  }\n}\n"]}

package/esm2022/src/signals/src/errors.mjs

@@ -0,0 +1,18 @@
+/**
+ * @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
+ */
+function defaultThrowError() {
+    throw new Error();
+}
+let throwInvalidWriteToSignalErrorFn = defaultThrowError;
+export function throwInvalidWriteToSignalError() {
+    throwInvalidWriteToSignalErrorFn();
+}
+export function setThrowInvalidWriteToSignalError(fn) {
+    throwInvalidWriteToSignalErrorFn = fn;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvc2lnbmFscy9zcmMvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILFNBQVMsaUJBQWlCO0lBQ3hCLE1BQU0sSUFBSSxLQUFLLEVBQUUsQ0FBQztBQUNwQixDQUFDO0FBRUQsSUFBSSxnQ0FBZ0MsR0FBRyxpQkFBaUIsQ0FBQztBQUV6RCxNQUFNLFVBQVUsOEJBQThCO0lBQzVDLGdDQUFnQyxFQUFFLENBQUM7QUFDckMsQ0FBQztBQUVELE1BQU0sVUFBVSxpQ0FBaUMsQ0FBQyxFQUFlO0lBQy9ELGdDQUFnQyxHQUFHLEVBQUUsQ0FBQztBQUN4QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmZ1bmN0aW9uIGRlZmF1bHRUaHJvd0Vycm9yKCk6IG5ldmVyIHtcbiAgdGhyb3cgbmV3IEVycm9yKCk7XG59XG5cbmxldCB0aHJvd0ludmFsaWRXcml0ZVRvU2lnbmFsRXJyb3JGbiA9IGRlZmF1bHRUaHJvd0Vycm9yO1xuXG5leHBvcnQgZnVuY3Rpb24gdGhyb3dJbnZhbGlkV3JpdGVUb1NpZ25hbEVycm9yKCkge1xuICB0aHJvd0ludmFsaWRXcml0ZVRvU2lnbmFsRXJyb3JGbigpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gc2V0VGhyb3dJbnZhbGlkV3JpdGVUb1NpZ25hbEVycm9yKGZuOiAoKSA9PiBuZXZlcik6IHZvaWQge1xuICB0aHJvd0ludmFsaWRXcml0ZVRvU2lnbmFsRXJyb3JGbiA9IGZuO1xufVxuIl19

package/esm2022/src/signals/src/graph.mjs

@@ -5,6 +5,9 @@
  * 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
  */
+// Required as the signals library is in a separate package, so we need to explicitly ensure the
+// global `ngDevMode` type is defined.
+import '../../util/ng_dev_mode';
 import { newWeakRef } from './weak_ref';
 /**
  * Counter tracking the next `ProducerId` or `ConsumerId`.
@@ -15,6 +18,10 @@ let _nextReactiveId = 0;
  * consumer).
  */
 let activeConsumer = null;
+/**
+ * Whether the graph is currently propagating change notifications.
+ */
+let inNotificationPhase = false;
 export function setActiveConsumer(consumer) {
     const prev = activeConsumer;
     activeConsumer = consumer;
@@ -105,20 +112,33 @@ export class ReactiveNode {
      * Notify all consumers of this producer that its value may have changed.
      */
     producerMayHaveChanged() {
-        for (const [consumerId, edge] of this.consumers) {
-            const consumer = edge.consumerNode.deref();
-            if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {
-                this.consumers.delete(consumerId);
-                consumer?.producers.delete(this.id);
-                continue;
+        // Prevent signal reads when we're updating the graph
+        const prev = inNotificationPhase;
+        inNotificationPhase = true;
+        try {
+            for (const [consumerId, edge] of this.consumers) {
+                const consumer = edge.consumerNode.deref();
+                if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {
+                    this.consumers.delete(consumerId);
+                    consumer?.producers.delete(this.id);
+                    continue;
+                }
+                consumer.onConsumerDependencyMayHaveChanged();
             }
-            consumer.onConsumerDependencyMayHaveChanged();
+        }
+        finally {
+            inNotificationPhase = prev;
         }
     }
     /**
      * Mark that this producer node has been accessed in the current reactive context.
      */
     producerAccessed() {
+        if (inNotificationPhase) {
+            throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode ?
+                `Assertion error: signal read during notification phase` :
+                '');
+        }
         if (activeConsumer === null) {
             return;
         }
@@ -145,6 +165,13 @@ export class ReactiveNode {
     get hasProducers() {
         return this.producers.size > 0;
     }
+    /**
+     * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
+     * based on the current consumer context.
+     */
+    get producerUpdatesAllowed() {
+        return activeConsumer?.consumerAllowSignalWrites !== false;
+    }
     /**
      * Checks if a `Producer` has a current value which is different than the value
      * last seen at a specific version by a `Consumer` which recorded a dependency on
@@ -162,4 +189,4 @@ export class ReactiveNode {
         return this.valueVersion !== lastSeenValueVersion;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/signals/src/graph.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {newWeakRef, WeakRef} from './weak_ref';\n\n/**\n * Counter tracking the next `ProducerId` or `ConsumerId`.\n */\nlet _nextReactiveId: number = 0;\n\n/**\n * Tracks the currently active reactive consumer (or `null` if there is no active\n * consumer).\n */\nlet activeConsumer: ReactiveNode|null = null;\n\nexport function setActiveConsumer(consumer: ReactiveNode|null): ReactiveNode|null {\n  const prev = activeConsumer;\n  activeConsumer = consumer;\n  return prev;\n}\n\n/**\n * A bidirectional edge in the dependency graph of `ReactiveNode`s.\n */\ninterface ReactiveEdge {\n  /**\n   * Weakly held reference to the consumer side of this edge.\n   */\n  readonly producerNode: WeakRef<ReactiveNode>;\n\n  /**\n   * Weakly held reference to the producer side of this edge.\n   */\n  readonly consumerNode: WeakRef<ReactiveNode>;\n  /**\n   * `trackingVersion` of the consumer at which this dependency edge was last observed.\n   *\n   * If this doesn't match the consumer's current `trackingVersion`, then this dependency record\n   * is stale, and needs to be cleaned up.\n   */\n  atTrackingVersion: number;\n\n  /**\n   * `valueVersion` of the producer at the time this dependency was last accessed.\n   */\n  seenValueVersion: number;\n}\n\n/**\n * A node in the reactive graph.\n *\n * Nodes can be producers of reactive values, consumers of other reactive values, or both.\n *\n * Producers are nodes that produce values, and can be depended upon by consumer nodes.\n *\n * Producers expose a monotonic `valueVersion` counter, and are responsible for incrementing this\n * version when their value semantically changes. Some producers may produce their values lazily and\n * thus at times need to be polled for potential updates to their value (and by extension their\n * `valueVersion`). This is accomplished via the `onProducerUpdateValueVersion` method for\n * implemented by producers, which should perform whatever calculations are necessary to ensure\n * `valueVersion` is up to date.\n *\n * Consumers are nodes that depend on the values of producers and are notified when those values\n * might have changed.\n *\n * Consumers do not wrap the reads they consume themselves, but rather can be set as the active\n * reader via `setActiveConsumer`. Reads of producers that happen while a consumer is active will\n * result in those producers being added as dependencies of that consumer node.\n *\n * The set of dependencies of a consumer is dynamic. Implementers expose a monotonically increasing\n * `trackingVersion` counter, which increments whenever the consumer is about to re-run any reactive\n * reads it needs and establish a new set of dependencies as a result.\n *\n * Producers store the last `trackingVersion` they've seen from `Consumer`s which have read them.\n * This allows a producer to identify whether its record of the dependency is current or stale, by\n * comparing the consumer's `trackingVersion` to the version at which the dependency was\n * last observed.\n */\nexport abstract class ReactiveNode {\n  private readonly id = _nextReactiveId++;\n\n  /**\n   * A cached weak reference to this node, which will be used in `ReactiveEdge`s.\n   */\n  private readonly ref = newWeakRef(this);\n\n  /**\n   * Edges to producers on which this node depends (in its consumer capacity).\n   */\n  private readonly producers = new Map<number, ReactiveEdge>();\n\n  /**\n   * Edges to consumers on which this node depends (in its producer capacity).\n   */\n  private readonly consumers = new Map<number, ReactiveEdge>();\n\n  /**\n   * Monotonically increasing counter representing a version of this `Consumer`'s\n   * dependencies.\n   */\n  protected trackingVersion = 0;\n\n  /**\n   * Monotonically increasing counter which increases when the value of this `Producer`\n   * semantically changes.\n   */\n  protected valueVersion = 0;\n\n  /**\n   * Called for consumers whenever one of their dependencies notifies that it might have a new\n   * value.\n   */\n  protected abstract onConsumerDependencyMayHaveChanged(): void;\n\n  /**\n   * Called for producers when a dependent consumer is checking if the producer's value has actually\n   * changed.\n   */\n  protected abstract onProducerUpdateValueVersion(): void;\n\n  /**\n   * Polls dependencies of a consumer to determine if they have actually changed.\n   *\n   * If this returns `false`, then even though the consumer may have previously been notified of a\n   * change, the values of its dependencies have not actually changed and the consumer should not\n   * rerun any reactions.\n   */\n  protected consumerPollProducersForChange(): boolean {\n    for (const [producerId, edge] of this.producers) {\n      const producer = edge.producerNode.deref();\n\n      if (producer === undefined || edge.atTrackingVersion !== this.trackingVersion) {\n        // This dependency edge is stale, so remove it.\n        this.producers.delete(producerId);\n        producer?.consumers.delete(this.id);\n        continue;\n      }\n\n      if (producer.producerPollStatus(edge.seenValueVersion)) {\n        // One of the dependencies reports a real value change.\n        return true;\n      }\n    }\n\n    // No dependency reported a real value change, so the `Consumer` has also not been\n    // impacted.\n    return false;\n  }\n\n  /**\n   * Notify all consumers of this producer that its value may have changed.\n   */\n  protected producerMayHaveChanged(): void {\n    for (const [consumerId, edge] of this.consumers) {\n      const consumer = edge.consumerNode.deref();\n      if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {\n        this.consumers.delete(consumerId);\n        consumer?.producers.delete(this.id);\n        continue;\n      }\n\n      consumer.onConsumerDependencyMayHaveChanged();\n    }\n  }\n\n  /**\n   * Mark that this producer node has been accessed in the current reactive context.\n   */\n  protected producerAccessed(): void {\n    if (activeConsumer === null) {\n      return;\n    }\n\n    // Either create or update the dependency `Edge` in both directions.\n    let edge = activeConsumer.producers.get(this.id);\n    if (edge === undefined) {\n      edge = {\n        consumerNode: activeConsumer.ref,\n        producerNode: this.ref,\n        seenValueVersion: this.valueVersion,\n        atTrackingVersion: activeConsumer.trackingVersion,\n      };\n      activeConsumer.producers.set(this.id, edge);\n      this.consumers.set(activeConsumer.id, edge);\n    } else {\n      edge.seenValueVersion = this.valueVersion;\n      edge.atTrackingVersion = activeConsumer.trackingVersion;\n    }\n  }\n\n  /**\n   * Whether this consumer currently has any producers registered.\n   */\n  protected get hasProducers(): boolean {\n    return this.producers.size > 0;\n  }\n\n  /**\n   * Checks if a `Producer` has a current value which is different than the value\n   * last seen at a specific version by a `Consumer` which recorded a dependency on\n   * this `Producer`.\n   */\n  private producerPollStatus(lastSeenValueVersion: number): boolean {\n    // `producer.valueVersion` may be stale, but a mismatch still means that the value\n    // last seen by the `Consumer` is also stale.\n    if (this.valueVersion !== lastSeenValueVersion) {\n      return true;\n    }\n\n    // Trigger the `Producer` to update its `valueVersion` if necessary.\n    this.onProducerUpdateValueVersion();\n\n    // At this point, we can trust `producer.valueVersion`.\n    return this.valueVersion !== lastSeenValueVersion;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/signals/src/graph.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// Required as the signals library is in a separate package, so we need to explicitly ensure the\n// global `ngDevMode` type is defined.\nimport '../../util/ng_dev_mode';\n\nimport {throwInvalidWriteToSignalError} from './errors';\nimport {newWeakRef, WeakRef} from './weak_ref';\n\n/**\n * Counter tracking the next `ProducerId` or `ConsumerId`.\n */\nlet _nextReactiveId: number = 0;\n\n/**\n * Tracks the currently active reactive consumer (or `null` if there is no active\n * consumer).\n */\nlet activeConsumer: ReactiveNode|null = null;\n\n/**\n * Whether the graph is currently propagating change notifications.\n */\nlet inNotificationPhase = false;\n\nexport function setActiveConsumer(consumer: ReactiveNode|null): ReactiveNode|null {\n  const prev = activeConsumer;\n  activeConsumer = consumer;\n  return prev;\n}\n\n/**\n * A bidirectional edge in the dependency graph of `ReactiveNode`s.\n */\ninterface ReactiveEdge {\n  /**\n   * Weakly held reference to the consumer side of this edge.\n   */\n  readonly producerNode: WeakRef<ReactiveNode>;\n\n  /**\n   * Weakly held reference to the producer side of this edge.\n   */\n  readonly consumerNode: WeakRef<ReactiveNode>;\n  /**\n   * `trackingVersion` of the consumer at which this dependency edge was last observed.\n   *\n   * If this doesn't match the consumer's current `trackingVersion`, then this dependency record\n   * is stale, and needs to be cleaned up.\n   */\n  atTrackingVersion: number;\n\n  /**\n   * `valueVersion` of the producer at the time this dependency was last accessed.\n   */\n  seenValueVersion: number;\n}\n\n/**\n * A node in the reactive graph.\n *\n * Nodes can be producers of reactive values, consumers of other reactive values, or both.\n *\n * Producers are nodes that produce values, and can be depended upon by consumer nodes.\n *\n * Producers expose a monotonic `valueVersion` counter, and are responsible for incrementing this\n * version when their value semantically changes. Some producers may produce their values lazily and\n * thus at times need to be polled for potential updates to their value (and by extension their\n * `valueVersion`). This is accomplished via the `onProducerUpdateValueVersion` method for\n * implemented by producers, which should perform whatever calculations are necessary to ensure\n * `valueVersion` is up to date.\n *\n * Consumers are nodes that depend on the values of producers and are notified when those values\n * might have changed.\n *\n * Consumers do not wrap the reads they consume themselves, but rather can be set as the active\n * reader via `setActiveConsumer`. Reads of producers that happen while a consumer is active will\n * result in those producers being added as dependencies of that consumer node.\n *\n * The set of dependencies of a consumer is dynamic. Implementers expose a monotonically increasing\n * `trackingVersion` counter, which increments whenever the consumer is about to re-run any reactive\n * reads it needs and establish a new set of dependencies as a result.\n *\n * Producers store the last `trackingVersion` they've seen from `Consumer`s which have read them.\n * This allows a producer to identify whether its record of the dependency is current or stale, by\n * comparing the consumer's `trackingVersion` to the version at which the dependency was\n * last observed.\n */\nexport abstract class ReactiveNode {\n  private readonly id = _nextReactiveId++;\n\n  /**\n   * A cached weak reference to this node, which will be used in `ReactiveEdge`s.\n   */\n  private readonly ref = newWeakRef(this);\n\n  /**\n   * Edges to producers on which this node depends (in its consumer capacity).\n   */\n  private readonly producers = new Map<number, ReactiveEdge>();\n\n  /**\n   * Edges to consumers on which this node depends (in its producer capacity).\n   */\n  private readonly consumers = new Map<number, ReactiveEdge>();\n\n  /**\n   * Monotonically increasing counter representing a version of this `Consumer`'s\n   * dependencies.\n   */\n  protected trackingVersion = 0;\n\n  /**\n   * Monotonically increasing counter which increases when the value of this `Producer`\n   * semantically changes.\n   */\n  protected valueVersion = 0;\n\n  /**\n   * Whether signal writes should be allowed while this `ReactiveNode` is the current consumer.\n   */\n  protected abstract readonly consumerAllowSignalWrites: boolean;\n\n  /**\n   * Called for consumers whenever one of their dependencies notifies that it might have a new\n   * value.\n   */\n  protected abstract onConsumerDependencyMayHaveChanged(): void;\n\n  /**\n   * Called for producers when a dependent consumer is checking if the producer's value has actually\n   * changed.\n   */\n  protected abstract onProducerUpdateValueVersion(): void;\n\n  /**\n   * Polls dependencies of a consumer to determine if they have actually changed.\n   *\n   * If this returns `false`, then even though the consumer may have previously been notified of a\n   * change, the values of its dependencies have not actually changed and the consumer should not\n   * rerun any reactions.\n   */\n  protected consumerPollProducersForChange(): boolean {\n    for (const [producerId, edge] of this.producers) {\n      const producer = edge.producerNode.deref();\n\n      if (producer === undefined || edge.atTrackingVersion !== this.trackingVersion) {\n        // This dependency edge is stale, so remove it.\n        this.producers.delete(producerId);\n        producer?.consumers.delete(this.id);\n        continue;\n      }\n\n      if (producer.producerPollStatus(edge.seenValueVersion)) {\n        // One of the dependencies reports a real value change.\n        return true;\n      }\n    }\n\n    // No dependency reported a real value change, so the `Consumer` has also not been\n    // impacted.\n    return false;\n  }\n\n  /**\n   * Notify all consumers of this producer that its value may have changed.\n   */\n  protected producerMayHaveChanged(): void {\n    // Prevent signal reads when we're updating the graph\n    const prev = inNotificationPhase;\n    inNotificationPhase = true;\n    try {\n      for (const [consumerId, edge] of this.consumers) {\n        const consumer = edge.consumerNode.deref();\n        if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {\n          this.consumers.delete(consumerId);\n          consumer?.producers.delete(this.id);\n          continue;\n        }\n\n        consumer.onConsumerDependencyMayHaveChanged();\n      }\n    } finally {\n      inNotificationPhase = prev;\n    }\n  }\n\n  /**\n   * Mark that this producer node has been accessed in the current reactive context.\n   */\n  protected producerAccessed(): void {\n    if (inNotificationPhase) {\n      throw new Error(\n          typeof ngDevMode !== 'undefined' && ngDevMode ?\n              `Assertion error: signal read during notification phase` :\n              '');\n    }\n\n    if (activeConsumer === null) {\n      return;\n    }\n\n    // Either create or update the dependency `Edge` in both directions.\n    let edge = activeConsumer.producers.get(this.id);\n    if (edge === undefined) {\n      edge = {\n        consumerNode: activeConsumer.ref,\n        producerNode: this.ref,\n        seenValueVersion: this.valueVersion,\n        atTrackingVersion: activeConsumer.trackingVersion,\n      };\n      activeConsumer.producers.set(this.id, edge);\n      this.consumers.set(activeConsumer.id, edge);\n    } else {\n      edge.seenValueVersion = this.valueVersion;\n      edge.atTrackingVersion = activeConsumer.trackingVersion;\n    }\n  }\n\n  /**\n   * Whether this consumer currently has any producers registered.\n   */\n  protected get hasProducers(): boolean {\n    return this.producers.size > 0;\n  }\n\n  /**\n   * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,\n   * based on the current consumer context.\n   */\n  protected get producerUpdatesAllowed(): boolean {\n    return activeConsumer?.consumerAllowSignalWrites !== false;\n  }\n\n  /**\n   * Checks if a `Producer` has a current value which is different than the value\n   * last seen at a specific version by a `Consumer` which recorded a dependency on\n   * this `Producer`.\n   */\n  private producerPollStatus(lastSeenValueVersion: number): boolean {\n    // `producer.valueVersion` may be stale, but a mismatch still means that the value\n    // last seen by the `Consumer` is also stale.\n    if (this.valueVersion !== lastSeenValueVersion) {\n      return true;\n    }\n\n    // Trigger the `Producer` to update its `valueVersion` if necessary.\n    this.onProducerUpdateValueVersion();\n\n    // At this point, we can trust `producer.valueVersion`.\n    return this.valueVersion !== lastSeenValueVersion;\n  }\n}\n"]}