@esportsplus/reactivity 0.36.7 → 0.37.1

package/src/compiler/primitives.ts

@@ -2,79 +2,26 @@ import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants';
 import type { Bindings, IsReactiveCall } from './types';
+import scope from './bindings';
 
 
-interface ScopeBinding {
-    depth: number;
-    name: string;
-    scope: ts.Node;
-    type: TYPES;
-}
+type PrimitivesTransformResult = {
+    calls: ts.CallExpression[];
+    replacements: ReplacementIntent[];
+};
 
-interface TransformContext {
+type TransformContext = {
     bindings: Bindings;
     calls: ts.CallExpression[];
     isReactiveCall: IsReactiveCall;
     replacements: ReplacementIntent[];
-    scopedBindings: ScopeBinding[];
-    sourceFile: ts.SourceFile;
     tmpCounter: number;
-}
-
-type PrimitivesTransformResult = {
-    calls: ts.CallExpression[];
-    replacements: ReplacementIntent[];
 };
 
 
-function inScope(reference: ts.Node, binding: ScopeBinding): boolean {
-    let current: ts.Node | undefined = reference;
-
-    while (current) {
-        if (current === binding.scope) {
-            return true;
-        }
-
-        current = current.parent;
-    }
-
-    return false;
-}
-
-function isScope(node: ts.Node): boolean {
-    return ts.isArrowFunction(node) ||
-        ts.isBlock(node) ||
-        ts.isCatchClause(node) ||
-        ts.isForInStatement(node) ||
-        ts.isForOfStatement(node) ||
-        ts.isForStatement(node) ||
-        ts.isFunctionDeclaration(node) ||
-        ts.isFunctionExpression(node) ||
-        ts.isSourceFile(node);
-}
-
-// Innermost enclosing scope plus its nesting depth, so shadowed names resolve to the closest binding
-function scopeOf(node: ts.Node): { depth: number; scope: ts.Node } {
-    let current: ts.Node | undefined = node.parent,
-        depth = 0,
-        scope: ts.Node = node.getSourceFile();
-
-    while (current) {
-        if (isScope(current)) {
-            if (scope === node.getSourceFile() && !ts.isSourceFile(current)) {
-                scope = current;
-            }
-
-            depth++;
-        }
-
-        current = current.parent;
-    }
-
-    return { depth, scope };
-}
-
-function visit(ctx: TransformContext, node: ts.Node): void {
+// Pass 1: record every reactive() call and the variable each signal/computed is bound to, before
+// any reference is rewritten — a use that precedes its declaration in source order still resolves
+function declare(ctx: TransformContext, node: ts.Node): void {
     if (ctx.isReactiveCall(node)) {
         let call = node;
 
@@ -99,160 +46,217 @@ function visit(ctx: TransformContext, node: ts.Node): void {
                 }
                 // Dynamic expression - use runtime reactive via namespace
                 else if (ts.isCallExpression(unwrapped) || ts.isIdentifier(unwrapped)) {
+                    classification = null;
                     ctx.replacements.push({
                         generate: () => `${NAMESPACE}.reactive`,
                         node: call.expression
                     });
-                    node.forEachChild(n => visit(ctx, n));
-                    return;
                 }
             }
 
-            if (classification) {
-                let varname: string | null = null;
+            if (classification !== null) {
+                let target = targetOf(call),
+                    type = classification;
 
-                if (call.parent && ts.isVariableDeclaration(call.parent) && ts.isIdentifier(call.parent.name)) {
-                    varname = call.parent.name.text;
-                }
-                else if (
-                    call.parent &&
-                    ts.isBinaryExpression(call.parent) &&
-                    call.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-                    ts.isIdentifier(call.parent.left)
-                ) {
-                    varname = call.parent.left.text;
-                }
-
-                if (varname) {
-                    let { depth, scope } = scopeOf(call);
-
-                    ctx.bindings.set(varname, classification);
-                    ctx.scopedBindings.push({ depth, name: varname, scope, type: classification });
+                if (target) {
+                    scope.declare(ctx.bindings, target, type);
                 }
 
                 // Replace just the 'reactive' identifier with the appropriate namespace function
                 ctx.replacements.push({
-                    generate: () => classification === TYPES.Computed
+                    generate: () => type === TYPES.Computed
                         ? `${NAMESPACE}.computed`
                         : `${NAMESPACE}.signal`,
                     node: call.expression
                 });
-
-                // Continue visiting children - inner identifiers will get their own ReplacementIntents
             }
         }
     }
 
+    node.forEachChild(child => declare(ctx, child));
+}
+
+// A name slot rather than a value reference: a declaration's or member's own name, a property
+// name (`o.count`, `{ count: 1 }`, `{ count: local } = o`), or a label. A shorthand property's
+// name doubles as a read of the variable, so it is not a name slot. (TS 7's `isDeclarationName`
+// only tests the node kind, so it is true for every identifier and cannot be used here.)
+function isName(node: ts.Identifier, parent: ts.Node): boolean {
+    if (ts.isShorthandPropertyAssignment(parent)) {
+        return false;
+    }
+
+    let slots = parent as { label?: ts.Node; name?: ts.Node; propertyName?: ts.Node };
+
+    return slots.name === node || slots.propertyName === node || slots.label === node;
+}
+
+// Destructuring assignment targets (`({ count } = o)`, `[count] = xs`) write through a pattern
+// that has no per-signal rewrite, so they are left untouched
+function isPatternTarget(node: ts.Node): boolean {
+    let current = node;
+
+    while (
+        current.parent &&
+        (
+            ts.isShorthandPropertyAssignment(current.parent) ||
+            ts.isPropertyAssignment(current.parent) ||
+            ts.isSpreadAssignment(current.parent) ||
+            ts.isSpreadElement(current.parent) ||
+            ts.isObjectLiteralExpression(current.parent) ||
+            ts.isArrayLiteralExpression(current.parent)
+        )
+    ) {
+        current = current.parent;
+    }
+
+    let parent = current.parent;
+
+    if (current === node || !parent) {
+        return false;
+    }
+
+    return (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.left === current) ||
+        ((ts.isForOfStatement(parent) || ts.isForInStatement(parent)) && parent.initializer === current);
+}
+
+function reference(ctx: TransformContext, node: ts.Identifier): void {
+    let parent = node.parent;
+
+    if (!parent || ts.isExportSpecifier(parent) || ts.isImportSpecifier(parent) || isName(node, parent)) {
+        return;
+    }
+
+    let binding = scope.resolve(ctx.bindings, node);
+
+    if (!binding || binding.type === TYPES.Array) {
+        return;
+    }
+
     if (
-        ts.isIdentifier(node) &&
-        node.parent &&
-        !(ts.isVariableDeclaration(node.parent) && node.parent.name === node)
+        (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.left === node && ctx.isReactiveCall(parent.right)) ||
+        (ts.isTypeOfExpression(parent) && parent.expression === node) ||
+        isPatternTarget(node)
     ) {
-        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            node.forEachChild(n => visit(ctx, n));
-            return;
-        }
+        return;
+    }
 
-        let bindings = ctx.scopedBindings,
-            binding,
-            name = node.text;
+    let name = node.text;
 
-        for (let i = 0, n = bindings.length; i < n; i++) {
-            let b = bindings[i];
+    if (ts.isShorthandPropertyAssignment(parent)) {
+        ctx.replacements.push({
+            generate: () => `${name}: ${NAMESPACE}.read(${name})`,
+            node: parent
+        });
 
-            if (b.name === name && (!binding || b.depth >= binding.depth) && inScope(node, b)) {
-                binding = b;
-            }
+        return;
+    }
+
+    let writeCtx: 'compound' | 'increment' | 'simple' | undefined;
+
+    if (ts.isBinaryExpression(parent) && parent.left === node) {
+        let op = parent.operatorToken.kind;
+
+        if (op === ts.SyntaxKind.EqualsToken) {
+            writeCtx = 'simple';
+        }
+        else if (COMPOUND_OPERATORS.has(op)) {
+            writeCtx = 'compound';
         }
+    }
+    else if (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) {
+        let op = parent.operator;
 
-        if (binding && node.parent) {
-            let parent = node.parent;
-
-            if (
-                !(
-                    ts.isBinaryExpression(parent) &&
-                    parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-                    ctx.isReactiveCall(parent.right)
-                ) &&
-                !(ts.isTypeOfExpression(parent) && parent.expression === node)
-            ) {
-                let writeCtx;
-
-                if (ts.isBinaryExpression(parent) && parent.left === node) {
-                    let op = parent.operatorToken.kind;
-
-                    if (op === ts.SyntaxKind.EqualsToken) {
-                        writeCtx = 'simple';
-                    }
-                    else if (COMPOUND_OPERATORS.has(op)) {
-                        writeCtx = 'compound';
-                    }
-                }
-                else if (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) {
-                    let op = parent.operator;
+        if (op === ts.SyntaxKind.MinusMinusToken || op === ts.SyntaxKind.PlusPlusToken) {
+            writeCtx = 'increment';
+        }
+    }
 
-                    if (op === ts.SyntaxKind.MinusMinusToken || op === ts.SyntaxKind.PlusPlusToken) {
-                        writeCtx = 'increment';
-                    }
-                }
+    if (!writeCtx) {
+        ctx.replacements.push({
+            generate: () => `${NAMESPACE}.read(${name})`,
+            node
+        });
 
-                if (writeCtx) {
-                    if (binding.type !== TYPES.Computed) {
-                        if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
-                            let right = parent.right;
-
-                            ctx.replacements.push({
-                                generate: (sf) => `${NAMESPACE}.write(${name}, ${right.getText(sf)})`,
-                                node: parent
-                            });
-                        }
-                        else if (writeCtx === 'compound' && ts.isBinaryExpression(parent)) {
-                            let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind) ?? '+',
-                                right = parent.right;
-
-                            ctx.replacements.push({
-                                generate: (sf) => `${NAMESPACE}.write(${name}, ${name}.value ${op} ${right.getText(sf)})`,
-                                node: parent
-                            });
-                        }
-                        else if (writeCtx === 'increment') {
-                            let delta = (parent as ts.PostfixUnaryExpression | ts.PrefixUnaryExpression).operator === ts.SyntaxKind.PlusPlusToken ? '+ 1' : '- 1',
-                                isPrefix = ts.isPrefixUnaryExpression(parent);
-
-                            if (ts.isExpressionStatement(parent.parent)) {
-                                ctx.replacements.push({
-                                    generate: () => `${NAMESPACE}.write(${name}, ${name}.value ${delta})`,
-                                    node: parent
-                                });
-                            }
-                            else if (isPrefix) {
-                                ctx.replacements.push({
-                                    generate: () => `(${NAMESPACE}.write(${name}, ${name}.value ${delta}), ${name}.value)`,
-                                    node: parent
-                                });
-                            }
-                            else {
-                                let tmp = `_t${ctx.tmpCounter++}`;
-
-                                ctx.replacements.push({
-                                    generate: () => `((${tmp}) => (${NAMESPACE}.write(${name}, ${tmp} ${delta}), ${tmp}))(${name}.value)`,
-                                    node: parent
-                                });
-                            }
-                        }
-                    }
-                }
-                else {
-                    ctx.replacements.push({
-                        generate: () => `${NAMESPACE}.read(${name})`,
-                        node
-                    });
-                }
-            }
+        return;
+    }
+
+    if (binding.type === TYPES.Computed) {
+        return;
+    }
+
+    if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
+        let right = parent.right;
+
+        ctx.replacements.push({
+            generate: (sf) => `${NAMESPACE}.write(${name}, ${right.getText(sf)})`,
+            node: parent
+        });
+    }
+    else if (writeCtx === 'compound' && ts.isBinaryExpression(parent)) {
+        let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind) ?? '+',
+            right = parent.right;
+
+        ctx.replacements.push({
+            generate: (sf) => `${NAMESPACE}.write(${name}, ${name}.value ${op} ${right.getText(sf)})`,
+            node: parent
+        });
+    }
+    else if (writeCtx === 'increment') {
+        let unary = parent as ts.PostfixUnaryExpression | ts.PrefixUnaryExpression,
+            delta = unary.operator === ts.SyntaxKind.PlusPlusToken ? '+ 1' : '- 1';
+
+        if (ts.isExpressionStatement(unary.parent)) {
+            ctx.replacements.push({
+                generate: () => `${NAMESPACE}.write(${name}, ${name}.value ${delta})`,
+                node: unary
+            });
+        }
+        else if (ts.isPrefixUnaryExpression(unary)) {
+            ctx.replacements.push({
+                generate: () => `(${NAMESPACE}.write(${name}, ${name}.value ${delta}), ${name}.value)`,
+                node: unary
+            });
         }
+        else {
+            let tmp = `_t${ctx.tmpCounter++}`;
+
+            ctx.replacements.push({
+                generate: () => `((${tmp}) => (${NAMESPACE}.write(${name}, ${tmp} ${delta}), ${tmp}))(${name}.value)`,
+                node: unary
+            });
+        }
+    }
+}
+
+// Pass 2: rewrite reads and writes of every signal/computed binding. Type positions never read a
+// value, so they are not walked at all.
+function rewrite(ctx: TransformContext, node: ts.Node): void {
+    if (ts.isTypeNode(node)) {
+        return;
+    }
+
+    if (ts.isIdentifier(node)) {
+        reference(ctx, node);
+
+        return;
+    }
+
+    node.forEachChild(child => rewrite(ctx, child));
+}
+
+// The variable a reactive() call initializes: `let x = reactive(...)` or `x = reactive(...)`
+function targetOf(call: ts.CallExpression): ts.Identifier | null {
+    let parent = call.parent;
+
+    if (parent && ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+        return parent.name;
+    }
+
+    if (parent && ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(parent.left)) {
+        return parent.left;
     }
 
-    node.forEachChild(n => visit(ctx, n));
+    return null;
 }
 
 
