signalium 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # signalium
 
+## 0.2.3
+
+### Patch Changes
+
+- 0ba50a0: Remove linked-lists for deps and subs
+
 ## 0.2.2
 
 ### Patch Changes

package/dist/signals.d.ts

@@ -32,26 +32,22 @@ declare const enum SignalState {
     Dirty = 2
 }
 interface Link {
-    id: number;
-    sub: WeakRef<ComputedSignal<any>>;
     dep: ComputedSignal<any>;
+    sub: WeakRef<ComputedSignal<any>>;
     ord: number;
     version: number;
-    nextDep: Link | undefined;
-    nextSub: Link | undefined;
-    prevSub: Link | undefined;
+    consumedAt: number;
     nextDirty: Link | undefined;
 }
-export declare function endTrack(sub: ComputedSignal<any>, shouldDisconnect: boolean): void;
 export declare class ComputedSignal<T> {
-    id: number;
+    _id: number;
     _type: SignalType;
-    _subs: Link | undefined;
-    _subsTail: Link | undefined;
-    _deps: Link | undefined;
+    _deps: Map<ComputedSignal<any>, Link>;
     _dirtyDep: Link | undefined;
+    _subs: Set<Link>;
     _state: SignalState;
     _version: number;
+    _computedCount: number;
     _connectedCount: number;
     _currentValue: T | AsyncResult<T> | undefined;
     _compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T> | undefined;
@@ -60,7 +56,7 @@ export declare class ComputedSignal<T> {
     constructor(type: SignalType, compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T> | undefined, equals?: SignalEquals<T>, initValue?: T);
     get(): T | AsyncResult<T>;
     _check(shouldWatch?: boolean): number;
-    _run(wasConnected: boolean, isConnected: boolean, shouldConnect: boolean): void;
+    _run(wasConnected: boolean, shouldConnect: boolean): void;
     _resetDirty(): void;
     _dirty(): void;
     _dirtyConsumers(): void;
@@ -92,7 +88,7 @@ export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 declare class StateSignal<T> implements StateSignal<T> {
     private _value;
     private _equals;
-    private _consumers;
+    private _subs;
     constructor(_value: T, _equals?: SignalEquals<T>);
     get(): T;
     set(value: T): void;

package/dist/signals.js

@@ -1,148 +1,21 @@
 import { scheduleDisconnect, scheduleWatcher } from './scheduling.js';
-let CURRENT_CONSUMER;
-let CURRENT_DEP_TAIL;
 let CURRENT_ORD = 0;
-let CURRENT_IS_WATCHED = false;
+let CURRENT_CONSUMER;
 let CURRENT_IS_WAITING = false;
-let CURRENT_SEEN;
-let id = 0;
+let ID = 0;
 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) {
-        newLink = linkPool;
-        linkPool = newLink.nextDep;
-        newLink.nextDep = nextDep;
-        newLink.dep = dep;
-        newLink.sub = sub._ref;
-        newLink.ord = ord;
-    }
-    else {
-        newLink = {
-            id: id++,
-            dep,
-            sub: sub._ref,
-            ord,
-            version: 0,
-            nextDep,
-            nextDirty: undefined,
-            prevSub: undefined,
-            nextSub: undefined,
-        };
-    }
-    if (depsTail === undefined) {
-        sub._deps = newLink;
-    }
-    else {
-        depsTail.nextDep = newLink;
-    }
-    if (dep._subs === undefined) {
-        dep._subs = newLink;
-    }
-    else {
-        const oldTail = dep._subsTail;
-        newLink.prevSub = oldTail;
-        oldTail.nextSub = newLink;
-    }
-    dep._subsTail = newLink;
-    return newLink;
-}
-function poolLink(link) {
-    const dep = link.dep;
-    const nextSub = link.nextSub;
-    const prevSub = link.prevSub;
-    if (nextSub !== undefined) {
-        nextSub.prevSub = prevSub;
-        link.nextSub = undefined;
-    }
-    else {
-        dep._subsTail = prevSub;
-    }
-    if (prevSub !== undefined) {
-        prevSub.nextSub = nextSub;
-        link.prevSub = undefined;
-    }
-    else {
-        dep._subs = nextSub;
-    }
-    // @ts-expect-error - override to pool the value
-    link.dep = undefined;
-    // @ts-expect-error - override to pool the value
-    link.sub = undefined;
-    link.nextDep = linkPool;
-    linkPool = link;
-    link.prevSub = undefined;
-}
-export function endTrack(sub, shouldDisconnect) {
-    if (CURRENT_DEP_TAIL !== undefined) {
-        if (CURRENT_DEP_TAIL.nextDep !== undefined) {
-            clearTrack(CURRENT_DEP_TAIL.nextDep, shouldDisconnect);
-            CURRENT_DEP_TAIL.nextDep = undefined;
-        }
-    }
-    else if (sub._deps !== undefined) {
-        clearTrack(sub._deps, shouldDisconnect);
-        sub._deps = undefined;
-    }
-}
-function clearTrack(link, shouldDisconnect) {
-    do {
-        const nextDep = link.nextDep;
-        if (shouldDisconnect) {
-            scheduleDisconnect(link.dep);
-        }
-        poolLink(link);
-        link = nextDep;
-    } while (link !== undefined);
-}
 export class ComputedSignal {
-    id = id++;
+    _id = ID++;
     _type;
-    _subs;
-    _subsTail;
-    _deps;
-    _dirtyDep;
+    _deps = new Map();
+    _dirtyDep = undefined;
+    _subs = new Set();
     _state = 2 /* SignalState.Dirty */;
     _version = 0;
-    _connectedCount;
+    _computedCount = 0;
+    _connectedCount = 0;
     _currentValue;
     _compute;
     _equals;
@@ -186,35 +59,30 @@ export class ComputedSignal {
                 };
     }
     get() {
-        let prevTracked = false;
-        if (CURRENT_CONSUMER !== undefined && this._type !== 3 /* SignalType.Watcher */ && !CURRENT_SEEN.has(this)) {
+        if (CURRENT_CONSUMER !== undefined) {
+            const { _deps: deps, _computedCount: computedCount, _connectedCount: connectedCount } = CURRENT_CONSUMER;
+            const prevLink = deps.get(this);
             const ord = CURRENT_ORD++;
-            const nextDep = CURRENT_DEP_TAIL === undefined ? CURRENT_CONSUMER._deps : CURRENT_DEP_TAIL.nextDep;
-            let newLink = nextDep;
-            while (newLink !== undefined) {
-                if (newLink.dep === this) {
-                    prevTracked = true;
-                    if (CURRENT_DEP_TAIL === undefined) {
-                        CURRENT_CONSUMER._deps = newLink;
-                    }
-                    else {
-                        CURRENT_DEP_TAIL.nextDep = newLink;
-                    }
-                    newLink.ord = ord;
-                    newLink.nextDirty = undefined;
-                    if (this._subs === undefined) {
-                        this._subs = newLink;
-                    }
-                    break;
-                }
-                newLink = newLink.nextDep;
+            this._check(!prevLink && connectedCount > 0);
+            if (prevLink === undefined) {
+                const newLink = {
+                    dep: this,
+                    sub: CURRENT_CONSUMER._ref,
+                    ord,
+                    version: this._version,
+                    consumedAt: CURRENT_CONSUMER._computedCount,
+                    nextDirty: undefined,
+                };
+                deps.set(this, newLink);
+                this._subs.add(newLink);
+            }
+            else if (prevLink.consumedAt !== computedCount) {
+                prevLink.ord = ord;
+                prevLink.version = this._version;
+                prevLink.consumedAt = computedCount;
+                // prevLink.nextDirty = undefined;
+                this._subs.add(prevLink);
             }
-            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);
         }
         else {
             this._check();
@@ -222,6 +90,7 @@ export class ComputedSignal {
         return this._currentValue;
     }
     _check(shouldWatch = false) {
+        // COUNTS.checks++;
         let state = this._state;
         let connectedCount = this._connectedCount;
         const wasConnected = connectedCount > 0;
@@ -234,16 +103,11 @@ export class ComputedSignal {
                 state = 2 /* SignalState.Dirty */;
             }
             else {
-                let link = this._deps;
-                if (process.env.NODE_ENV !== 'production')
-                    checkForCircularLinks(link);
-                while (link !== undefined) {
-                    const dep = link.dep;
+                for (const [dep, link] of this._deps) {
                     if (link.version !== dep._check(true)) {
                         state = 2 /* SignalState.Dirty */;
                         break;
                     }
-                    link = link.nextDep;
                 }
             }
         }
@@ -262,7 +126,7 @@ export class ComputedSignal {
             }
         }
         if (state === 2 /* SignalState.Dirty */) {
-            this._run(wasConnected, connectedCount > 0, shouldConnect);
+            this._run(wasConnected, shouldConnect);
         }
         else {
             this._resetDirty();
@@ -271,20 +135,13 @@ export class ComputedSignal {
         this._dirtyDep = undefined;
         return this._version;
     }
-    _run(wasConnected, isConnected, shouldConnect) {
+    _run(wasConnected, shouldConnect) {
         const { _type: type } = this;
         const prevConsumer = CURRENT_CONSUMER;
-        const prevOrd = CURRENT_ORD;
-        const prevSeen = CURRENT_SEEN;
-        const prevDepTail = CURRENT_DEP_TAIL;
-        const prevIsWatched = CURRENT_IS_WATCHED;
         try {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             CURRENT_CONSUMER = this;
-            CURRENT_ORD = 0;
-            CURRENT_SEEN = new WeakSet();
-            CURRENT_DEP_TAIL = undefined;
-            CURRENT_IS_WATCHED = isConnected;
+            this._computedCount++;
             switch (type) {
                 case 0 /* SignalType.Computed */: {
                     const prevValue = this._currentValue;
@@ -391,39 +248,30 @@ export class ComputedSignal {
             }
         }
         finally {
-            endTrack(this, wasConnected);
+            const deps = this._deps;
+            for (const link of deps.values()) {
+                if (link.consumedAt === this._computedCount)
+                    continue;
+                const dep = link.dep;
+                if (wasConnected) {
+                    scheduleDisconnect(dep);
+                }
+                deps.delete(dep);
+                dep._subs.delete(link);
+            }
             CURRENT_CONSUMER = prevConsumer;
-            CURRENT_SEEN = prevSeen;
-            CURRENT_DEP_TAIL = prevDepTail;
-            CURRENT_ORD = prevOrd;
-            CURRENT_IS_WATCHED = prevIsWatched;
         }
     }
     _resetDirty() {
         let dirty = this._dirtyDep;
+        // COUNTS.dirtyResetIterations++;
         while (dirty !== undefined) {
-            const dep = dirty.dep;
-            const oldHead = dep._subs;
-            if (oldHead === undefined) {
-                dep._subs = dirty;
-                dirty.nextSub = undefined;
-                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);
-            }
+            // COUNTS.dirtyResetIterations++;
+            dirty.dep._subs.add(dirty);
             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 */) {
@@ -438,52 +286,41 @@ export class ComputedSignal {
         else {
             this._dirtyConsumers();
         }
-        this._subs = undefined;
     }
     _dirtyConsumers() {
-        let link = this._subs;
-        if (process.env.NODE_ENV !== 'production')
-            checkForCircularLinks(link);
-        while (link !== undefined) {
-            const consumer = link.sub.deref();
-            if (consumer === undefined) {
-                const nextSub = link.nextSub;
-                poolLink(link);
-                link = nextSub;
-                continue;
-            }
-            const state = consumer._state;
-            if (state === 2 /* SignalState.Dirty */) {
-                const nextSub = link.nextSub;
-                link = nextSub;
+        for (const link of this._subs.values()) {
+            const sub = link.sub.deref();
+            if (sub === undefined)
                 continue;
-            }
-            if (state === 1 /* SignalState.MaybeDirty */) {
-                let dirty = consumer._dirtyDep;
-                const ord = link.ord;
-                if (dirty.ord > ord) {
-                    consumer._dirtyDep = link;
-                    link.nextDirty = dirty;
-                }
-                else {
-                    let nextDirty = dirty.nextDirty;
-                    while (nextDirty !== undefined && nextDirty.ord < ord) {
-                        dirty = nextDirty;
-                        nextDirty = dirty.nextDirty;
+            switch (sub._state) {
+                case 1 /* SignalState.MaybeDirty */: {
+                    let dirty = sub._dirtyDep;
+                    const ord = link.ord;
+                    if (dirty.ord > ord) {
+                        sub._dirtyDep = link;
+                        link.nextDirty = dirty;
                     }
-                    link.nextDirty = nextDirty;
-                    dirty.nextDirty = link;
+                    else {
+                        let nextDirty = dirty.nextDirty;
+                        while (nextDirty !== undefined && nextDirty.ord < ord) {
+                            // COUNTS.dirtyInsertIterations++;
+                            dirty = nextDirty;
+                            nextDirty = dirty.nextDirty;
+                        }
+                        link.nextDirty = nextDirty;
+                        dirty.nextDirty = link;
+                    }
+                    break;
+                }
+                case 0 /* SignalState.Clean */: {
+                    sub._state = 1 /* SignalState.MaybeDirty */;
+                    sub._dirtyDep = link;
+                    link.nextDirty = undefined;
+                    sub._dirty();
                 }
             }
-            else {
-                // consumer._dirtyQueueLength = dirtyQueueLength + 2;
-                consumer._state = 1 /* SignalState.MaybeDirty */;
-                consumer._dirtyDep = link;
-                link.nextDirty = undefined;
-                consumer._dirty();
-            }
-            link = link.nextSub;
         }
+        this._subs = new Set();
     }
     _disconnect(count = 1) {
         this._connectedCount -= count;
@@ -500,25 +337,23 @@ export class ComputedSignal {
                 SUBSCRIPTIONS.delete(this);
             }
         }
-        let link = this._deps;
-        while (link !== undefined) {
+        for (const link of this._deps.values()) {
             const dep = link.dep;
             dep._disconnect();
-            link = link.nextDep;
         }
     }
 }
 class StateSignal {
     _value;
     _equals;
-    _consumers = [];
+    _subs = [];
     constructor(_value, _equals = (a, b) => a === b) {
         this._value = _value;
         this._equals = _equals;
     }
     get() {
         if (CURRENT_CONSUMER !== undefined) {
-            this._consumers.push(CURRENT_CONSUMER._ref);
+            this._subs.push(CURRENT_CONSUMER._ref);
         }
         return this._value;
     }
@@ -527,16 +362,24 @@ class StateSignal {
             return;
         }
         this._value = value;
-        const { _consumers: consumers } = this;
-        for (const consumerRef of consumers) {
-            const consumer = consumerRef.deref();
-            if (consumer === undefined) {
+        const subs = this._subs;
+        const subsLength = subs.length;
+        for (let i = 0; i < subsLength; i++) {
+            const sub = subs[i].deref();
+            if (sub === undefined) {
                 continue;
             }
-            consumer._state = 2 /* SignalState.Dirty */;
-            consumer._dirty();
+            switch (sub._state) {
+                case 0 /* SignalState.Clean */:
+                    sub._state = 2 /* SignalState.Dirty */;
+                    sub._dirty();
+                    break;
+                case 1 /* SignalState.MaybeDirty */:
+                    sub._state = 2 /* SignalState.Dirty */;
+                    break;
+            }
         }
-        consumers.length = 0;
+        this._subs = [];
     }
 }
 export function state(initialValue, opts) {
@@ -552,7 +395,7 @@ export function subscription(subscribe, opts) {
     return new ComputedSignal(1 /* SignalType.Subscription */, subscribe, opts?.equals, opts?.initValue);
 }
 export function watcher(fn) {
-    const subscribers = new Set();
+    const subscribers = [];
     const watcher = new ComputedSignal(3 /* SignalType.Watcher */, () => {
         fn();
         untrack(() => {
@@ -567,9 +410,9 @@ export function watcher(fn) {
             scheduleDisconnect(watcher);
         },
         subscribe(subscriber) {
-            subscribers.add(subscriber);
+            subscribers.push(subscriber);
             return () => {
-                subscribers.delete(subscriber);
+                subscribers.splice(subscribers.indexOf(subscriber), 1);
             };
         },
     };
@@ -579,18 +422,12 @@ export function isTracking() {
 }
 export function untrack(fn) {
     const prevConsumer = CURRENT_CONSUMER;
-    const prevOrd = CURRENT_ORD;
-    const prevIsWatched = CURRENT_IS_WATCHED;
     try {
         CURRENT_CONSUMER = undefined;
         // LAST_CONSUMED = undefined;
-        CURRENT_ORD = 0;
-        CURRENT_IS_WATCHED = false;
         return fn();
     }
     finally {
         CURRENT_CONSUMER = prevConsumer;
-        CURRENT_ORD = prevOrd;
-        CURRENT_IS_WATCHED = prevIsWatched;
     }
 }

package/package.json

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