@tstdl/base 0.93.181 → 0.93.183

package/signals/implementation/primitive/formatter.js

@@ -0,0 +1,136 @@
+/**
+ * @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.dev/license
+ */
+import { SIGNAL } from './graph.js';
+/**
+ * A custom formatter which renders signals in an easy-to-read format.
+ *
+ * @see https://firefox-source-docs.mozilla.org/devtools-user/custom_formatters/index.html
+ */
+const formatter = {
+    /**
+     *  If the function returns `null`, the formatter is not used for this reference
+     */
+    header: (sig, config) => {
+        if (!isSignal(sig) || config?.ngSkipFormatting)
+            return null;
+        let value;
+        try {
+            value = sig();
+        }
+        catch (e) {
+            // In case the signal throws, we don't want to break the formatting.
+            return ['span', `Signal(⚠️ Error)${e.message ? `: ${e.message}` : ''}`];
+        }
+        const kind = 'computation' in sig[SIGNAL] ? 'Computed' : 'Signal';
+        const isPrimitive = value === null || (!Array.isArray(value) && typeof value !== 'object');
+        return [
+            'span',
+            {},
+            ['span', {}, `${kind}(`],
+            (() => {
+                if (isSignal(value)) {
+                    // Recursively call formatter. Could return an `object` to call the formatter through DevTools,
+                    // but then recursive signals will render multiple expando arrows which is an awkward UX.
+                    return formatter.header(value, config);
+                }
+                else if (isPrimitive && value !== undefined && typeof value !== 'function') {
+                    // Use built-in rendering for primitives which applies standard syntax highlighting / theming.
+                    // Can't do this for `undefined` however, as the browser thinks we forgot to provide an object.
+                    // Also don't want to do this for functions which render nested expando arrows.
+                    return ['object', { object: value }];
+                }
+                else {
+                    return prettifyPreview(value);
+                }
+            })(),
+            ['span', {}, `)`],
+        ];
+    },
+    hasBody: (sig, config) => {
+        if (!isSignal(sig))
+            return false;
+        try {
+            sig();
+        }
+        catch {
+            return false;
+        }
+        return !config?.ngSkipFormatting;
+    },
+    body: (sig, config) => {
+        // We can use sys colors to fit the current DevTools theme.
+        // Those are unfortunately only available on Chromium-based browsers.
+        // On Firefow we fall back to the default color
+        const color = 'var(--sys-color-primary)';
+        return [
+            'div',
+            { style: `background: #FFFFFF10; padding-left: 4px; padding-top: 2px; padding-bottom: 2px;` },
+            ['div', { style: `color: ${color}` }, 'Signal value: '],
+            ['div', { style: `padding-left: .5rem;` }, ['object', { object: sig(), config }]],
+            ['div', { style: `color: ${color}` }, 'Signal function: '],
+            [
+                'div',
+                { style: `padding-left: .5rem;` },
+                ['object', { object: sig, config: { ...config, ngSkipFormatting: true } }],
+            ],
+        ];
+    },
+};
+function prettifyPreview(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return `Array(${value.length})`;
+    if (value instanceof Element)
+        return `<${value.tagName.toLowerCase()}>`;
+    if (value instanceof URL)
+        return `URL`;
+    switch (typeof value) {
+        case 'undefined': {
+            return 'undefined';
+        }
+        case 'function': {
+            if ('prototype' in value) {
+                // This is what Chrome renders, can't use `object` though because it creates a nested expando arrow.
+                return 'class';
+            }
+            else {
+                return '() => {…}';
+            }
+        }
+        case 'object': {
+            if (value.constructor.name === 'Object') {
+                return '{…}';
+            }
+            else {
+                return `${value.constructor.name} {}`;
+            }
+        }
+        default: {
+            return ['object', { object: value, config: { ngSkipFormatting: true } }];
+        }
+    }
+}
+function isSignal(value) {
+    return value[SIGNAL] !== undefined;
+}
+/**
+ * Installs the custom formatter into custom formatting on Signals in the devtools.
+ *
+ * Supported by both Chrome and Firefox.
+ *
+ * @see https://firefox-source-docs.mozilla.org/devtools-user/custom_formatters/index.html
+ */
+export function installDevToolsSignalFormatter() {
+    globalThis.devtoolsFormatters ??= [];
+    if (!globalThis.devtoolsFormatters.some((f) => f === formatter)) {
+        globalThis.devtoolsFormatters.push(formatter);
+    }
+}
+// This fixes the RollupError: Exported variable "global" is not defined.
+export {};

