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

package/esm2022/src/render3/reactive_lview_consumer.mjs

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ReactiveNode, setActiveConsumer } from '../signals/src/graph';
+import { assertDefined, assertEqual } from '../util/assert';
+import { markViewDirty } from './instructions/mark_view_dirty';
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
+export class ReactiveLViewConsumer extends ReactiveNode {
+    constructor() {
+        super(...arguments);
+        this._lView = null;
+    }
+    set lView(lView) {
+        NG_DEV_MODE && assertEqual(this._lView, null, 'Consumer already associated with a view.');
+        this._lView = lView;
+    }
+    onConsumerDependencyMayHaveChanged() {
+        NG_DEV_MODE &&
+            assertDefined(this._lView, 'Updating a signal during template or host binding execution is not allowed.');
+        markViewDirty(this._lView);
+    }
+    onProducerUpdateValueVersion() {
+        // This type doesn't implement the producer side of a `ReactiveNode`.
+    }
+    get hasReadASignal() {
+        return this.hasProducers;
+    }
+    runInContext(fn, rf, ctx) {
+        const prevConsumer = setActiveConsumer(this);
+        this.trackingVersion++;
+        try {
+            fn(rf, ctx);
+        }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
+    }
+    destroy() {
+        // Incrementing the version means that every producer which tries to update this consumer will
+        // consider its record stale, and not notify.
+        this.trackingVersion++;
+    }
+}
+let currentConsumer = null;
+function getOrCreateCurrentLViewConsumer() {
+    currentConsumer ??= new ReactiveLViewConsumer();
+    return currentConsumer;
+}
+/**
+ * Create a new template consumer pointing at the specified LView.
+ * Sometimes, a previously created consumer may be reused, in order to save on allocations. In that
+ * case, the LView will be updated.
+ */
+export function getReactiveLViewConsumer(lView, slot) {
+    return lView[slot] ?? getOrCreateCurrentLViewConsumer();
+}
+/**
+ * Assigns the `currentTemplateContext` to its LView's `REACTIVE_CONSUMER` slot if there are tracked
+ * producers.
+ *
+ * The presence of producers means that a signal was read while the consumer was the active
+ * consumer.
+ *
+ * If no producers are present, we do not assign the current template context. This also means we
+ * can just reuse the template context for the next LView.
+ */
+export function commitLViewConsumerIfHasProducers(lView, slot) {
+    const consumer = getOrCreateCurrentLViewConsumer();
+    if (!consumer.hasReadASignal) {
+        return;
+    }
+    lView[slot] = currentConsumer;
+    consumer.lView = lView;
+    currentConsumer = new ReactiveLViewConsumer();
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { assertInInjectionContext } from '../../di/contextual';
+import { Injector } from '../../di/injector';
+import { inject } from '../../di/injector_compatibility';
+import { DestroyRef } from '../../linker/destroy_ref';
+import { Watch } from '../../signals';
+const globalWatches = new Set();
+const queuedWatches = new Map();
+let watchQueuePromise = null;
+/**
+ * Create a global `Effect` for the given reactive function.
+ *
+ * @developerPreview
+ */
+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 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;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWZmZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvcmVuZGVyMy9yZWFjdGl2aXR5L2VmZmVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsd0JBQXdCLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUM3RCxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sbUJBQW1CLENBQUM7QUFDM0MsT0FBTyxFQUFDLE1BQU0sRUFBQyxNQUFNLGlDQUFpQyxDQUFDO0FBQ3ZELE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSwwQkFBMEIsQ0FBQztBQUNwRCxPQUFPLEVBQUMsS0FBSyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBV3BDLE1BQU0sYUFBYSxHQUFHLElBQUksR0FBRyxFQUFTLENBQUM7QUFDdkMsTUFBTSxhQUFhLEdBQUcsSUFBSSxHQUFHLEVBQWUsQ0FBQztBQUU3QyxJQUFJLGlCQUFpQixHQUEwRCxJQUFJLENBQUM7QUFvQ3BGOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsTUFBTSxDQUNsQixRQUFzQyxFQUFFLE9BQTZCO0lBQ3ZFLENBQUMsT0FBTyxFQUFFLFFBQVEsSUFBSSx3QkFBd0IsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUV2RCxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQzFCLE1BQU0sS0FBSyxHQUFHLElBQUksS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBRXRFLE1BQU0sUUFBUSxHQUFHLE9BQU8sRUFBRSxRQUFRLElBQUksTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3ZELE1BQU0sVUFBVSxHQUFHLE9BQU8sRUFBRSxhQUFhLEtBQUssSUFBSSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7SUFFckYsYUFBYSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUV6Qix1QkFBdUI7SUFDdkIsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBRWYsSUFBSSxtQkFBMkMsQ0FBQztJQUVoRCxNQUFNLE9BQU8sR0FBRyxHQUFHLEVBQUU7UUFDbkIsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2hCLG1CQUFtQixFQUFFLEVBQUUsQ0FBQztRQUN4QixhQUFhLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzVCLGFBQWEsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDOUIsQ0FBQyxDQUFDO0lBRUYsbUJBQW1CLEdBQUcsVUFBVSxFQUFFLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUVyRCxPQUFPO1FBQ0wsT0FBTztLQUNSLENBQUM7QUFDSixDQUFDO0FBRUQsU0FBUyxVQUFVLENBQUMsS0FBWSxFQUFFLElBQVU7SUFDMUMsSUFBSSxhQUFhLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsRUFBRTtRQUN6RCxPQUFPO0tBQ1I7SUFFRCxhQUFhLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztJQUUvQixJQUFJLGlCQUFpQixLQUFLLElBQUksRUFBRTtRQUM5QixPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBRXRDLElBQUksU0FBc0IsQ0FBQztRQUMzQixNQUFNLE9BQU8sR0FBRyxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxFQUFFO1lBQzVDLFNBQVMsR0FBRyxPQUFPLENBQUM7UUFDdEIsQ0FBQyxDQUFDLENBQUM7UUFFSCxpQkFBaUIsR0FBRztZQUNsQixPQUFPO1lBQ1AsU0FBUztTQUNWLENBQUM7S0FDSDtBQUNILENBQUM7QUFFRCxTQUFTLGFBQWE7SUFDcEIsS0FBSyxNQUFNLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxJQUFJLGFBQWEsRUFBRTtRQUN6QyxhQUFhLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzVCLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUM7S0FDN0I7SUFFRCxpQkFBa0IsQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUMvQixpQkFBaUIsR0FBRyxJQUFJLENBQUM7QUFDM0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge2Fzc2VydEluSW5qZWN0aW9uQ29udGV4dH0gZnJvbSAnLi4vLi4vZGkvY29udGV4dHVhbCc7XG5pbXBvcnQge0luamVjdG9yfSBmcm9tICcuLi8uLi9kaS9pbmplY3Rvcic7XG5pbXBvcnQge2luamVjdH0gZnJvbSAnLi4vLi4vZGkvaW5qZWN0b3JfY29tcGF0aWJpbGl0eSc7XG5pbXBvcnQge0Rlc3Ryb3lSZWZ9IGZyb20gJy4uLy4uL2xpbmtlci9kZXN0cm95X3JlZic7XG5pbXBvcnQge1dhdGNofSBmcm9tICcuLi8uLi9zaWduYWxzJztcblxuLyoqXG4gKiBBbiBlZmZlY3QgY2FuLCBvcHRpb25hbGx5LCByZXR1cm4gYSBjbGVhbnVwIGZ1bmN0aW9uLiBJZiByZXR1cm5lZCwgdGhlIGNsZWFudXAgaXMgZXhlY3V0ZWQgYmVmb3JlXG4gKiB0aGUgbmV4dCBlZmZlY3QgcnVuLiBUaGUgY2xlYW51cCBmdW5jdGlvbiBtYWtlcyBpdCBwb3NzaWJsZSB0byBcImNhbmNlbFwiIGFueSB3b3JrIHRoYXQgdGhlXG4gKiBwcmV2aW91cyBlZmZlY3QgcnVuIG1pZ2h0IGhhdmUgc3RhcnRlZC5cbiAqXG4gKiBAZGV2ZWxvcGVyUHJldmlld1xuICovXG5leHBvcnQgdHlwZSBFZmZlY3RDbGVhbnVwRm4gPSAoKSA9PiB2b2lkO1xuXG5jb25zdCBnbG9iYWxXYXRjaGVzID0gbmV3IFNldDxXYXRjaD4oKTtcbmNvbnN0IHF1ZXVlZFdhdGNoZXMgPSBuZXcgTWFwPFdhdGNoLCBab25lPigpO1xuXG5sZXQgd2F0Y2hRdWV1ZVByb21pc2U6IHtwcm9taXNlOiBQcm9taXNlPHZvaWQ+OyByZXNvbHZlRm46ICgpID0+IHZvaWQ7fXxudWxsID0gbnVsbDtcblxuLyoqXG4gKiBBIGdsb2JhbCByZWFjdGl2ZSBlZmZlY3QsIHdoaWNoIGNhbiBiZSBtYW51YWxseSBkZXN0cm95ZWQuXG4gKlxuICogQGRldmVsb3BlclByZXZpZXdcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBFZmZlY3RSZWYge1xuICAvKipcbiAgICogU2h1dCBkb3duIHRoZSBlZmZlY3QsIHJlbW92aW5nIGl0IGZyb20gYW55IHVwY29taW5nIHNjaGVkdWxlZCBleGVjdXRpb25zLlxuICAgKi9cbiAgZGVzdHJveSgpOiB2b2lkO1xufVxuXG4vKipcbiAqIE9wdGlvbnMgcGFzc2VkIHRvIHRoZSBgZWZmZWN0YCBmdW5jdGlvbi5cbiAqXG4gKiBAZGV2ZWxvcGVyUHJldmlld1xuICovXG5leHBvcnQgaW50ZXJmYWNlIENyZWF0ZUVmZmVjdE9wdGlvbnMge1xuICAvKipcbiAgICogVGhlIGBJbmplY3RvcmAgaW4gd2hpY2ggdG8gY3JlYXRlIHRoZSBlZmZlY3QuXG4gICAqXG4gICAqIElmIHRoaXMgaXMgbm90IHByb3ZpZGVkLCB0aGUgY3VycmVudCBpbmplY3Rpb24gY29udGV4dCB3aWxsIGJlIHVzZWQgaW5zdGVhZCAodmlhIGBpbmplY3RgKS5cbiAgICovXG4gIGluamVjdG9yPzogSW5qZWN0b3I7XG5cbiAgLyoqXG4gICAqIFdoZXRoZXIgdGhlIGBlZmZlY3RgIHNob3VsZCByZXF1aXJlIG1hbnVhbCBjbGVhbnVwLlxuICAgKlxuICAgKiBJZiB0aGlzIGlzIGBmYWxzZWAgKHRoZSBkZWZhdWx0KSB0aGUgZWZmZWN0IHdpbGwgYXV0b21hdGljYWxseSByZWdpc3RlciBpdHNlbGYgdG8gYmUgY2xlYW5lZCB1cFxuICAgKiB3aXRoIHRoZSBjdXJyZW50IGBEZXN0cm95UmVmYC5cbiAgICovXG4gIG1hbnVhbENsZWFudXA/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIENyZWF0ZSBhIGdsb2JhbCBgRWZmZWN0YCBmb3IgdGhlIGdpdmVuIHJlYWN0aXZlIGZ1bmN0aW9uLlxuICpcbiAqIEBkZXZlbG9wZXJQcmV2aWV3XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBlZmZlY3QoXG4gICAgZWZmZWN0Rm46ICgpID0+IEVmZmVjdENsZWFudXBGbiB8IHZvaWQsIG9wdGlvbnM/OiBDcmVhdGVFZmZlY3RPcHRpb25zKTogRWZmZWN0UmVmIHtcbiAgIW9wdGlvbnM/LmluamVjdG9yICYmIGFzc2VydEluSW5qZWN0aW9uQ29udGV4dChlZmZlY3QpO1xuXG4gIGNvbnN0IHpvbmUgPSBab25lLmN1cnJlbnQ7XG4gIGNvbnN0IHdhdGNoID0gbmV3IFdhdGNoKGVmZmVjdEZuLCAod2F0Y2gpID0+IHF1ZXVlV2F0Y2god2F0Y2gsIHpvbmUpKTtcblxuICBjb25zdCBpbmplY3RvciA9IG9wdGlvbnM/LmluamVjdG9yID8/IGluamVjdChJbmplY3Rvcik7XG4gIGNvbnN0IGRlc3Ryb3lSZWYgPSBvcHRpb25zPy5tYW51YWxDbGVhbnVwICE9PSB0cnVlID8gaW5qZWN0b3IuZ2V0KERlc3Ryb3lSZWYpIDogbnVsbDtcblxuICBnbG9iYWxXYXRjaGVzLmFkZCh3YXRjaCk7XG5cbiAgLy8gRWZmZWN0cyBzdGFydCBkaXJ0eS5cbiAgd2F0Y2gubm90aWZ5KCk7XG5cbiAgbGV0IHVucmVnaXN0ZXJPbkRlc3Ryb3k6ICgoKSA9PiB2b2lkKXx1bmRlZmluZWQ7XG5cbiAgY29uc3QgZGVzdHJveSA9ICgpID0+IHtcbiAgICB3YXRjaC5jbGVhbnVwKCk7XG4gICAgdW5yZWdpc3Rlck9uRGVzdHJveT8uKCk7XG4gICAgcXVldWVkV2F0Y2hlcy5kZWxldGUod2F0Y2gpO1xuICAgIGdsb2JhbFdhdGNoZXMuZGVsZXRlKHdhdGNoKTtcbiAgfTtcblxuICB1bnJlZ2lzdGVyT25EZXN0cm95ID0gZGVzdHJveVJlZj8ub25EZXN0cm95KGRlc3Ryb3kpO1xuXG4gIHJldHVybiB7XG4gICAgZGVzdHJveSxcbiAgfTtcbn1cblxuZnVuY3Rpb24gcXVldWVXYXRjaCh3YXRjaDogV2F0Y2gsIHpvbmU6IFpvbmUpOiB2b2lkIHtcbiAgaWYgKHF1ZXVlZFdhdGNoZXMuaGFzKHdhdGNoKSB8fCAhZ2xvYmFsV2F0Y2hlcy5oYXMod2F0Y2gpKSB7XG4gICAgcmV0dXJuO1xuICB9XG5cbiAgcXVldWVkV2F0Y2hlcy5zZXQod2F0Y2gsIHpvbmUpO1xuXG4gIGlmICh3YXRjaFF1ZXVlUHJvbWlzZSA9PT0gbnVsbCkge1xuICAgIFByb21pc2UucmVzb2x2ZSgpLnRoZW4ocnVuV2F0Y2hRdWV1ZSk7XG5cbiAgICBsZXQgcmVzb2x2ZUZuITogKCkgPT4gdm9pZDtcbiAgICBjb25zdCBwcm9taXNlID0gbmV3IFByb21pc2U8dm9pZD4oKHJlc29sdmUpID0+IHtcbiAgICAgIHJlc29sdmVGbiA9IHJlc29sdmU7XG4gICAgfSk7XG5cbiAgICB3YXRjaFF1ZXVlUHJvbWlzZSA9IHtcbiAgICAgIHByb21pc2UsXG4gICAgICByZXNvbHZlRm4sXG4gICAgfTtcbiAgfVxufVxuXG5mdW5jdGlvbiBydW5XYXRjaFF1ZXVlKCk6IHZvaWQge1xuICBmb3IgKGNvbnN0IFt3YXRjaCwgem9uZV0gb2YgcXVldWVkV2F0Y2hlcykge1xuICAgIHF1ZXVlZFdhdGNoZXMuZGVsZXRlKHdhdGNoKTtcbiAgICB6b25lLnJ1bigoKSA9PiB3YXRjaC5ydW4oKSk7XG4gIH1cblxuICB3YXRjaFF1ZXVlUHJvbWlzZSEucmVzb2x2ZUZuKCk7XG4gIHdhdGNoUXVldWVQcm9taXNlID0gbnVsbDtcbn1cbiJdfQ==

package/{esm2020 → esm2022}/src/render3/util/change_detection_utils.mjs

@@ -8,7 +8,7 @@
 import { assertDefined } from '../../util/assert';
 import { getComponentViewByInstance } from '../context_discovery';
 import { detectChanges } from '../instructions/change_detection';
-import { markViewDirty } from '../instructions/shared';
+import { markViewDirty } from '../instructions/mark_view_dirty';
 import { getRootComponents } from './discovery_utils';
 /**
  * Marks a component for check (in case of OnPush components) and synchronously
@@ -24,4 +24,4 @@ export function applyChanges(component) {
     markViewDirty(getComponentViewByInstance(component));
     getRootComponents(component).forEach(rootComponent => detectChanges(rootComponent));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbmdlX2RldGVjdGlvbl91dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL3JlbmRlcjMvdXRpbC9jaGFuZ2VfZGV0ZWN0aW9uX3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxtQkFBbUIsQ0FBQztBQUNoRCxPQUFPLEVBQUMsMEJBQTBCLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUNoRSxPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0sa0NBQWtDLENBQUM7QUFDL0QsT0FBTyxFQUFDLGFBQWEsRUFBQyxNQUFNLGlDQUFpQyxDQUFDO0FBRTlELE9BQU8sRUFBQyxpQkFBaUIsRUFBQyxNQUFNLG1CQUFtQixDQUFDO0FBRXBEOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBQyxTQUFhO0lBQ3hDLFNBQVMsSUFBSSxhQUFhLENBQUMsU0FBUyxFQUFFLFdBQVcsQ0FBQyxDQUFDO0lBQ25ELGFBQWEsQ0FBQywwQkFBMEIsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDO0lBQ3JELGlCQUFpQixDQUFDLFNBQVMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDO0FBQ3RGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHthc3NlcnREZWZpbmVkfSBmcm9tICcuLi8uLi91dGlsL2Fzc2VydCc7XG5pbXBvcnQge2dldENvbXBvbmVudFZpZXdCeUluc3RhbmNlfSBmcm9tICcuLi9jb250ZXh0X2Rpc2NvdmVyeSc7XG5pbXBvcnQge2RldGVjdENoYW5nZXN9IGZyb20gJy4uL2luc3RydWN0aW9ucy9jaGFuZ2VfZGV0ZWN0aW9uJztcbmltcG9ydCB7bWFya1ZpZXdEaXJ0eX0gZnJvbSAnLi4vaW5zdHJ1Y3Rpb25zL21hcmtfdmlld19kaXJ0eSc7XG5cbmltcG9ydCB7Z2V0Um9vdENvbXBvbmVudHN9IGZyb20gJy4vZGlzY292ZXJ5X3V0aWxzJztcblxuLyoqXG4gKiBNYXJrcyBhIGNvbXBvbmVudCBmb3IgY2hlY2sgKGluIGNhc2Ugb2YgT25QdXNoIGNvbXBvbmVudHMpIGFuZCBzeW5jaHJvbm91c2x5XG4gKiBwZXJmb3JtcyBjaGFuZ2UgZGV0ZWN0aW9uIG9uIHRoZSBhcHBsaWNhdGlvbiB0aGlzIGNvbXBvbmVudCBiZWxvbmdzIHRvLlxuICpcbiAqIEBwYXJhbSBjb21wb25lbnQgQ29tcG9uZW50IHRvIHtAbGluayBDaGFuZ2VEZXRlY3RvclJlZiNtYXJrRm9yQ2hlY2sgbWFyayBmb3IgY2hlY2t9LlxuICpcbiAqIEBwdWJsaWNBcGlcbiAqIEBnbG9iYWxBcGkgbmdcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGFwcGx5Q2hhbmdlcyhjb21wb25lbnQ6IHt9KTogdm9pZCB7XG4gIG5nRGV2TW9kZSAmJiBhc3NlcnREZWZpbmVkKGNvbXBvbmVudCwgJ2NvbXBvbmVudCcpO1xuICBtYXJrVmlld0RpcnR5KGdldENvbXBvbmVudFZpZXdCeUluc3RhbmNlKGNvbXBvbmVudCkpO1xuICBnZXRSb290Q29tcG9uZW50cyhjb21wb25lbnQpLmZvckVhY2gocm9vdENvbXBvbmVudCA9PiBkZXRlY3RDaGFuZ2VzKHJvb3RDb21wb25lbnQpKTtcbn1cbiJdfQ==

package/esm2022/src/render3/view_ref.mjs

@@ -0,0 +1,307 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { RuntimeError } from '../errors';
+import { removeFromArray } from '../util/array_utils';
+import { assertEqual } from '../util/assert';
+import { collectNativeNodes } from './collect_native_nodes';
+import { markViewDirty } from './instructions/mark_view_dirty';
+import { checkNoChangesInternal, detectChangesInternal } from './instructions/shared';
+import { CONTAINER_HEADER_OFFSET, VIEW_REFS } from './interfaces/container';
+import { isLContainer } from './interfaces/type_checks';
+import { CONTEXT, FLAGS, PARENT, TVIEW } from './interfaces/view';
+import { destroyLView, detachView, renderDetachView } from './node_manipulation';
+import { storeLViewOnDestroy } from './util/view_utils';
+export class ViewRef {
+    get rootNodes() {
+        const lView = this._lView;
+        const tView = lView[TVIEW];
+        return collectNativeNodes(tView, lView, tView.firstChild, []);
+    }
+    constructor(
+    /**
+     * This represents `LView` associated with the component when ViewRef is a ChangeDetectorRef.
+     *
+     * When ViewRef is created for a dynamic component, this also represents the `LView` for the
+     * component.
+     *
+     * For a "regular" ViewRef created for an embedded view, this is the `LView` for the embedded
+     * view.
+     *
+     * @internal
+     */
+    _lView, 
+    /**
+     * This represents the `LView` associated with the point where `ChangeDetectorRef` was
+     * requested.
+     *
+     * This may be different from `_lView` if the `_cdRefInjectingView` is an embedded view.
+     */
+    _cdRefInjectingView) {
+        this._lView = _lView;
+        this._cdRefInjectingView = _cdRefInjectingView;
+        this._appRef = null;
+        this._attachedToViewContainer = false;
+    }
+    get context() {
+        return this._lView[CONTEXT];
+    }
+    set context(value) {
+        this._lView[CONTEXT] = value;
+    }
+    get destroyed() {
+        return (this._lView[FLAGS] & 128 /* LViewFlags.Destroyed */) === 128 /* LViewFlags.Destroyed */;
+    }
+    destroy() {
+        if (this._appRef) {
+            this._appRef.detachView(this);
+        }
+        else if (this._attachedToViewContainer) {
+            const parent = this._lView[PARENT];
+            if (isLContainer(parent)) {
+                const viewRefs = parent[VIEW_REFS];
+                const index = viewRefs ? viewRefs.indexOf(this) : -1;
+                if (index > -1) {
+                    ngDevMode &&
+                        assertEqual(index, parent.indexOf(this._lView) - CONTAINER_HEADER_OFFSET, 'An attached view should be in the same position within its container as its ViewRef in the VIEW_REFS array.');
+                    detachView(parent, index);
+                    removeFromArray(viewRefs, index);
+                }
+            }
+            this._attachedToViewContainer = false;
+        }
+        destroyLView(this._lView[TVIEW], this._lView);
+    }
+    onDestroy(callback) {
+        storeLViewOnDestroy(this._lView, callback);
+    }
+    /**
+     * Marks a view and all of its ancestors dirty.
+     *
+     * This can be used to ensure an {@link ChangeDetectionStrategy#OnPush OnPush} component is
+     * checked when it needs to be re-rendered but the two normal triggers haven't marked it
+     * dirty (i.e. inputs haven't changed and events haven't fired in the view).
+     *
+     * <!-- TODO: Add a link to a chapter on OnPush components -->
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```typescript
+     * @Component({
+     *   selector: 'app-root',
+     *   template: `Number of ticks: {{numberOfTicks}}`
+     *   changeDetection: ChangeDetectionStrategy.OnPush,
+     * })
+     * class AppComponent {
+     *   numberOfTicks = 0;
+     *
+     *   constructor(private ref: ChangeDetectorRef) {
+     *     setInterval(() => {
+     *       this.numberOfTicks++;
+     *       // the following is required, otherwise the view will not be updated
+     *       this.ref.markForCheck();
+     *     }, 1000);
+     *   }
+     * }
+     * ```
+     */
+    markForCheck() {
+        markViewDirty(this._cdRefInjectingView || this._lView);
+    }
+    /**
+     * Detaches the view from the change detection tree.
+     *
+     * Detached views will not be checked during change detection runs until they are
+     * re-attached, even if they are dirty. `detach` can be used in combination with
+     * {@link ChangeDetectorRef#detectChanges detectChanges} to implement local change
+     * detection checks.
+     *
+     * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
+     * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * The following example defines a component with a large list of readonly data.
+     * Imagine the data changes constantly, many times per second. For performance reasons,
+     * we want to check and update the list every five seconds. We can do that by detaching
+     * the component's change detector and doing a local check every five seconds.
+     *
+     * ```typescript
+     * class DataProvider {
+     *   // in a real application the returned data will be different every time
+     *   get data() {
+     *     return [1,2,3,4,5];
+     *   }
+     * }
+     *
+     * @Component({
+     *   selector: 'giant-list',
+     *   template: `
+     *     <li *ngFor="let d of dataProvider.data">Data {{d}}</li>
+     *   `,
+     * })
+     * class GiantList {
+     *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {
+     *     ref.detach();
+     *     setInterval(() => {
+     *       this.ref.detectChanges();
+     *     }, 5000);
+     *   }
+     * }
+     *
+     * @Component({
+     *   selector: 'app',
+     *   providers: [DataProvider],
+     *   template: `
+     *     <giant-list><giant-list>
+     *   `,
+     * })
+     * class App {
+     * }
+     * ```
+     */
+    detach() {
+        this._lView[FLAGS] &= ~64 /* LViewFlags.Attached */;
+    }
+    /**
+     * Re-attaches a view to the change detection tree.
+     *
+     * This can be used to re-attach views that were previously detached from the tree
+     * using {@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.
+     *
+     * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * The following example creates a component displaying `live` data. The component will detach
+     * its change detector from the main change detector tree when the component's live property
+     * is set to false.
+     *
+     * ```typescript
+     * class DataProvider {
+     *   data = 1;
+     *
+     *   constructor() {
+     *     setInterval(() => {
+     *       this.data = this.data * 2;
+     *     }, 500);
+     *   }
+     * }
+     *
+     * @Component({
+     *   selector: 'live-data',
+     *   inputs: ['live'],
+     *   template: 'Data: {{dataProvider.data}}'
+     * })
+     * class LiveData {
+     *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}
+     *
+     *   set live(value) {
+     *     if (value) {
+     *       this.ref.reattach();
+     *     } else {
+     *       this.ref.detach();
+     *     }
+     *   }
+     * }
+     *
+     * @Component({
+     *   selector: 'app-root',
+     *   providers: [DataProvider],
+     *   template: `
+     *     Live Update: <input type="checkbox" [(ngModel)]="live">
+     *     <live-data [live]="live"><live-data>
+     *   `,
+     * })
+     * class AppComponent {
+     *   live = true;
+     * }
+     * ```
+     */
+    reattach() {
+        this._lView[FLAGS] |= 64 /* LViewFlags.Attached */;
+    }
+    /**
+     * Checks the view and its children.
+     *
+     * This can also be used in combination with {@link ChangeDetectorRef#detach detach} to implement
+     * local change detection checks.
+     *
+     * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
+     * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * The following example defines a component with a large list of readonly data.
+     * Imagine, the data changes constantly, many times per second. For performance reasons,
+     * we want to check and update the list every five seconds.
+     *
+     * We can do that by detaching the component's change detector and doing a local change detection
+     * check every five seconds.
+     *
+     * See {@link ChangeDetectorRef#detach detach} for more information.
+     */
+    detectChanges() {
+        detectChangesInternal(this._lView[TVIEW], this._lView, this.context);
+    }
+    /**
+     * Checks the change detector and its children, and throws if any changes are detected.
+     *
+     * This is used in development mode to verify that running change detection doesn't
+     * introduce other changes.
+     */
+    checkNoChanges() {
+        if (ngDevMode) {
+            checkNoChangesInternal(this._lView[TVIEW], this._lView, this.context);
+        }
+    }
+    attachToViewContainerRef() {
+        if (this._appRef) {
+            throw new RuntimeError(902 /* RuntimeErrorCode.VIEW_ALREADY_ATTACHED */, ngDevMode && 'This view is already attached directly to the ApplicationRef!');
+        }
+        this._attachedToViewContainer = true;
+    }
+    detachFromAppRef() {
+        this._appRef = null;
+        renderDetachView(this._lView[TVIEW], this._lView);
+    }
+    attachToAppRef(appRef) {
+        if (this._attachedToViewContainer) {
+            throw new RuntimeError(902 /* RuntimeErrorCode.VIEW_ALREADY_ATTACHED */, ngDevMode && 'This view is already attached to a ViewContainer!');
+        }
+        this._appRef = appRef;
+    }
+}
+/** @internal */
+export class RootViewRef extends ViewRef {
+    constructor(_view) {
+        super(_view);
+        this._view = _view;
+    }
+    detectChanges() {
+        const lView = this._view;
+        const tView = lView[TVIEW];
+        const context = lView[CONTEXT];
+        detectChangesInternal(tView, lView, context, false);
+    }
+    checkNoChanges() {
+        if (ngDevMode) {
+            const lView = this._view;
+            const tView = lView[TVIEW];
+            const context = lView[CONTEXT];
+            checkNoChangesInternal(tView, lView, context, false);
+        }
+    }
+    get context() {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view_ref.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/view_ref.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ChangeDetectorRef} from '../change_detection/change_detector_ref';\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {EmbeddedViewRef, InternalViewRef, ViewRefTracker} from '../linker/view_ref';\nimport {removeFromArray} from '../util/array_utils';\nimport {assertEqual} from '../util/assert';\n\nimport {collectNativeNodes} from './collect_native_nodes';\nimport {markViewDirty} from './instructions/mark_view_dirty';\nimport {checkNoChangesInternal, detectChangesInternal} from './instructions/shared';\nimport {CONTAINER_HEADER_OFFSET, VIEW_REFS} from './interfaces/container';\nimport {isLContainer} from './interfaces/type_checks';\nimport {CONTEXT, FLAGS, LView, LViewFlags, PARENT, TVIEW} from './interfaces/view';\nimport {destroyLView, detachView, renderDetachView} from './node_manipulation';\nimport {storeLViewOnDestroy} from './util/view_utils';\n\n\n// Needed due to tsickle downleveling where multiple `implements` with classes creates\n// multiple @extends in Closure annotations, which is illegal. This workaround fixes\n// the multiple @extends by making the annotation @implements instead\ninterface ChangeDetectorRefInterface extends ChangeDetectorRef {}\n\nexport class ViewRef<T> implements EmbeddedViewRef<T>, InternalViewRef, ChangeDetectorRefInterface {\n  private _appRef: ViewRefTracker|null = null;\n  private _attachedToViewContainer = false;\n\n  get rootNodes(): any[] {\n    const lView = this._lView;\n    const tView = lView[TVIEW];\n    return collectNativeNodes(tView, lView, tView.firstChild, []);\n  }\n\n  constructor(\n      /**\n       * This represents `LView` associated with the component when ViewRef is a ChangeDetectorRef.\n       *\n       * When ViewRef is created for a dynamic component, this also represents the `LView` for the\n       * component.\n       *\n       * For a \"regular\" ViewRef created for an embedded view, this is the `LView` for the embedded\n       * view.\n       *\n       * @internal\n       */\n      public _lView: LView,\n\n      /**\n       * This represents the `LView` associated with the point where `ChangeDetectorRef` was\n       * requested.\n       *\n       * This may be different from `_lView` if the `_cdRefInjectingView` is an embedded view.\n       */\n      private _cdRefInjectingView?: LView) {}\n\n  get context(): T {\n    return this._lView[CONTEXT] as unknown as T;\n  }\n\n  set context(value: T) {\n    this._lView[CONTEXT] = value as unknown as {};\n  }\n\n  get destroyed(): boolean {\n    return (this._lView[FLAGS] & LViewFlags.Destroyed) === LViewFlags.Destroyed;\n  }\n\n  destroy(): void {\n    if (this._appRef) {\n      this._appRef.detachView(this);\n    } else if (this._attachedToViewContainer) {\n      const parent = this._lView[PARENT];\n      if (isLContainer(parent)) {\n        const viewRefs = parent[VIEW_REFS] as ViewRef<unknown>[] | null;\n        const index = viewRefs ? viewRefs.indexOf(this) : -1;\n        if (index > -1) {\n          ngDevMode &&\n              assertEqual(\n                  index, parent.indexOf(this._lView) - CONTAINER_HEADER_OFFSET,\n                  'An attached view should be in the same position within its container as its ViewRef in the VIEW_REFS array.');\n          detachView(parent, index);\n          removeFromArray(viewRefs!, index);\n        }\n      }\n      this._attachedToViewContainer = false;\n    }\n    destroyLView(this._lView[TVIEW], this._lView);\n  }\n\n  onDestroy(callback: Function) {\n    storeLViewOnDestroy(this._lView, callback as () => void);\n  }\n\n  /**\n   * Marks a view and all of its ancestors dirty.\n   *\n   * This can be used to ensure an {@link ChangeDetectionStrategy#OnPush OnPush} component is\n   * checked when it needs to be re-rendered but the two normal triggers haven't marked it\n   * dirty (i.e. inputs haven't changed and events haven't fired in the view).\n   *\n   * <!-- TODO: Add a link to a chapter on OnPush components -->\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'app-root',\n   *   template: `Number of ticks: {{numberOfTicks}}`\n   *   changeDetection: ChangeDetectionStrategy.OnPush,\n   * })\n   * class AppComponent {\n   *   numberOfTicks = 0;\n   *\n   *   constructor(private ref: ChangeDetectorRef) {\n   *     setInterval(() => {\n   *       this.numberOfTicks++;\n   *       // the following is required, otherwise the view will not be updated\n   *       this.ref.markForCheck();\n   *     }, 1000);\n   *   }\n   * }\n   * ```\n   */\n  markForCheck(): void {\n    markViewDirty(this._cdRefInjectingView || this._lView);\n  }\n\n  /**\n   * Detaches the view from the change detection tree.\n   *\n   * Detached views will not be checked during change detection runs until they are\n   * re-attached, even if they are dirty. `detach` can be used in combination with\n   * {@link ChangeDetectorRef#detectChanges detectChanges} to implement local change\n   * detection checks.\n   *\n   * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n   * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The following example defines a component with a large list of readonly data.\n   * Imagine the data changes constantly, many times per second. For performance reasons,\n   * we want to check and update the list every five seconds. We can do that by detaching\n   * the component's change detector and doing a local check every five seconds.\n   *\n   * ```typescript\n   * class DataProvider {\n   *   // in a real application the returned data will be different every time\n   *   get data() {\n   *     return [1,2,3,4,5];\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'giant-list',\n   *   template: `\n   *     <li *ngFor=\"let d of dataProvider.data\">Data {{d}}</li>\n   *   `,\n   * })\n   * class GiantList {\n   *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {\n   *     ref.detach();\n   *     setInterval(() => {\n   *       this.ref.detectChanges();\n   *     }, 5000);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   providers: [DataProvider],\n   *   template: `\n   *     <giant-list><giant-list>\n   *   `,\n   * })\n   * class App {\n   * }\n   * ```\n   */\n  detach(): void {\n    this._lView[FLAGS] &= ~LViewFlags.Attached;\n  }\n\n  /**\n   * Re-attaches a view to the change detection tree.\n   *\n   * This can be used to re-attach views that were previously detached from the tree\n   * using {@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.\n   *\n   * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The following example creates a component displaying `live` data. The component will detach\n   * its change detector from the main change detector tree when the component's live property\n   * is set to false.\n   *\n   * ```typescript\n   * class DataProvider {\n   *   data = 1;\n   *\n   *   constructor() {\n   *     setInterval(() => {\n   *       this.data = this.data * 2;\n   *     }, 500);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'live-data',\n   *   inputs: ['live'],\n   *   template: 'Data: {{dataProvider.data}}'\n   * })\n   * class LiveData {\n   *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}\n   *\n   *   set live(value) {\n   *     if (value) {\n   *       this.ref.reattach();\n   *     } else {\n   *       this.ref.detach();\n   *     }\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app-root',\n   *   providers: [DataProvider],\n   *   template: `\n   *     Live Update: <input type=\"checkbox\" [(ngModel)]=\"live\">\n   *     <live-data [live]=\"live\"><live-data>\n   *   `,\n   * })\n   * class AppComponent {\n   *   live = true;\n   * }\n   * ```\n   */\n  reattach(): void {\n    this._lView[FLAGS] |= LViewFlags.Attached;\n  }\n\n  /**\n   * Checks the view and its children.\n   *\n   * This can also be used in combination with {@link ChangeDetectorRef#detach detach} to implement\n   * local change detection checks.\n   *\n   * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n   * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The following example defines a component with a large list of readonly data.\n   * Imagine, the data changes constantly, many times per second. For performance reasons,\n   * we want to check and update the list every five seconds.\n   *\n   * We can do that by detaching the component's change detector and doing a local change detection\n   * check every five seconds.\n   *\n   * See {@link ChangeDetectorRef#detach detach} for more information.\n   */\n  detectChanges(): void {\n    detectChangesInternal(this._lView[TVIEW], this._lView, this.context as unknown as {});\n  }\n\n  /**\n   * Checks the change detector and its children, and throws if any changes are detected.\n   *\n   * This is used in development mode to verify that running change detection doesn't\n   * introduce other changes.\n   */\n  checkNoChanges(): void {\n    if (ngDevMode) {\n      checkNoChangesInternal(this._lView[TVIEW], this._lView, this.context as unknown as {});\n    }\n  }\n\n  attachToViewContainerRef() {\n    if (this._appRef) {\n      throw new RuntimeError(\n          RuntimeErrorCode.VIEW_ALREADY_ATTACHED,\n          ngDevMode && 'This view is already attached directly to the ApplicationRef!');\n    }\n    this._attachedToViewContainer = true;\n  }\n\n  detachFromAppRef() {\n    this._appRef = null;\n    renderDetachView(this._lView[TVIEW], this._lView);\n  }\n\n  attachToAppRef(appRef: ViewRefTracker) {\n    if (this._attachedToViewContainer) {\n      throw new RuntimeError(\n          RuntimeErrorCode.VIEW_ALREADY_ATTACHED,\n          ngDevMode && 'This view is already attached to a ViewContainer!');\n    }\n    this._appRef = appRef;\n  }\n}\n\n/** @internal */\nexport class RootViewRef<T> extends ViewRef<T> {\n  constructor(public _view: LView) {\n    super(_view);\n  }\n\n  override detectChanges(): void {\n    const lView = this._view;\n    const tView = lView[TVIEW];\n    const context = lView[CONTEXT];\n    detectChangesInternal(tView, lView, context, false);\n  }\n\n  override checkNoChanges(): void {\n    if (ngDevMode) {\n      const lView = this._view;\n      const tView = lView[TVIEW];\n      const context = lView[CONTEXT];\n      checkNoChangesInternal(tView, lView, context, false);\n    }\n  }\n\n  override get context(): T {\n    return null!;\n  }\n}\n"]}

package/{esm2020 → esm2022}/src/sanitization/sanitizer.mjs

@@ -12,12 +12,12 @@ import { ɵɵdefineInjectable } from '../di/interface/defs';
  * @publicApi
  */
 class Sanitizer {
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: Sanitizer,
+        providedIn: 'root',
+        factory: () => null,
+    }); }
 }
