@angular/core 15.2.0 → 16.0.0-next.0

package/esm2020/src/core.mjs

@@ -32,6 +32,7 @@ export { EventEmitter } from './event_emitter';
 export { ErrorHandler } from './error_handler';
 export * from './core_private_export';
 export * from './core_render3_private_export';
+export * from './core_reactivity_export';
 export { SecurityContext } from './sanitization/security';
 export { Sanitizer } from './sanitization/sanitizer';
 export { createNgModule, createNgModuleRef, createEnvironmentInjector } from './render3/ng_module_ref';
@@ -50,4 +51,4 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
             'For server-side rendering applications add the import to your `main.server.ts` file.)');
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/core_reactivity_export.mjs

@@ -0,0 +1,11 @@
+/**
+ * @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
+ */
+// This file exists to allow the set of reactivity exports to be modified in g3, as these APIs are
+// only "beta" for the time being.
+export * from './core_reactivity_export_internal';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZV9yZWFjdGl2aXR5X2V4cG9ydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL2NvcmVfcmVhY3Rpdml0eV9leHBvcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsa0dBQWtHO0FBQ2xHLGtDQUFrQztBQUVsQyxjQUFjLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8vIFRoaXMgZmlsZSBleGlzdHMgdG8gYWxsb3cgdGhlIHNldCBvZiByZWFjdGl2aXR5IGV4cG9ydHMgdG8gYmUgbW9kaWZpZWQgaW4gZzMsIGFzIHRoZXNlIEFQSXMgYXJlXG4vLyBvbmx5IFwiYmV0YVwiIGZvciB0aGUgdGltZSBiZWluZy5cblxuZXhwb3J0ICogZnJvbSAnLi9jb3JlX3JlYWN0aXZpdHlfZXhwb3J0X2ludGVybmFsJztcbiJdfQ==

package/esm2020/src/core_reactivity_export_internal.mjs