package/signals/implementation/{graph.d.ts → primitive/graph.d.ts}

@@ -1,8 +1,16 @@
-import { SIGNAL } from '../symbol.js';
+/**
+ * @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.dev/license
+ */
+import { SIGNAL } from '../../symbol.js';
 export { SIGNAL };
-type Version = number & {
+export type Version = number & {
     __brand: 'Version';
 };
+export type ReactiveHookFn = (node: ReactiveNode) => void;
 export declare function setActiveConsumer(consumer: ReactiveNode | null): ReactiveNode | null;
 export declare function getActiveConsumer(): ReactiveNode | null;
 export declare function isInNotificationPhase(): boolean;
@@ -11,6 +19,15 @@ export interface Reactive {
 }
 export declare function isReactive(value: unknown): value is Reactive;
 export declare const REACTIVE_NODE: ReactiveNode;
+interface ReactiveLink {
+    producer: ReactiveNode;
+    consumer: ReactiveNode;
+    lastReadVersion: number;
+    prevConsumer: ReactiveLink | undefined;
+    nextConsumer: ReactiveLink | undefined;
+    nextProducer: ReactiveLink | undefined;
+}
+export type ReactiveNodeKind = 'signal' | 'computed' | 'effect' | 'template' | 'linkedSignal' | 'afterRenderEffectPhase' | 'unknown';
 /**
  * A producer and/or consumer which participates in the reactive graph.
  *
@@ -46,47 +63,26 @@ export interface ReactiveNode {
      */
     dirty: boolean;
     /**
-     * Producers which are dependencies of this consumer.
-     *
-     * Uses the same indices as the `producerLastReadVersion` and `producerIndexOfThis` arrays.
-     */
-    producerNode: ReactiveNode[] | undefined;
-    /**
-     * `Version` of the value last read by a given producer.
-     *
-     * Uses the same indices as the `producerNode` and `producerIndexOfThis` arrays.
-     */
-    producerLastReadVersion: Version[] | undefined;
-    /**
-     * Index of `this` (consumer) in each producer's `liveConsumers` array.
-     *
-     * This value is only meaningful if this node is live (`liveConsumers.length > 0`). Otherwise
-     * these indices are stale.
-     *
-     * Uses the same indices as the `producerNode` and `producerLastReadVersion` arrays.
+     * Whether this node is currently rebuilding its producer list.
      */
-    producerIndexOfThis: number[] | undefined;
+    recomputing: boolean;
     /**
-     * Index into the producer arrays that the next dependency of this node as a consumer will use.
-     *
-     * This index is zeroed before this node as a consumer begins executing. When a producer is read,
-     * it gets inserted into the producers arrays at this index. There may be an existing dependency
-     * in this location which may or may not match the incoming producer, depending on whether the
-     * same producers were read in the same order as the last computation.
+     * Producers which are dependencies of this consumer.
      */
-    nextProducerIndex: number;
+    producers: ReactiveLink | undefined;
     /**
-     * Array of consumers of this producer that are "live" (they require push notifications).
+     * Points to the last linked list node in the `producers` linked list.
      *
-     * `liveConsumerNode.length` is effectively our reference count for this node.
+     * When this node is recomputing, this is used to track the producers that we have accessed so far.
      */
-    liveConsumerNode: ReactiveNode[] | undefined;
+    producersTail: ReactiveLink | undefined;
     /**
-     * Index of `this` (producer) in each consumer's `producerNode` array.
+     * Linked list of consumers of this producer that are "live" (they require push notifications).
      *
-     * Uses the same indices as the `liveConsumerNode` array.
+     * The length of this list is effectively our reference count for this node.
      */
-    liveConsumerIndexOfThis: number[] | undefined;
+    consumers: ReactiveLink | undefined;
+    consumersTail: ReactiveLink | undefined;
     /**
      * Whether writes to signals are allowed when this consumer is the `activeConsumer`.
      *
@@ -106,6 +102,19 @@ export interface ReactiveNode {
      * Called when a signal is read within this consumer.
      */
     consumerOnSignalRead(node: unknown): void;
+    /**
+     * A debug name for the reactive node. Used in Angular DevTools to identify the node.
+     */
+    debugName?: string;
+    /**
+     * Kind of node. Example: 'signal', 'computed', 'input', 'effect'.
+     *
+     * ReactiveNode has this as 'unknown' by default, but derived node types should override this to
+     * make available the kind of signal that particular instance of a ReactiveNode represents.
+     *
+     * Used in Angular DevTools to identify the kind of signal.
+     */
+    kind: ReactiveNodeKind;
 }
 /**
  * Called by implementations when a producer's signal is read.
@@ -131,20 +140,41 @@ export declare function producerNotifyConsumers(node: ReactiveNode): void;
  */
 export declare function producerUpdatesAllowed(): boolean;
 export declare function consumerMarkDirty(node: ReactiveNode): void;