@@ -262,12 +266,11 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: I
             calls: [],
             isReactiveCall,
             replacements: [],
-            scopedBindings: [],
-            sourceFile,
             tmpCounter: 0
         };
 
-    visit(ctx, sourceFile);
+    declare(ctx, sourceFile);
+    rewrite(ctx, sourceFile);
 
     return { calls: ctx.calls, replacements: ctx.replacements };
 };

package/src/compiler/types.ts

@@ -1,8 +1,13 @@
 import type { ts } from '@esportsplus/typescript';
-import { TYPES } from './constants';
+import type { TYPES } from './constants';
 
 
-type Bindings = Map<string, TYPES>;
+type Bindings = {
+    checker: ts.Checker;
+    names: Set<string>;
+    paths: Map<ts.Symbol, Set<string>>;
+    symbols: Map<ts.Symbol, TYPES>;
+};
 
 type IsReactiveCall = (node: ts.Node) => node is ts.CallExpression;
 

package/src/constants.ts

@@ -1,12 +1,12 @@
-const COMPUTED = Symbol('reactivity.computed');
-
 const PACKAGE_NAME = '@esportsplus/reactivity';
 
-const REACTIVE_ARRAY = Symbol('reactivity.reactive.array');
+const COMPUTED = Symbol.for(`${PACKAGE_NAME}/computed`);
+
+const REACTIVE_ARRAY = Symbol.for(`${PACKAGE_NAME}/reactive.array`);
 