@@ -0,0 +1,9 @@
+/**
+ * @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 { computed, effect, isSignal, signal, untracked } from './signals';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZV9yZWFjdGl2aXR5X2V4cG9ydF9pbnRlcm5hbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL2NvcmVfcmVhY3Rpdml0eV9leHBvcnRfaW50ZXJuYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFFBQVEsRUFBRSxNQUFNLEVBQVUsUUFBUSxFQUEwQixNQUFNLEVBQUUsU0FBUyxFQUFrQixNQUFNLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQge2NvbXB1dGVkLCBlZmZlY3QsIEVmZmVjdCwgaXNTaWduYWwsIFNldHRhYmxlU2lnbmFsLCBTaWduYWwsIHNpZ25hbCwgdW50cmFja2VkLCBWYWx1ZUVxdWFsaXR5Rm59IGZyb20gJy4vc2lnbmFscyc7XG4iXX0=

package/esm2020/src/render/api_flags.mjs

@@ -23,4 +23,4 @@ export var RendererStyleFlags2;
      */
     RendererStyleFlags2[RendererStyleFlags2["DashCase"] = 2] = "DashCase";
 })(RendererStyleFlags2 || (RendererStyleFlags2 = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/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 { effect } from './src/effect';
+export { setActiveConsumer } from './src/graph';
+export { signal } from './src/signal';
+export { untracked } from './src/untracked';
+export { Watch } from './src/watch';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9zaWduYWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxRQUFRLEVBQTBCLE1BQU0sV0FBVyxDQUFDO0FBQzVELE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUN4QyxPQUFPLEVBQUMsTUFBTSxFQUFTLE1BQU0sY0FBYyxDQUFDO0FBQzVDLE9BQU8sRUFBQyxpQkFBaUIsRUFBQyxNQUFNLGFBQWEsQ0FBQztBQUM5QyxPQUFPLEVBQWlCLE1BQU0sRUFBQyxNQUFNLGNBQWMsQ0FBQztBQUNwRCxPQUFPLEVBQUMsU0FBUyxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxFQUFDLEtBQUssRUFBQyxNQUFNLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQge2lzU2lnbmFsLCBTaWduYWwsIFZhbHVlRXF1YWxpdHlGbn0gZnJvbSAnLi9zcmMvYXBpJztcbmV4cG9ydCB7Y29tcHV0ZWR9IGZyb20gJy4vc3JjL2NvbXB1dGVkJztcbmV4cG9ydCB7ZWZmZWN0LCBFZmZlY3R9IGZyb20gJy4vc3JjL2VmZmVjdCc7XG5leHBvcnQge3NldEFjdGl2ZUNvbnN1bWVyfSBmcm9tICcuL3NyYy9ncmFwaCc7XG5leHBvcnQge1NldHRhYmxlU2lnbmFsLCBzaWduYWx9IGZyb20gJy4vc3JjL3NpZ25hbCc7XG5leHBvcnQge3VudHJhY2tlZH0gZnJvbSAnLi9zcmMvdW50cmFja2VkJztcbmV4cG9ydCB7V2F0Y2h9IGZyb20gJy4vc3JjL3dhdGNoJztcbiJdfQ==

package/esm2020/src/signals/src/api.mjs

@@ -0,0 +1,46 @@
+/**
+ * @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] ?? false;
+}
+/**
+ * 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(fn, extraApi = {}) {
+    fn[SIGNAL] = true;
+    // 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);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/signals/src/computed.mjs

@@ -0,0 +1,142 @@
+/**
+ * @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 { createSignalFromFunction, defaultEquals } from './api';
+import { consumerPollValueStatus, nextReactiveId, producerAccessed, producerNotifyConsumers, setActiveConsumer } from './graph';
+import { WeakRef } from './weak_ref';
+/**
+ * Create a computed `Signal` which derives a reactive value from an expression.
+ *
+ * @developerPreview
+ */
+export function computed(computation, equal = defaultEquals) {
+    const node = new ComputedImpl(computation, equal);
+    return createSignalFromFunction(node.signal.bind(node));
+}
+/**
+ * A dedicated symbol used before a computed value has been calculated for the first time.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const UNSET = Symbol('UNSET');
+/**
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * is in progress. Used to detect cycles in computation chains.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const COMPUTING = Symbol('COMPUTING');
+/**
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * failed. The thrown error is cached until the computation gets dirty again.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const ERRORED = Symbol('ERRORED');
+/**
+ * A computation, which derives a value from a declarative reactive expression.
+ *
+ * `Computed`s are both `Producer`s and `Consumer`s of reactivity.
+ */
+class ComputedImpl {
+    constructor(computation, equal) {
+        this.computation = computation;
+        this.equal = equal;
+        /**
+         * Current value of the computation.
+         *
+         * This can also be one of the special values `UNSET`, `COMPUTING`, or `ERRORED`.
+         */
+        this.value = UNSET;
+        /**
+         * If `value` is `ERRORED`, the error caught from the last computation attempt which will
+         * be re-thrown.
+         */
+        this.error = null;
+        /**
+         * Flag indicating that the computation is currently stale, meaning that one of the
+         * dependencies has notified of a potential change.
+         *
+         * It's possible that no dependency has _actually_ changed, in which case the `stale`
+         * state can be resolved without recomputing the value.
+         */
+        this.stale = true;
+        this.id = nextReactiveId();
+        this.ref = new WeakRef(this);
+        this.producers = new Map();
+        this.consumers = new Map();
+        this.trackingVersion = 0;
+        this.valueVersion = 0;
+    }
+    checkForChangedValue() {
+        if (!this.stale) {
+            // The current value and its version are already up to date.
+            return;
+        }
+        // The current value is stale. Check whether we need to produce a new one.
+        if (this.value !== UNSET && this.value !== COMPUTING && !consumerPollValueStatus(this)) {
+            // Even though we were previously notified of a potential dependency update, all of
+            // our dependencies report that they have not actually changed in value, so we can
+            // resolve the stale state without needing to recompute the current value.
+            this.stale = false;
+            return;
+        }
+        // The current value is stale, and needs to be recomputed. It still may not change -
+        // that depends on whether the newly computed value is equal to the old.
+        this.recomputeValue();
+    }
+    recomputeValue() {
+        if (this.value === COMPUTING) {
+            // Our computation somehow led to a cyclic read of itself.
+            throw new Error('Detected cycle in computations.');
+        }
+        const oldValue = this.value;
+        this.value = COMPUTING;
+        // As we're re-running the computation, update our dependent tracking version number.
+        this.trackingVersion++;
+        const prevConsumer = setActiveConsumer(this);
+        let newValue;
+        try {
+            newValue = this.computation();
+        }
+        catch (err) {
+            newValue = ERRORED;
+            this.error = err;
+        }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
+        this.stale = false;
+        if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+            this.equal(oldValue, newValue)) {
+            // No change to `valueVersion` - old and new values are
+            // semantically equivalent.
+            this.value = oldValue;
+            return;
+        }
+        this.value = newValue;
+        this.valueVersion++;
+    }
+    notify() {
+        if (this.stale) {
+            // We've already notified consumers that this value has potentially changed.
+            return;
+        }
+        // Record that the currently cached value may be stale.
+        this.stale = true;
+        // Notify any consumers about the potential change.
+        producerNotifyConsumers(this);
+    }
+    signal() {
+        // Check if the value needs updating before returning it.
+        this.checkForChangedValue();
+        // Record that someone looked at this signal.
+        producerAccessed(this);
+        if (this.value === ERRORED) {
+            throw this.error;
+        }
+        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 {Consumer, ConsumerId, consumerPollValueStatus, Edge, nextReactiveId, Producer, producerAccessed, ProducerId, producerNotifyConsumers, setActiveConsumer} from './graph';\nimport {WeakRef} from './weak_ref';\n\n/**\n * Create a computed `Signal` which derives a reactive value from an expression.\n *\n * @developerPreview\n */\nexport function computed<T>(\n    computation: () => T, equal: ValueEqualityFn<T> = defaultEquals): Signal<T> {\n  const node = new ComputedImpl(computation, equal);\n  return createSignalFromFunction(node.signal.bind(node));\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 `Producer`s and `Consumer`s of reactivity.\n */\nclass ComputedImpl<T> implements Producer, Consumer {\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  readonly id = nextReactiveId();\n  readonly ref = new WeakRef(this);\n  readonly producers = new Map<ProducerId, Edge>();\n  readonly consumers = new Map<ConsumerId, Edge>();\n  trackingVersion = 0;\n  valueVersion = 0;\n\n  constructor(private computation: () => T, private equal: (oldValue: T, newValue: T) => boolean) {}\n\n  checkForChangedValue(): 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 && !consumerPollValueStatus(this)) {\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  notify(): 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    producerNotifyConsumers(this);\n  }\n\n  signal(): T {\n    // Check if the value needs updating before returning it.\n    this.checkForChangedValue();\n\n    // Record that someone looked at this signal.\n    producerAccessed(this);\n\n    if (this.value === ERRORED) {\n      throw this.error;\n    }\n\n    return this.value;\n  }\n}\n"]}

package/esm2020/src/signals/src/effect.mjs

@@ -0,0 +1,69 @@
+/**
+ * @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 { Watch } from './watch';
+/**
+ * Create a global `Effect` for the given reactive function.
+ *
+ * @developerPreview
+ */
+export function effect(effectFn) {
+    const watch = new Watch(effectFn, queueWatch);
+    globalWatches.add(watch);
+    // Effects start dirty.
+    watch.notify();
+    return {
+        consumer: watch,
+        schedule: watch.notify.bind(watch),
+        destroy: () => {
+            queuedWatches.delete(watch);
+            globalWatches.delete(watch);
+        },
+    };
+}
+/**
+ * Get a `Promise` that resolves when any scheduled effects have resolved.
+ */
+export function effectsDone() {
+    return watchQueuePromise?.promise ?? Promise.resolve();
+}
+/**
+ * Shut down all active effects.
+ */
+export function resetEffects() {
+    queuedWatches.clear();
+    globalWatches.clear();
+}
+const globalWatches = new Set();
+const queuedWatches = new Set();
+let watchQueuePromise = null;
+function queueWatch(watch) {
+    if (queuedWatches.has(watch) || !globalWatches.has(watch)) {
+        return;
+    }
+    queuedWatches.add(watch);
+    if (watchQueuePromise === null) {
+        Promise.resolve().then(runWatchQueue);
+        let resolveFn;
+        const promise = new Promise((resolve) => {
+            resolveFn = resolve;
+        });
+        watchQueuePromise = {
+            promise,
+            resolveFn,
+        };
+    }
+}
+function runWatchQueue() {
+    for (const watch of queuedWatches) {
+        queuedWatches.delete(watch);
+        watch.run();
+    }
+    watchQueuePromise.resolveFn();
+    watchQueuePromise = null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/signals/src/graph.mjs

@@ -0,0 +1,114 @@
+/**
+ * @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
+ */
+/**
+ * Tracks the currently active reactive context (or `null` if there is no active
+ * context).
+ */
+let activeConsumer = null;
+/**
+ * Counter tracking the next `ProducerId` or `ConsumerId`.
+ */
+let _nextReactiveId = 0;
+/**
+ * Get a new `ProducerId` or `ConsumerId`, allocated from the global sequence.
+ *
+ * The value returned is a type intersection of both branded types, and thus can be assigned to
+ * either.
+ */
+export function nextReactiveId() {
+    return _nextReactiveId++;
+}
+/**
+ * Set `consumer` as the active reactive context, and return the previous `Consumer`
+ * (if any) for later restoration.
+ */
+export function setActiveConsumer(consumer) {
+    const prevConsumer = activeConsumer;
+    activeConsumer = consumer;
+    return prevConsumer;
+}
+/**
+ * Notify all `Consumer`s of the given `Producer` that its value may have changed.
+ */
+export function producerNotifyConsumers(producer) {
+    for (const [consumerId, edge] of producer.consumers) {
+        const consumer = edge.consumerRef.deref();
+        if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {
+            producer.consumers.delete(consumerId);
+            consumer?.producers.delete(producer.id);
+            continue;
+        }
+        consumer.notify();
+    }
+}
+/**
+ * Record a dependency on the given `Producer` by the current reactive `Consumer` if
+ * one is present.
+ */
+export function producerAccessed(producer) {
+    if (activeConsumer === null) {
+        return;
+    }
+    // Either create or update the dependency `Edge` in both directions.
+    let edge = activeConsumer.producers.get(producer.id);
+    if (edge === undefined) {
+        edge = {
+            consumerRef: activeConsumer.ref,
+            producerRef: producer.ref,
+            seenValueVersion: producer.valueVersion,
+            atTrackingVersion: activeConsumer.trackingVersion,
+        };
+        activeConsumer.producers.set(producer.id, edge);
+        producer.consumers.set(activeConsumer.id, edge);
+    }
+    else {
+        edge.seenValueVersion = producer.valueVersion;
+        edge.atTrackingVersion = activeConsumer.trackingVersion;
+    }
+}
+/**
+ * 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
+ * this `Producer`.
+ */
+function producerPollStatus(producer, lastSeenValueVersion) {
+    // `producer.valueVersion` may be stale, but a mismatch still means that the value
+    // last seen by the `Consumer` is also stale.
+    if (producer.valueVersion !== lastSeenValueVersion) {
+        return true;
+    }
+    // Trigger the `Producer` to update its `valueVersion` if necessary.
+    producer.checkForChangedValue();
+    // At this point, we can trust `producer.valueVersion`.
+    return producer.valueVersion !== lastSeenValueVersion;
+}
+/**
+ * Function called to check the stale status of dependencies (producers) for a given consumer. This
+ * is a verification step before refreshing a given consumer: if none of the the dependencies
+ * reports a semantically new value, then the `Consumer` has not observed a real dependency change
+ * (even though it may have been notified of one).
+ */
+export function consumerPollValueStatus(consumer) {
+    for (const [producerId, edge] of consumer.producers) {
+        const producer = edge.producerRef.deref();
+        if (producer === undefined || edge.atTrackingVersion !== consumer.trackingVersion) {
+            // This dependency edge is stale, so remove it.
+            consumer.producers.delete(producerId);
+            producer?.consumers.delete(consumer.id);
+            continue;
+        }
+        if (producerPollStatus(producer, edge.seenValueVersion)) {
+            // One of the dependencies reports a real value change.
+            return true;
+        }
+    }
+    // No dependency reported a real value change, so the `Consumer` has also not been
+    // impacted.
+    return false;
+}
+//# 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 {WeakRef} from './weak_ref';\n\n/**\n * Identifier for a `Producer`, which is a branded `number`.\n *\n * Note that `ProducerId` and `ConsumerId` are assigned from the same sequence, so the same `number`\n * will never be used for both.\n *\n * Branding provides additional type safety by ensuring that `ProducerId` and `ConsumerId` are\n * mutually unassignable without a cast. Since several `Map`s are keyed by these IDs, this prevents\n * `ProducerId`s from being inadvertently used to look up `Consumer`s or vice versa.\n */\nexport type ProducerId = number&{__producer: true};\n\n/**\n * Identifier for a `Consumer`, which is a branded `number`.\n *\n * Note that `ProducerId` and `ConsumerId` are assigned from the same sequence, so the same `number`\n * will never be used for both.\n *\n * Branding provides additional type safety by ensuring that `ProducerId` and `ConsumerId` are\n * mutually unassignable without a cast. Since several `Map`s are keyed by these IDs, this prevents\n * `ConsumerId`s from being inadvertently used to look up `Producer`s or vice versa.\n */\nexport type ConsumerId = number&{__consumer: true};\n\n/**\n * Tracks the currently active reactive context (or `null` if there is no active\n * context).\n */\nlet activeConsumer: Consumer|null = null;\n\n/**\n * Counter tracking the next `ProducerId` or `ConsumerId`.\n */\nlet _nextReactiveId: number = 0;\n\n/**\n * Get a new `ProducerId` or `ConsumerId`, allocated from the global sequence.\n *\n * The value returned is a type intersection of both branded types, and thus can be assigned to\n * either.\n */\nexport function nextReactiveId(): ProducerId&ConsumerId {\n  return (_nextReactiveId++ as ProducerId & ConsumerId);\n}\n\n/**\n * Set `consumer` as the active reactive context, and return the previous `Consumer`\n * (if any) for later restoration.\n */\nexport function setActiveConsumer(consumer: Consumer|null): Consumer|null {\n  const prevConsumer = activeConsumer;\n  activeConsumer = consumer;\n  return prevConsumer;\n}\n\n/**\n * A bidirectional edge in the producer-consumer dependency graph.\n */\nexport interface Edge {\n  /**\n   * Weakly held reference to the `Consumer` side of this edge.\n   */\n  readonly consumerRef: WeakRef<Consumer>;\n\n  /**\n   * Weakly held reference to the `Producer` side of this edge.\n   */\n  readonly producerRef: WeakRef<Producer>;\n\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   * This is used by `consumerPollValueStatus` to determine whether a `Consumer`'s dependencies have\n   * semantically changed.\n   */\n  seenValueVersion: number;\n}\n\n/**\n * Represents a value that can be read reactively, and can notify readers (`Consumer`s)\n * when it changes.\n *\n * Producers maintain a weak reference to any `Consumer`s which may depend on the\n * producer's value.\n *\n * Implementers of `Producer` expose a monotonic `valueVersion` counter, and are responsible\n * for incrementing this version when their value semantically changes. Some Producers may\n * produce this value lazily and thus at times need to be polled for potential updates to\n * their value (and by extension their `valueVersion`). This is accomplished via the\n * `checkForChangedValue` method for Producers, which should perform whatever calculations\n * are necessary to ensure `valueVersion` is up to date.\n *\n * `Producer`s support two operations:\n *   * `producerNotifyConsumers`\n *   * `producerAccessed`\n */\nexport interface Producer {\n  /**\n   * Numeric identifier of this `Producer`.\n   *\n   * May also be used to satisfy the interface for `Consumer`.\n   */\n  readonly id: ProducerId;\n\n  /**\n   * A `WeakRef` to this `Producer` instance.\n   *\n   * An implementer provides this as a cached value to avoid the need to instantiate\n   * multiple `WeakRef` instances for the same `Producer`.\n   *\n   * May also be used to satisfy the interface for `Consumer`.\n   */\n  readonly ref: WeakRef<Producer>;\n\n  /**\n   * A map of dependency `Edge`s to `Consumer`s, keyed by the `ConsumerId`.\n   *\n   * Used when the produced value changes to notify interested `Consumer`s.\n   */\n  readonly consumers: Map<ConsumerId, Edge>;\n\n  /**\n   * Monotonically increasing counter which increases when the value of this `Producer`\n   * semantically changes.\n   */\n  readonly valueVersion: number;\n\n  /**\n   * Ensure that `valueVersion` is up to date for the `Producer`'s value.\n   *\n   * Some `Producer`s may produce values lazily, and thus require polling before their\n   * `valueVersion` can be compared with the version captured during a previous read.\n   */\n  checkForChangedValue(): void;\n}\n\n/**\n * Notify all `Consumer`s of the given `Producer` that its value may have changed.\n */\nexport function producerNotifyConsumers(producer: Producer): void {\n  for (const [consumerId, edge] of producer.consumers) {\n    const consumer = edge.consumerRef.deref();\n    if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {\n      producer.consumers.delete(consumerId);\n      consumer?.producers.delete(producer.id);\n      continue;\n    }\n\n    consumer.notify();\n  }\n}\n\n/**\n * Record a dependency on the given `Producer` by the current reactive `Consumer` if\n * one is present.\n */\nexport function producerAccessed(producer: Producer): 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(producer.id);\n  if (edge === undefined) {\n    edge = {\n      consumerRef: activeConsumer.ref,\n      producerRef: producer.ref,\n      seenValueVersion: producer.valueVersion,\n      atTrackingVersion: activeConsumer.trackingVersion,\n    };\n    activeConsumer.producers.set(producer.id, edge);\n    producer.consumers.set(activeConsumer.id, edge);\n  } else {\n    edge.seenValueVersion = producer.valueVersion;\n    edge.atTrackingVersion = activeConsumer.trackingVersion;\n  }\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 */\nfunction producerPollStatus(producer: Producer, 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 (producer.valueVersion !== lastSeenValueVersion) {\n    return true;\n  }\n\n  // Trigger the `Producer` to update its `valueVersion` if necessary.\n  producer.checkForChangedValue();\n\n  // At this point, we can trust `producer.valueVersion`.\n  return producer.valueVersion !== lastSeenValueVersion;\n}\n\n/**\n * Represents a reader that can depend on reactive values (`Producer`s) and receive\n * notifications when those values change.\n *\n * `Consumer`s do not wrap the reads they consume themselves, but rather can be set\n * as the active reader via `setActiveConsumer`.\n *\n * The set of dependencies of a `Consumer` is dynamic. Implementers expose a\n * monotonically increasing `trackingVersion` counter, which increments whenever\n * the `Consumer` is about to re-run any reactive reads it needs and establish a\n * new set of dependencies as a result.\n *\n * `Producer`s store the last `trackingVersion` they've seen from `Consumer`s which\n * have read them. This allows a `Producer` to identify whether its record of the\n * dependency is current or stale, by comparing the `Consumer`'s `trackingVersion`\n * to the version at which the dependency was established.\n */\nexport interface Consumer {\n  /**\n   * Numeric identifier of this `Producer`.\n   *\n   * May also be used to satisfy the interface for `Producer`.\n   */\n  readonly id: ConsumerId;\n\n  /**\n   * A `WeakRef` to this `Consumer` instance.\n   *\n   * An implementer provides this as a cached value to avoid the need to instantiate\n   * multiple `WeakRef` instances for the same `Consumer`.\n   *\n   * May also be used to satisfy the interface for `Producer`.\n   */\n  readonly ref: WeakRef<Consumer>;\n\n  /**\n   * A map of `Edge`s to `Producer` dependencies, keyed by the `ProducerId`.\n   *\n   * Used to poll `Producer`s to determine if the `Consumer` has really updated\n   * or not.\n   */\n  readonly producers: Map<ProducerId, Edge>;\n\n  /**\n   * Monotonically increasing counter representing a version of this `Consumer`'s\n   * dependencies.\n   */\n  readonly trackingVersion: number;\n\n  /**\n   * Called when a `Producer` dependency of this `Consumer` indicates it may\n   * have a new value.\n   *\n   * Notification alone does not mean the `Producer` has definitely produced a\n   * semantically different value, only that it _may_ have changed. Before a\n   * `Consumer` re-runs any computations or side effects, it should use the\n   * `consumerPollValueStatus` method to poll the `Producer`s on which it depends\n   * and determine if any of them have actually updated.\n   */\n  notify(): void;\n}\n\n/**\n * Function called to check the stale status of dependencies (producers) for a given consumer. This\n * is a verification step before refreshing a given consumer: if none of the the dependencies\n * reports a semantically new value, then the `Consumer` has not observed a real dependency change\n * (even though it may have been notified of one).\n */\nexport function consumerPollValueStatus(consumer: Consumer): boolean {\n  for (const [producerId, edge] of consumer.producers) {\n    const producer = edge.producerRef.deref();\n\n    if (producer === undefined || edge.atTrackingVersion !== consumer.trackingVersion) {\n      // This dependency edge is stale, so remove it.\n      consumer.producers.delete(producerId);\n      producer?.consumers.delete(consumer.id);\n      continue;\n    }\n\n    if (producerPollStatus(producer, 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"]}