+export declare function producerMarkClean(node: ReactiveNode): void;
 /**
- * Prepare this consumer to run a computation in its reactive context.
+ * Prepare this consumer to run a computation in its reactive context and set
+ * it as the active consumer.
  *
  * Must be called by subclasses which represent reactive computations, before those computations
  * begin.
  */
 export declare function consumerBeforeComputation(node: ReactiveNode | null): ReactiveNode | null;
 /**
- * Finalize this consumer's state after a reactive computation has run.
+ * Prepare this consumer to run a computation in its reactive context.
+ *
+ * We expose this mainly for code where we manually batch effects into a single
+ * consumer. In those cases we may wish to "reopen" a consumer multiple times
+ * in initial render before finalizing it. Most code should just call
+ * `consumerBeforeComputation` instead of calling this directly.
+ */
+export declare function resetConsumerBeforeComputation(node: ReactiveNode): void;
+/**
+ * Finalize this consumer's state and set previous consumer as the active consumer after a
+ * reactive computation has run.
  *
  * Must be called by subclasses which represent reactive computations, after those computations
  * have finished.
  */
 export declare function consumerAfterComputation(node: ReactiveNode | null, prevConsumer: ReactiveNode | null): void;
+/**
+ * Finalize this consumer's state after a reactive computation has run.
+ *
+ * We expose this mainly for code where we manually batch effects into a single
+ * consumer. In those cases we may wish to "reopen" a consumer multiple times
+ * in initial render before finalizing it. Most code should just call
+ * `consumerAfterComputation` instead of calling this directly.
+ */
+export declare function finalizeConsumerAfterComputation(node: ReactiveNode): void;
 /**
  * Determine whether this consumer has any dependencies which have changed since the last time
  * they were read.
@@ -154,3 +184,5 @@ export declare function consumerPollProducersForChange(node: ReactiveNode): bool
  * Disconnect this consumer from the graph.
  */
 export declare function consumerDestroy(node: ReactiveNode): void;
+export declare function runPostProducerCreatedFn(node: ReactiveNode): void;
+export declare function setPostProducerCreatedFn(fn: ReactiveHookFn | null): ReactiveHookFn | null;

package/signals/implementation/primitive/graph.js