-const REACTIVE_OBJECT = Symbol('reactivity.reactive.object');
+const REACTIVE_OBJECT = Symbol.for(`${PACKAGE_NAME}/reactive.object`);
 
-const SIGNAL = Symbol('reactivity.signal');
+const SIGNAL = Symbol.for(`${PACKAGE_NAME}/signal`);
 
 const STABILIZER_DEFERRED = 4;
 

package/src/reactive/array.ts

@@ -240,14 +240,16 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     pop() {
-        let item = super.pop();
-
-        if (item !== undefined) {
-            dispose(item);
-            write(this._length, this.length);
-            this.dispatch('pop', { item });
+        if (this.length === 0) {
+            return undefined;
         }
 
+        let item = super.pop() as T;
+
+        dispose(item);
+        write(this._length, this.length);
+        this.dispatch('pop', { item });
+
         return item;
     }
 
@@ -273,14 +275,16 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     shift() {
-        let item = super.shift();
-
-        if (item !== undefined) {
-            dispose(item);
-            write(this._length, this.length);
-            this.dispatch('shift', { item });
+        if (this.length === 0) {
+            return undefined;
         }
 
+        let item = super.shift() as T;
+
+        dispose(item);
+        write(this._length, this.length);
+        this.dispatch('shift', { item });
+
         return item;
     }
 
@@ -326,7 +330,8 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     splice(start: number, deleteCount: number = this.length, ...items: T[]) {
-        let removed = super.splice(start, deleteCount, ...items);
+        let length = this.length,
+            removed = super.splice(start, deleteCount, ...items);
 
         if (items.length > 0 || removed.length > 0) {
             write(this._length, this.length);
@@ -335,7 +340,15 @@ class ReactiveArray<T> extends Array<T> {
                 dispose(removed[i]);
             }
 
-            this.dispatch('splice', { deleteCount, items, start });
+            // Listeners receive the position and count Array.prototype.splice actually applied
+            // (negative, fractional and out-of-range arguments resolved), never the raw arguments
+            let index = Math.trunc(start) || 0;
+
+            this.dispatch('splice', {
+                deleteCount: removed.length,
+                items,
+                start: index < 0 ? Math.max(length + index, 0) : Math.min(index, length)
+            });
         }
 
         return removed;

package/src/system.ts

@@ -680,8 +680,10 @@ function makeAsyncComputed<T>(factory: Computed<Promise<T> | AsyncIterable<T> |
         else if (result != null && typeof (result as AsyncIterable<T>)[Symbol.asyncIterator] === 'function') {
             let it = (result as AsyncIterable<T>)[Symbol.asyncIterator]();
 
+            // Disposal leaves no consumer to observe a failing iterator cleanup; left unhandled, the
+            // rejection would crash hosts that treat unhandled rejections as fatal (Node's default)
             onCleanup(() => {
-                it.return?.();
+                it.return?.().then(undefined, () => {});
             });
 
             let step = (r: IteratorResult<T>) => {

package/test/async-iterable.test.ts

@@ -218,4 +218,46 @@ describe('asyncComputed AsyncIterable support', () => {
 
         expect(() => read(node)).toThrow('iterable step boom');
     });
+
+    it('a rejecting return() during disposal is not an unhandled rejection', async () => {
+        let unhandled: unknown[] = [],
+            listener = (reason: unknown) => {
+                unhandled.push(reason);
+            };
+
+        process.on('unhandledRejection', listener);
+
+        try {
+            let iterable = {
+                    [Symbol.asyncIterator]: () => ({
+                        next: () => new Promise<IteratorResult<number>>(() => {}),
+                        return: () => Promise.reject(new Error('cleanup boom'))
+                    })
+                },
+                node!: Computed<number | undefined>,
+                stopRoot!: VoidFunction;
+
+            root((dispose) => {
+                stopRoot = dispose;
+                node = computed(() => iterable);
+            });
+
+            let keeper = effect(() => {
+                read(node);
+            });
+
+            await tick();
+
+            keeper();
+            stopRoot();
+
+            await tick();
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(unhandled).toEqual([]);
+        }
+        finally {
+            process.off('unhandledRejection', listener);
+        }
+    });
 });