-/** @nocollapse */
-Sanitizer.ɵprov = ɵɵdefineInjectable({
-    token: Sanitizer,
-    providedIn: 'root',
-    factory: () => null,
-});
 export { Sanitizer };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FuaXRpemVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvc2FuaXRpemF0aW9uL3Nhbml0aXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsa0JBQWtCLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUd4RDs7OztHQUlHO0FBQ0gsTUFBc0IsU0FBUzs7QUFFN0Isa0JBQWtCO0FBQ1gsZUFBSyxHQUE2QixrQkFBa0IsQ0FBQztJQUMxRCxLQUFLLEVBQUUsU0FBUztJQUNoQixVQUFVLEVBQUUsTUFBTTtJQUNsQixPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMsSUFBSTtDQUNwQixDQUFDLENBQUM7U0FQaUIsU0FBUyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge8m1ybVkZWZpbmVJbmplY3RhYmxlfSBmcm9tICcuLi9kaS9pbnRlcmZhY2UvZGVmcyc7XG5pbXBvcnQge1NlY3VyaXR5Q29udGV4dH0gZnJvbSAnLi9zZWN1cml0eSc7XG5cbi8qKlxuICogU2FuaXRpemVyIGlzIHVzZWQgYnkgdGhlIHZpZXdzIHRvIHNhbml0aXplIHBvdGVudGlhbGx5IGRhbmdlcm91cyB2YWx1ZXMuXG4gKlxuICogQHB1YmxpY0FwaVxuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgU2FuaXRpemVyIHtcbiAgYWJzdHJhY3Qgc2FuaXRpemUoY29udGV4dDogU2VjdXJpdHlDb250ZXh0LCB2YWx1ZToge318c3RyaW5nfG51bGwpOiBzdHJpbmd8bnVsbDtcbiAgLyoqIEBub2NvbGxhcHNlICovXG4gIHN0YXRpYyDJtXByb3YgPSAvKiogQHB1cmVPckJyZWFrTXlDb2RlICovIMm1ybVkZWZpbmVJbmplY3RhYmxlKHtcbiAgICB0b2tlbjogU2FuaXRpemVyLFxuICAgIHByb3ZpZGVkSW46ICdyb290JyxcbiAgICBmYWN0b3J5OiAoKSA9PiBudWxsLFxuICB9KTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FuaXRpemVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvc2FuaXRpemF0aW9uL3Nhbml0aXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsa0JBQWtCLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUd4RDs7OztHQUlHO0FBQ0gsTUFBc0IsU0FBUztJQUU3QixrQkFBa0I7YUFDWCxVQUFLLEdBQTZCLGtCQUFrQixDQUFDO1FBQzFELEtBQUssRUFBRSxTQUFTO1FBQ2hCLFVBQVUsRUFBRSxNQUFNO1FBQ2xCLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxJQUFJO0tBQ3BCLENBQUMsQ0FBQzs7U0FQaUIsU0FBUyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge8m1ybVkZWZpbmVJbmplY3RhYmxlfSBmcm9tICcuLi9kaS9pbnRlcmZhY2UvZGVmcyc7XG5pbXBvcnQge1NlY3VyaXR5Q29udGV4dH0gZnJvbSAnLi9zZWN1cml0eSc7XG5cbi8qKlxuICogU2FuaXRpemVyIGlzIHVzZWQgYnkgdGhlIHZpZXdzIHRvIHNhbml0aXplIHBvdGVudGlhbGx5IGRhbmdlcm91cyB2YWx1ZXMuXG4gKlxuICogQHB1YmxpY0FwaVxuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgU2FuaXRpemVyIHtcbiAgYWJzdHJhY3Qgc2FuaXRpemUoY29udGV4dDogU2VjdXJpdHlDb250ZXh0LCB2YWx1ZToge318c3RyaW5nfG51bGwpOiBzdHJpbmd8bnVsbDtcbiAgLyoqIEBub2NvbGxhcHNlICovXG4gIHN0YXRpYyDJtXByb3YgPSAvKiogQHB1cmVPckJyZWFrTXlDb2RlICovIMm1ybVkZWZpbmVJbmplY3RhYmxlKHtcbiAgICB0b2tlbjogU2FuaXRpemVyLFxuICAgIHByb3ZpZGVkSW46ICdyb290JyxcbiAgICBmYWN0b3J5OiAoKSA9PiBudWxsLFxuICB9KTtcbn1cbiJdfQ==

package/esm2022/src/signals/index.mjs

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export { isSignal } from './src/api';
+export { computed } from './src/computed';
+export { setActiveConsumer } from './src/graph';
+export { 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

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

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