@@ -0,0 +1,386 @@
+/**
+ * @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.dev/license
+ */
+import { isDevMode } from '../../../core.js';
+import { SIGNAL } from '../../symbol.js';
+export { SIGNAL };
+/**
+ * The currently active consumer `ReactiveNode`, if running code in a reactive context.
+ *
+ * Change this via `setActiveConsumer`.
+ */
+let activeConsumer = null;
+let inNotificationPhase = false;
+/**
+ * Global epoch counter. Incremented whenever a source signal is set.
+ */
+let epoch = 1;
+/**
+ * If set, called after a producer `ReactiveNode` is created.
+ */
+let postProducerCreatedFn = null;
+export function setActiveConsumer(consumer) {
+    const prev = activeConsumer;
+    activeConsumer = consumer;
+    return prev;
+}
+export function getActiveConsumer() {
+    return activeConsumer;
+}
+export function isInNotificationPhase() {
+    return inNotificationPhase;
+}
+export function isReactive(value) {
+    return value[SIGNAL] !== undefined;
+}
+export const REACTIVE_NODE = {
+    version: 0,
+    lastCleanEpoch: 0,
+    dirty: false,
+    producers: undefined,
+    producersTail: undefined,
+    consumers: undefined,
+    consumersTail: undefined,
+    recomputing: false,
+    consumerAllowSignalWrites: false,
+    consumerIsAlwaysLive: false,
+    kind: 'unknown',
+    producerMustRecompute: () => false,
+    producerRecomputeValue: () => { },
+    consumerMarkedDirty: () => { },
+    consumerOnSignalRead: () => { },
+};
+/**
+ * Called by implementations when a producer's signal is read.
+ */
+export function producerAccessed(node) {
+    if (inNotificationPhase) {
+        throw new Error(isDevMode()
+            ? `Assertion error: signal read during notification phase`
+            : '');
+    }
+    if (activeConsumer === null) {
+        // Accessed outside of a reactive context, so nothing to record.
+        return;
+    }
+    activeConsumer.consumerOnSignalRead(node);
+    const prevProducerLink = activeConsumer.producersTail;
+    // If the last producer we accessed is the same as the current one, we can skip adding a new
+    // link
+    if (prevProducerLink !== undefined && prevProducerLink.producer === node) {
+        return;
+    }
+    let nextProducerLink = undefined;
+    const isRecomputing = activeConsumer.recomputing;
+    if (isRecomputing) {
+        // If we're incrementally rebuilding the producers list, we want to check if the next producer
+        // in the list is the same as the one we're trying to add.
+        // If the previous producer is defined, then the next producer is just the one that follows it.
+        // Otherwise, we should check the head of the producers list (the first node that we accessed the last time this consumer was run).
+        nextProducerLink =
+            prevProducerLink !== undefined ? prevProducerLink.nextProducer : activeConsumer.producers;
+        if (nextProducerLink !== undefined && nextProducerLink.producer === node) {
+            // If the next producer is the same as the one we're trying to add, we can just update the
+            // last read version, update the tail of the producers list of this rerun, and return.
+            activeConsumer.producersTail = nextProducerLink;
+            nextProducerLink.lastReadVersion = node.version;
+            return;
+        }
+    }
+    const prevConsumerLink = node.consumersTail;
+    // If the producer we're accessing already has a link to this consumer, we can skip adding a new
+    // link. This can short circuit the creation of a new link in the case where the consumer reads alternating ReeactiveNodes
+    if (prevConsumerLink !== undefined &&
+        prevConsumerLink.consumer === activeConsumer &&
+        // However, we have to make sure that the link we've discovered isn't from a node that is incrementally rebuilding its producer list
+        (!isRecomputing || isValidLink(prevConsumerLink, activeConsumer))) {
+        // If we found an existing link to the consumer we can just return.
+        return;
+    }
+    // If we got here, it means that we need to create a new link between the producer and the consumer.
+    const isLive = consumerIsLive(activeConsumer);
+    const newLink = {
+        producer: node,
+        consumer: activeConsumer,
+        // instead of eagerly destroying the previous link, we delay until we've finished recomputing
+        // the producers list, so that we can destroy all of the old links at once.
+        nextProducer: nextProducerLink,
+        prevConsumer: prevConsumerLink,
+        lastReadVersion: node.version,
+        nextConsumer: undefined,
+    };
+    activeConsumer.producersTail = newLink;
+    if (prevProducerLink !== undefined) {
+        prevProducerLink.nextProducer = newLink;
+    }
+    else {
+        activeConsumer.producers = newLink;
+    }
+    if (isLive) {
+        producerAddLiveConsumer(node, newLink);
+    }
+}
+/**
+ * Increment the global epoch counter.
+ *
+ * Called by source producers (that is, not computeds) whenever their values change.
+ */
+export function producerIncrementEpoch() {
+    epoch++;
+}
+/**
+ * Ensure this producer's `version` is up-to-date.
+ */
+export function producerUpdateValueVersion(node) {
+    if (consumerIsLive(node) && !node.dirty) {
+        // A live consumer will be marked dirty by producers, so a clean state means that its version
+        // is guaranteed to be up-to-date.
+        return;
+    }
+    if (!node.dirty && node.lastCleanEpoch === epoch) {
+        // Even non-live consumers can skip polling if they previously found themselves to be clean at
+        // the current epoch, since their dependencies could not possibly have changed (such a change
+        // would've increased the epoch).
+        return;
+    }
+    if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
+        // None of our producers report a change since the last time they were read, so no
+        // recomputation of our value is necessary, and we can consider ourselves clean.
+        producerMarkClean(node);
+        return;
+    }
+    node.producerRecomputeValue(node);
+    // After recomputing the value, we're no longer dirty.
+    producerMarkClean(node);
+}
+/**
+ * Propagate a dirty notification to live consumers of this producer.
+ */
+export function producerNotifyConsumers(node) {
+    if (node.consumers === undefined) {
+        return;
+    }
+    // Prevent signal reads when we're updating the graph
+    const prev = inNotificationPhase;
+    inNotificationPhase = true;
+    try {
+        for (let link = node.consumers; link !== undefined; link = link.nextConsumer) {
+            const consumer = link.consumer;
+            if (!consumer.dirty) {
+                consumerMarkDirty(consumer);
+            }
+        }
+    }
+    finally {
+        inNotificationPhase = prev;
+    }
+}
+/**
+ * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
+ * based on the current consumer context.
+ */
+export function producerUpdatesAllowed() {
+    return activeConsumer?.consumerAllowSignalWrites !== false;
+}
+export function consumerMarkDirty(node) {
+    node.dirty = true;
+    producerNotifyConsumers(node);
+    node.consumerMarkedDirty?.(node);
+}
+export function producerMarkClean(node) {
+    node.dirty = false;
+    node.lastCleanEpoch = epoch;
+}
+/**
+ * Prepare this consumer to run a computation in its reactive context and set
+ * it as the active consumer.
+ *
+ * Must be called by subclasses which represent reactive computations, before those computations
+ * begin.
+ */
+export function consumerBeforeComputation(node) {
+    if (node)
+        resetConsumerBeforeComputation(node);
+    return setActiveConsumer(node);
+}
+/**
+ * Prepare this consumer to run a computation in its reactive context.
+ *
+ * We expose this mainly for code where we manually batch effects into a single
+ * consumer. In those cases we may wish to "reopen" a consumer multiple times
+ * in initial render before finalizing it. Most code should just call
+ * `consumerBeforeComputation` instead of calling this directly.
+ */
+export function resetConsumerBeforeComputation(node) {
+    node.producersTail = undefined;
+    node.recomputing = true;
+}
+/**
+ * Finalize this consumer's state and set previous consumer as the active consumer after a
+ * reactive computation has run.
+ *
+ * Must be called by subclasses which represent reactive computations, after those computations
+ * have finished.
+ */
+export function consumerAfterComputation(node, prevConsumer) {
+    setActiveConsumer(prevConsumer);
+    if (node)
+        finalizeConsumerAfterComputation(node);
+}
+/**
+ * Finalize this consumer's state after a reactive computation has run.
+ *
+ * We expose this mainly for code where we manually batch effects into a single
+ * consumer. In those cases we may wish to "reopen" a consumer multiple times
+ * in initial render before finalizing it. Most code should just call
+ * `consumerAfterComputation` instead of calling this directly.
+ */
+export function finalizeConsumerAfterComputation(node) {
+    node.recomputing = false;
+    // We've finished incrementally rebuilding the producers list, now if there are any producers
+    // that are after producersTail, they are stale and should be removed.
+    const producersTail = node.producersTail;
+    let toRemove = producersTail !== undefined ? producersTail.nextProducer : node.producers;
+    if (toRemove !== undefined) {
+        if (consumerIsLive(node)) {
+            // For each stale link, we first unlink it from the producers list of consumers
+            do {
+                toRemove = producerRemoveLiveConsumerLink(toRemove);
+            } while (toRemove !== undefined);
+        }
+        // Now, we can truncate the producers list to remove all stale links.
+        if (producersTail !== undefined) {
+            producersTail.nextProducer = undefined;
+        }
+        else {
+            node.producers = undefined;
+        }
+    }
+}
+/**
+ * Determine whether this consumer has any dependencies which have changed since the last time
+ * they were read.
+ */
+export function consumerPollProducersForChange(node) {
+    // Poll producers for change.
+    for (let link = node.producers; link !== undefined; link = link.nextProducer) {
+        const producer = link.producer;
+        const seenVersion = link.lastReadVersion;
+        // First check the versions. A mismatch means that the producer's value is known to have
+        // changed since the last time we read it.
+        if (seenVersion !== producer.version) {
+            return true;
+        }
+        // The producer's version is the same as the last time we read it, but it might itself be
+        // stale. Force the producer to recompute its version (calculating a new value if necessary).
+        producerUpdateValueVersion(producer);
+        // Now when we do this check, `producer.version` is guaranteed to be up to date, so if the
+        // versions still match then it has not changed since the last time we read it.
+        if (seenVersion !== producer.version) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Disconnect this consumer from the graph.
+ */
+export function consumerDestroy(node) {
+    if (consumerIsLive(node)) {
+        // Drop all connections from the graph to this node.
+        let link = node.producers;
+        while (link !== undefined) {
+            link = producerRemoveLiveConsumerLink(link);
+        }
+    }
+    // Truncate all the linked lists to drop all connection from this node to the graph.
+    node.producers = undefined;
+    node.producersTail = undefined;
+    node.consumers = undefined;
+    node.consumersTail = undefined;
+}
+/**
+ * Add `consumer` as a live consumer of this node.
+ *
+ * Note that this operation is potentially transitive. If this node becomes live, then it becomes
+ * a live consumer of all of its current producers.
+ */
+function producerAddLiveConsumer(node, link) {
+    const consumersTail = node.consumersTail;
+    const wasLive = consumerIsLive(node);
+    if (consumersTail !== undefined) {
+        link.nextConsumer = consumersTail.nextConsumer;
+        consumersTail.nextConsumer = link;
+    }
+    else {
+        link.nextConsumer = undefined;
+        node.consumers = link;
+    }
+    link.prevConsumer = consumersTail;
+    node.consumersTail = link;
+    if (!wasLive) {
+        for (let link = node.producers; link !== undefined; link = link.nextProducer) {
+            producerAddLiveConsumer(link.producer, link);
+        }
+    }
+}
+function producerRemoveLiveConsumerLink(link) {
+    const producer = link.producer;
+    const nextProducer = link.nextProducer;
+    const nextConsumer = link.nextConsumer;
+    const prevConsumer = link.prevConsumer;
+    link.nextConsumer = undefined;
+    link.prevConsumer = undefined;
+    if (nextConsumer !== undefined) {
+        nextConsumer.prevConsumer = prevConsumer;
+    }
+    else {
+        producer.consumersTail = prevConsumer;
+    }
+    if (prevConsumer !== undefined) {
+        prevConsumer.nextConsumer = nextConsumer;
+    }
+    else {
+        producer.consumers = nextConsumer;
+        if (!consumerIsLive(producer)) {
+            let producerLink = producer.producers;
+            while (producerLink !== undefined) {
+                producerLink = producerRemoveLiveConsumerLink(producerLink);
+            }
+        }
+    }
+    return nextProducer;
+}
+function consumerIsLive(node) {
+    return node.consumerIsAlwaysLive || node.consumers !== undefined;
+}
+export function runPostProducerCreatedFn(node) {
+    postProducerCreatedFn?.(node);
+}
+export function setPostProducerCreatedFn(fn) {
+    const prev = postProducerCreatedFn;
+    postProducerCreatedFn = fn;
+    return prev;
+}
+// While a ReactiveNode is recomputing, it may not have destroyed previous links
+// This allows us to check if a given link will be destroyed by a reactivenode if it were to finish running immediately without accesing any more producers
+function isValidLink(checkLink, consumer) {
+    const producersTail = consumer.producersTail;
+    if (producersTail !== undefined) {
+        let link = consumer.producers;
+        do {
+            if (link === checkLink) {
+                return true;
+            }
+            if (link === producersTail) {
+                break;
+            }
+            link = link.nextProducer;
+        } while (link !== undefined);
+    }
+    return false;
+}