signalium 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# signalium
+
+## 0.1.0
+
+### Minor Changes
+
+- 03b2d2b: Initial release
+
+### Patch Changes
+
+- a472569: Fix release and build, add linting

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+export type FlushCallback = () => Promise<void>;
+export declare let scheduleWatchers: (flushWatchers: FlushCallback) => void;
+export declare let scheduleDisconnects: (flushDisconnects: FlushCallback) => void;

package/dist/config.js

@@ -0,0 +1,19 @@
+let currentWatcherFlush = null;
+let currentDisconnectFlush = null;
+const idleCallback = typeof requestIdleCallback === 'function' ? requestIdleCallback : (cb) => setTimeout(cb, 0);
+export let scheduleWatchers = flushWatchers => {
+    if (currentWatcherFlush !== null)
+        return;
+    currentWatcherFlush = setTimeout(() => {
+        currentWatcherFlush = null;
+        flushWatchers();
+    }, 0);
+};
+export let scheduleDisconnects = flushDisconnects => {
+    if (currentDisconnectFlush !== null)
+        return;
+    currentDisconnectFlush = idleCallback(() => {
+        currentDisconnectFlush = null;
+        flushDisconnects();
+    });
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { Signal, WriteableSignal, SignalCompute, SignalAsyncCompute, SignalSubscribe, SignalEquals, SignalOptions, SignalOptionsWithInit, SignalSubscription, SignalWatcherEffect, AsyncPending, AsyncReady, AsyncResult, } from './signals.js';
+export { state, computed, asyncComputed, subscription, watcher } from './signals.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { state, computed, asyncComputed, subscription, watcher } from './signals.js';

package/dist/scheduling.d.ts

@@ -0,0 +1,3 @@
+import type { ComputedSignal } from './signals.js';
+export declare const scheduleWatcher: (watcher: ComputedSignal<any>) => void;
+export declare const scheduleDisconnect: (disconnect: ComputedSignal<any>) => void;

package/dist/scheduling.js

@@ -0,0 +1,36 @@
+import { scheduleWatchers, scheduleDisconnects } from './config.js';
+let PENDING_FLUSH_WATCHERS = null;
+const PENDING_WATCHERS = [];
+const PENDING_DISCONNECTS = new Map();
+export const scheduleWatcher = (watcher) => {
+    PENDING_WATCHERS.push(watcher);
+    if (PENDING_FLUSH_WATCHERS === null) {
+        let resolve;
+        const promise = new Promise(r => {
+            resolve = r;
+        });
+        PENDING_FLUSH_WATCHERS = { promise, resolve: resolve };
+    }
+    scheduleWatchers(flushWatchers);
+};
+const flushWatchers = async () => {
+    PENDING_FLUSH_WATCHERS.resolve();
+    PENDING_FLUSH_WATCHERS = null;
+    let watcher;
+    while ((watcher = PENDING_WATCHERS.shift())) {
+        watcher._check();
+    }
+    PENDING_WATCHERS.length = 0;
+};
+export const scheduleDisconnect = (disconnect) => {
+    const current = PENDING_DISCONNECTS.get(disconnect) ?? 0;
+    PENDING_DISCONNECTS.set(disconnect, current + 1);
+    scheduleDisconnects(flushDisconnects);
+};
+const flushDisconnects = async () => {
+    await PENDING_FLUSH_WATCHERS?.promise;
+    for (const [signal, count] of PENDING_DISCONNECTS) {
+        signal._disconnect(count);
+    }
+    PENDING_DISCONNECTS.clear();
+};

package/dist/signals.d.ts

@@ -0,0 +1,103 @@
+declare const enum SignalType {
+    Computed = 0,
+    Subscription = 1,
+    Async = 2,
+    Watcher = 3
+}
+export interface Signal<T = unknown> {
+    get(): T;
+}
+export interface WriteableSignal<T> extends Signal<T> {
+    set(value: T): void;
+}
+export type SignalCompute<T> = (prev: T | undefined) => T;
+export type SignalAsyncCompute<T> = (prev: T | undefined) => T | Promise<T>;
+export type SignalWatcherEffect = () => void;
+export type SignalEquals<T> = (prev: T, next: T) => boolean;
+export type SignalSubscription = {
+    update?(): void;
+    unsubscribe?(): void;
+};
+export type SignalSubscribe<T> = (get: () => T, set: (value: T) => void) => SignalSubscription | undefined | void;
+export interface SignalOptions<T> {
+    equals?: SignalEquals<T>;
+}
+export interface SignalOptionsWithInit<T> extends SignalOptions<T> {
+    initValue: T;
+}
+declare const enum SignalState {
+    Clean = 0,
+    MaybeDirty = 1,
+    Dirty = 2
+}
+interface Link {
+    sub: WeakRef<ComputedSignal<any>>;
+    dep: ComputedSignal<any>;
+    ord: number;
+    version: number;
+    nextDep: Link | undefined;
+    nextSub: Link | undefined;
+    prevSub: Link | undefined;
+    nextDirty: Link | undefined;
+}
+export declare function endTrack(sub: ComputedSignal<any>, shouldDisconnect: boolean): void;
+export declare class ComputedSignal<T> {
+    id: number;
+    _type: SignalType;
+    _subs: Link | undefined;
+    _subsTail: Link | undefined;
+    _deps: Link | undefined;
+    _dirtyDep: Link | undefined;
+    _state: SignalState;
+    _version: number;
+    _connectedCount: number;
+    _currentValue: T | AsyncResult<T> | undefined;
+    _compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T> | undefined;
+    _equals: SignalEquals<T>;
+    _ref: WeakRef<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;
+    _resetDirty(): void;
+    _dirty(): void;
+    _dirtyConsumers(): void;
+    _disconnect(count?: number): void;
+}
+export interface AsyncPending {
+    result: undefined;
+    error: unknown;
+    isPending: boolean;
+    isReady: false;
+    isError: boolean;
+    isSuccess: boolean;
+}
+export interface AsyncReady<T> {
+    result: T;
+    error: unknown;
+    isPending: boolean;
+    isReady: true;
+    isError: boolean;
+    isSuccess: boolean;
+}
+export type AsyncResult<T> = AsyncPending | AsyncReady<T>;
+declare class StateSignal<T> implements StateSignal<T> {
+    private _value;
+    private _equals;
+    private _consumers;
+    constructor(_value: T, _equals?: SignalEquals<T>);
+    get(): T;
+    set(value: T): void;
+}
+export declare function state<T>(initialValue: T, opts?: SignalOptions<T>): StateSignal<T>;
+export declare function computed<T>(compute: (prev: T | undefined) => T, opts?: SignalOptions<T>): Signal<T>;
+export declare function asyncComputed<T>(compute: (prev: T | undefined) => Promise<T>, opts?: SignalOptions<T>): Signal<AsyncResult<T>>;
+export declare function asyncComputed<T>(compute: (prev: T | undefined) => Promise<T>, opts: SignalOptionsWithInit<T>): Signal<AsyncReady<T>>;
+export declare function subscription<T>(subscribe: SignalSubscribe<T>, opts?: SignalOptions<T>): Signal<T | undefined>;
+export declare function subscription<T>(subscribe: SignalSubscribe<T>, opts: SignalOptionsWithInit<T>): Signal<T>;
+export interface Watcher {
+    disconnect(): void;
+}
+export declare function watcher(fn: () => void): Watcher;
+export declare function untrack<T = void>(fn: () => T): T;
+export {};

package/dist/signals.js

@@ -0,0 +1,474 @@
+import { scheduleDisconnect, scheduleWatcher } from './scheduling.js';
+let CURRENT_CONSUMER;
+let CURRENT_DEP_TAIL;
+let CURRENT_ORD = 0;
+let CURRENT_IS_WATCHED = false;
+let CURRENT_SEEN;
+let id = 0;
+const SUBSCRIPTIONS = new WeakMap();
+let linkPool;
+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 = {
+            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);
+}
+// const registry = new FinalizationRegistry(poolLink);
+export class ComputedSignal {
+    id = id++;
+    _type;
+    _subs;
+    _subsTail;
+    _deps;
+    _dirtyDep;
+    _state = 2 /* SignalState.Dirty */;
+    _version = 0;
+    _connectedCount;
+    _currentValue;
+    _compute;
+    _equals;
+    _ref = new WeakRef(this);
+    constructor(type, compute, equals, initValue) {
+        this._type = type;
+        this._compute = compute;
+        this._equals = equals ?? ((a, b) => a === b);
+        this._currentValue = initValue;
+        this._connectedCount = type === 3 /* SignalType.Watcher */ ? 1 : 0;
+    }
+    get() {
+        let prevTracked = false;
+        if (CURRENT_CONSUMER !== undefined && this._type !== 3 /* SignalType.Watcher */ && !CURRENT_SEEN.has(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(CURRENT_IS_WATCHED && !prevTracked);
+            CURRENT_DEP_TAIL = newLink ?? linkNewDep(this, CURRENT_CONSUMER, nextDep, CURRENT_DEP_TAIL, ord);
+            CURRENT_DEP_TAIL.version = this._version;
+            CURRENT_SEEN.add(this);
+        }
+        else {
+            this._check();
+        }
+        return this._currentValue;
+    }
+    _check(shouldWatch = false) {
+        let state = this._state;
+        let connectedCount = this._connectedCount;
+        const wasConnected = connectedCount > 0;
+        const shouldConnect = shouldWatch && !wasConnected;
+        if (shouldWatch) {
+            this._connectedCount = connectedCount = connectedCount + 1;
+        }
+        if (shouldConnect) {
+            if (this._type === 1 /* SignalType.Subscription */) {
+                state = 2 /* SignalState.Dirty */;
+            }
+            else {
+                let link = this._deps;
+                while (link !== undefined) {
+                    const dep = link.dep;
+                    if (link.version !== dep._check(true)) {
+                        state = 2 /* SignalState.Dirty */;
+                        break;
+                    }
+                    link = link.nextDep;
+                }
+            }
+            this._resetDirty();
+        }
+        if (state === 0 /* SignalState.Clean */) {
+            return this._version;
+        }
+        if (state === 1 /* SignalState.MaybeDirty */) {
+            let dirty = this._dirtyDep;
+            while (dirty !== undefined) {
+                const dep = dirty.dep;
+                if (dirty.version !== dep._check()) {
+                    state = 2 /* SignalState.Dirty */;
+                    break;
+                }
+                dirty = dirty.nextDirty;
+            }
+        }
+        if (state === 2 /* SignalState.Dirty */) {
+            this._run(wasConnected, connectedCount > 0, shouldConnect);
+        }
+        else {
+            this._resetDirty();
+        }
+        this._state = 0 /* SignalState.Clean */;
+        this._dirtyDep = undefined;
+        return this._version;
+    }
+    _run(wasConnected, isConnected, 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;
+            switch (type) {
+                case 0 /* SignalType.Computed */: {
+                    const prevValue = this._currentValue;
+                    const nextValue = this._compute(prevValue);
+                    if (!this._equals(prevValue, nextValue)) {
+                        this._currentValue = nextValue;
+                        this._version++;
+                    }
+                    break;
+                }
+                case 2 /* SignalType.Async */: {
+                    const value = this._currentValue ??
+                        (this._currentValue = {
+                            result: undefined,
+                            error: undefined,
+                            isPending: true,
+                            isReady: false,
+                            isError: false,
+                            isSuccess: false,
+                        });
+                    const nextValue = this._compute(value?.result);
+                    if ('then' in nextValue) {
+                        const currentVersion = ++this._version;
+                        nextValue.then(result => {
+                            if (currentVersion !== this._version) {
+                                return;
+                            }
+                            value.result = result;
+                            value.isReady = true;
+                            value.isPending = false;
+                            value.isSuccess = true;
+                            this._version++;
+                            this._dirtyConsumers();
+                        }, error => {
+                            if (currentVersion !== this._version) {
+                                return;
+                            }
+                            value.error = error;
+                            value.isPending = false;
+                            value.isError = true;
+                            this._version++;
+                            this._dirtyConsumers();
+                        });
+                        value.isPending = true;
+                        value.isError = false;
+                        value.isSuccess = false;
+                    }
+                    else {
+                        value.result = nextValue;
+                        value.isReady = true;
+                        value.isPending = false;
+                        value.isSuccess = true;
+                        value.isError = false;
+                        this._version++;
+                    }
+                    break;
+                }
+                case 1 /* SignalType.Subscription */: {
+                    if (shouldConnect) {
+                        const subscription = this._compute(() => this._currentValue, value => {
+                            if (this._equals(value, this._currentValue)) {
+                                return;
+                            }
+                            this._currentValue = value;
+                            this._version++;
+                            this._dirtyConsumers();
+                        });
+                        SUBSCRIPTIONS.set(this, subscription);
+                    }
+                    else {
+                        const subscription = SUBSCRIPTIONS.get(this);
+                        subscription?.update?.();
+                    }
+                    break;
+                }
+                default: {
+                    this._compute();
+                }
+            }
+        }
+        finally {
+            endTrack(this, wasConnected);
+            CURRENT_CONSUMER = prevConsumer;
+            CURRENT_SEEN = prevSeen;
+            CURRENT_DEP_TAIL = prevDepTail;
+            CURRENT_ORD = prevOrd;
+            CURRENT_IS_WATCHED = prevIsWatched;
+        }
+    }
+    _resetDirty() {
+        let dirty = this._dirtyDep;
+        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;
+                oldHead.prevSub = dirty;
+                dep._subs = dirty;
+            }
+            let nextDirty = dirty.nextDirty;
+            dirty.nextDirty = undefined;
+            dirty = nextDirty;
+        }
+    }
+    _dirty() {
+        if (this._type === 1 /* SignalType.Subscription */) {
+            if (this._connectedCount > 0) {
+                scheduleWatcher(this);
+            }
+            // else do nothing, only schedule if connected
+        }
+        else if (this._type === 3 /* SignalType.Watcher */) {
+            scheduleWatcher(this);
+        }
+        else {
+            this._dirtyConsumers();
+        }
+        this._subs = undefined;
+    }
+    _dirtyConsumers() {
+        let link = this._subs;
+        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;
+                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;
+                    }
+                    link.nextDirty = nextDirty;
+                    dirty.nextDirty = link;
+                }
+            }
+            else {
+                // consumer._dirtyQueueLength = dirtyQueueLength + 2;
+                consumer._state = 1 /* SignalState.MaybeDirty */;
+                consumer._dirtyDep = link;
+                link.nextDirty = undefined;
+                consumer._dirty();
+            }
+            link = link.nextSub;
+        }
+    }
+    _disconnect(count = 1) {
+        this._connectedCount -= count;
+        if (this._connectedCount > 0) {
+            return;
+        }
+        else if (this._connectedCount < 0) {
+            throw new Error('Signal disconnect count cannot be negative');
+        }
+        if (this._type === 1 /* SignalType.Subscription */) {
+            const subscription = SUBSCRIPTIONS.get(this);
+            if (subscription !== undefined) {
+                subscription.unsubscribe?.();
+                SUBSCRIPTIONS.delete(this);
+            }
+        }
+        let link = this._deps;
+        while (link !== undefined) {
+            const dep = link.dep;
+            dep._disconnect();
+            link = link.nextDep;
+        }
+    }
+}
+class StateSignal {
+    _value;
+    _equals;
+    _consumers = [];
+    constructor(_value, _equals = (a, b) => a === b) {
+        this._value = _value;
+        this._equals = _equals;
+    }
+    get() {
+        if (CURRENT_CONSUMER !== undefined) {
+            this._consumers.push(CURRENT_CONSUMER._ref);
+        }
+        return this._value;
+    }
+    set(value) {
+        if (this._equals(value, this._value)) {
+            return;
+        }
+        this._value = value;
+        const { _consumers: consumers } = this;
+        for (const consumerRef of consumers) {
+            const consumer = consumerRef.deref();
+            if (consumer === undefined) {
+                continue;
+            }
+            consumer._state = 2 /* SignalState.Dirty */;
+            consumer._dirty();
+        }
+        consumers.length = 0;
+    }
+}
+export function state(initialValue, opts) {
+    return new StateSignal(initialValue, opts?.equals);
+}
+export function computed(compute, opts) {
+    return new ComputedSignal(0 /* SignalType.Computed */, compute, opts?.equals);
+}
+export function asyncComputed(compute, opts) {
+    return new ComputedSignal(2 /* SignalType.Async */, compute, opts?.equals, opts?.initValue);
+}
+export function subscription(subscribe, opts) {
+    return new ComputedSignal(1 /* SignalType.Subscription */, subscribe, opts?.equals, opts?.initValue);
+}
+export function watcher(fn) {
+    const watcher = new ComputedSignal(3 /* SignalType.Watcher */, fn);
+    scheduleWatcher(watcher);
+    return {
+        disconnect() {
+            scheduleDisconnect(watcher);
+        },
+    };
+}
+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

@@ -0,0 +1,31 @@
+{
+  "name": "signalium",
+  "version": "0.1.0",
+  "type": "module",
+  "repository": "https://github.com/pzuraq/signalium",
+  "description": "Chain-reactivity at critical mass",
+  "exports": {
+    ".": {
+      "import": {
+        "development": "./src/index.ts",
+        "default": "./dist/index.js"
+      },
+      "types": {
+        "development": "./src/index.ts",
+        "default": "./dist/index.d.ts"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "dev": "vitest",
+    "test": "vitest run",
+    "build": "tsc"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "vite": "^5.4.8",
+    "vitest": "^2.1.2"
+  }
+}