signalium 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # signalium
 
+## 0.2.2
+
+### Patch Changes
+
+- 0376187: Fix a circular ref and add logs to detect circular refs in dev
+
 ## 0.2.1
 
 ### Patch Changes

package/dist/signals.d.ts

@@ -32,6 +32,7 @@ declare const enum SignalState {
     Dirty = 2
 }
 interface Link {
+    id: number;
     sub: WeakRef<ComputedSignal<any>>;
     dep: ComputedSignal<any>;
     ord: number;

package/dist/signals.js

@@ -10,6 +10,41 @@ const SUBSCRIPTIONS = new WeakMap();
 const ACTIVE_ASYNCS = new WeakMap();
 const WAITING = Symbol();
 let linkPool;
+const checkForCircularLinks = (link) => {
+    if (!link)
+        return;
+    for (const key of ['nextDep', 'nextSub', 'prevSub', 'nextDirty']) {
+        let currentLink = link?.[key];
+        while (currentLink !== undefined) {
+            if (currentLink === link) {
+                throw new Error(`Circular link detected via ${key}. This is a bug, please report it to the Signalium maintainers.`);
+            }
+            currentLink = currentLink[key];
+        }
+    }
+};
+const typeToString = (type) => {
+    switch (type) {
+        case 0 /* SignalType.Computed */:
+            return 'Computed';
+        case 1 /* SignalType.Subscription */:
+            return 'Subscription';
+        case 2 /* SignalType.Async */:
+            return 'Async';
+        case 3 /* SignalType.Watcher */:
+            return 'Watcher';
+    }
+};
+const printComputed = (computed) => {
+    const type = typeToString(computed._type);
+    return `ComputedSignal<${type}:${computed.id}>`;
+};
+const printLink = (link) => {
+    const sub = link.sub.deref();
+    const subStr = sub === undefined ? 'undefined' : printComputed(sub);
+    const depStr = printComputed(link.dep);
+    return `Link<${link.id}> sub(${subStr}) -> dep(${depStr})`;
+};
 function linkNewDep(dep, sub, nextDep, depsTail, ord) {
     let newLink;
     if (linkPool !== undefined) {
@@ -22,6 +57,7 @@ function linkNewDep(dep, sub, nextDep, depsTail, ord) {
     }
     else {
         newLink = {
+            id: id++,
             dep,
             sub: sub._ref,
             ord,
@@ -175,6 +211,8 @@ export class ComputedSignal {
             }
             this._check(CURRENT_IS_WATCHED && !prevTracked);
             CURRENT_DEP_TAIL = newLink ?? linkNewDep(this, CURRENT_CONSUMER, nextDep, CURRENT_DEP_TAIL, ord);
+            if (process.env.NODE_ENV !== 'production')
+                checkForCircularLinks(CURRENT_DEP_TAIL);
             CURRENT_DEP_TAIL.version = this._version;
             CURRENT_SEEN.add(this);
         }
@@ -197,6 +235,8 @@ export class ComputedSignal {
             }
             else {
                 let link = this._deps;
+                if (process.env.NODE_ENV !== 'production')
+                    checkForCircularLinks(link);
                 while (link !== undefined) {
                     const dep = link.dep;
                     if (link.version !== dep._check(true)) {
@@ -206,7 +246,6 @@ export class ComputedSignal {
                     link = link.nextDep;
                 }
             }
-            this._resetDirty();
         }
         if (state === 0 /* SignalState.Clean */) {
             return this._version;
@@ -269,8 +308,8 @@ export class ComputedSignal {
                             value.isPending = false;
                             value.isError = true;
                             this._version++;
+                            break;
                         }
-                        break;
                     }
                     if (CURRENT_IS_WAITING) {
                         if (!value.isPending) {
@@ -372,13 +411,19 @@ export class ComputedSignal {
             }
             else {
                 dirty.nextSub = oldHead;
+                dirty.prevSub = undefined;
                 oldHead.prevSub = dirty;
                 dep._subs = dirty;
             }
+            if (process.env.NODE_ENV !== 'production') {
+                checkForCircularLinks(this._dirtyDep);
+            }
             let nextDirty = dirty.nextDirty;
             dirty.nextDirty = undefined;
             dirty = nextDirty;
         }
+        if (process.env.NODE_ENV !== 'production')
+            checkForCircularLinks(this._dirtyDep);
     }
     _dirty() {
         if (this._type === 1 /* SignalType.Subscription */) {
@@ -397,6 +442,8 @@ export class ComputedSignal {
     }
     _dirtyConsumers() {
         let link = this._subs;
+        if (process.env.NODE_ENV !== 'production')
+            checkForCircularLinks(link);
         while (link !== undefined) {
             const consumer = link.sub.deref();
             if (consumer === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalium",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "repository": "https://github.com/pzuraq/signalium",
   "description": "Chain-reactivity at critical mass",

package/src/__tests__/async.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { state, computed, asyncComputed } from './utils/instrumented.js';
+import { state, asyncComputed } from './utils/instrumented.js';
 import { AsyncResult } from '../signals';
 
 const sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));

package/src/signals.ts

@@ -61,6 +61,7 @@ const enum SignalState {
 const WAITING = Symbol();
 
 interface Link {
+  id: number;
   sub: WeakRef<ComputedSignal<any>>;
   dep: ComputedSignal<any>;
   ord: number;
@@ -75,6 +76,51 @@ interface Link {
 
 let linkPool: Link | undefined;
 
+const checkForCircularLinks = (link: Link | undefined) => {
+  if (!link) return;
+
+  for (const key of ['nextDep', 'nextSub', 'prevSub', 'nextDirty'] as const) {
+    let currentLink: Link | undefined = link?.[key];
+
+    while (currentLink !== undefined) {
+      if (currentLink === link) {
+        throw new Error(
+          `Circular link detected via ${key}. This is a bug, please report it to the Signalium maintainers.`,
+        );
+      }
+
+      currentLink = currentLink[key];
+    }
+  }
+};
+
+const typeToString = (type: SignalType) => {
+  switch (type) {
+    case SignalType.Computed:
+      return 'Computed';
+    case SignalType.Subscription:
+      return 'Subscription';
+    case SignalType.Async:
+      return 'Async';
+    case SignalType.Watcher:
+      return 'Watcher';
+  }
+};
+
+const printComputed = (computed: ComputedSignal<any>) => {
+  const type = typeToString(computed._type);
+
+  return `ComputedSignal<${type}:${computed.id}>`;
+};
+
+const printLink = (link: Link) => {
+  const sub = link.sub.deref();
+  const subStr = sub === undefined ? 'undefined' : printComputed(sub);
+  const depStr = printComputed(link.dep);
+
+  return `Link<${link.id}> sub(${subStr}) -> dep(${depStr})`;
+};
+
 function linkNewDep(
   dep: ComputedSignal<any>,
   sub: ComputedSignal<any>,
@@ -93,6 +139,7 @@ function linkNewDep(
     newLink.ord = ord;
   } else {
     newLink = {
+      id: id++,
       dep,
       sub: sub._ref,
       ord,
@@ -288,6 +335,8 @@ export class ComputedSignal<T> {
 
       CURRENT_DEP_TAIL = newLink ?? linkNewDep(this, CURRENT_CONSUMER, nextDep, CURRENT_DEP_TAIL, ord);
 
+      if (process.env.NODE_ENV !== 'production') checkForCircularLinks(CURRENT_DEP_TAIL);
+
       CURRENT_DEP_TAIL.version = this._version;
       CURRENT_SEEN!.add(this);
     } else {
@@ -314,6 +363,8 @@ export class ComputedSignal<T> {
       } else {
         let link = this._deps;
 
+        if (process.env.NODE_ENV !== 'production') checkForCircularLinks(link);
+
         while (link !== undefined) {
           const dep = link.dep;
 
@@ -325,8 +376,6 @@ export class ComputedSignal<T> {
           link = link.nextDep;
         }
       }
-
-      this._resetDirty();
     }
 
     if (state === SignalState.Clean) {
@@ -403,9 +452,8 @@ export class ComputedSignal<T> {
               value.isPending = false;
               value.isError = true;
               this._version++;
+              break;
             }
-
-            break;
           }
 
           if (CURRENT_IS_WAITING) {
@@ -527,14 +575,21 @@ export class ComputedSignal<T> {
         dirty.prevSub = undefined;
       } else {
         dirty.nextSub = oldHead;
+        dirty.prevSub = undefined;
         oldHead.prevSub = dirty;
         dep._subs = dirty;
       }
 
+      if (process.env.NODE_ENV !== 'production') {
+        checkForCircularLinks(this._dirtyDep);
+      }
+
       let nextDirty = dirty.nextDirty;
       dirty.nextDirty = undefined;
       dirty = nextDirty;
     }
+
+    if (process.env.NODE_ENV !== 'production') checkForCircularLinks(this._dirtyDep);
   }
 
   _dirty() {
@@ -556,6 +611,8 @@ export class ComputedSignal<T> {
   _dirtyConsumers() {
     let link = this._subs;
 
+    if (process.env.NODE_ENV !== 'production') checkForCircularLinks(link);
+
     while (link !== undefined) {
       const consumer = link.sub.deref();