@esportsplus/reactivity 0.33.0 → 0.36.0

package/src/compiler/index.ts

@@ -9,27 +9,7 @@ import object from './object';
 import primitives from './primitives';
 
 
-type FindRemainingContext = {
-    checker: ts.TypeChecker;
-    replacements: ReplacementIntent[];
-    sourceFile: ts.SourceFile;
-    transformedNodes: Set<ts.Node>;
-};
-
-
-function findRemainingCalls(
-    checker: ts.TypeChecker,
-    sourceFile: ts.SourceFile,
-    transformedNodes: Set<ts.Node>
-): ReplacementIntent[] {
-    let ctx: FindRemainingContext = { checker, replacements: [], sourceFile, transformedNodes };
-
-    visit(ctx, sourceFile);
-
-    return ctx.replacements;
-}
-
-function isReactiveCallExpression(checker: ts.TypeChecker, node: ts.Node): node is ts.CallExpression {
+function isReactiveCallExpression(checker: ts.Checker, node: ts.Node): node is ts.CallExpression {
     if (!ts.isCallExpression(node)) {
         return false;
     }
@@ -49,38 +29,13 @@ function isReactiveCallExpression(checker: ts.TypeChecker, node: ts.Node): node
     return false;
 }
 
-function hasReactiveCalls(checker: ts.TypeChecker, node: ts.Node): boolean {
-    if (isReactiveCallExpression(checker, node)) {
-        return true;
-    }
-
-    let found = false;
-
-    ts.forEachChild(node, child => {
-        if (!found && hasReactiveCalls(checker, child)) {
-            found = true;
-        }
-    });
-
-    return found;
-}
-
-function visit(ctx: FindRemainingContext, node: ts.Node): void {
-    if (isReactiveCallExpression(ctx.checker, node) && !ctx.transformedNodes.has(node) && !ctx.transformedNodes.has(node.expression)) {
-        ctx.replacements.push({
-            generate: () => `${NAMESPACE}.reactive(${node.arguments.map(a => a.getText(ctx.sourceFile)).join(', ')})`,
-            node
-        });
-    }
-
-    ts.forEachChild(node, n => visit(ctx, n));
-}
-
 
 export default {
     patterns: ['reactive(', 'reactive<'],
     transform: (ctx: TransformContext) => {
-        if (!ctx.checker || !hasReactiveCalls(ctx.checker, ctx.sourceFile)) {
+        let checker = ctx.checker;
+
+        if (!checker) {
             return {};
         }
 
@@ -89,36 +44,50 @@ export default {
                 imports: [] as ImportIntent[],
                 prepend: [] as string[],
                 replacements: [] as ReplacementIntent[]
-            };
+            },
+            isReactiveCall = (node: ts.Node): node is ts.CallExpression => isReactiveCallExpression(checker, node),
+            sourceFile = ctx.sourceFile;
 
-        // Run primitives transform first (tracks bindings for signal/computed)
-        intents.replacements.push(
-            ...primitives(ctx.sourceFile, bindings, (node: ts.Node) => isReactiveCallExpression(ctx.checker!, node))
-        );
+        // Run primitives transform first (tracks bindings for signal/computed, collects every call)
+        let { calls, replacements } = primitives(sourceFile, bindings, isReactiveCall);
 
-        // Run object transform
-        let { prepend, replacements } = object(ctx.sourceFile, bindings, ctx.checker);
+        if (calls.length === 0) {
+            return {};
+        }
 
-        intents.prepend.push(...prepend);
         intents.replacements.push(...replacements);
 
+        // Run object transform
+        let objects = object(sourceFile, bindings, isReactiveCall);
+
+        intents.prepend.push(...objects.prepend);
+        intents.replacements.push(...objects.replacements);
+
         // Run array transform separately ( avoid race conditions )
-        intents.replacements.push(...array(ctx.sourceFile, bindings, ctx.checker));
-
-        // Find remaining reactive() calls that weren't transformed and replace with namespace version
-        intents.replacements.push(
-            ...findRemainingCalls(ctx.checker, ctx.sourceFile, new Set(intents.replacements.map(r => r.node)))
-        );
-
-        // Build import intent
-        if (intents.replacements.length > 0 || intents.prepend.length > 0) {
-            intents.imports.push({
-                namespace: NAMESPACE,
-                package: PACKAGE_NAME,
-                remove: [ENTRYPOINT]
+        intents.replacements.push(...array(sourceFile, bindings, isReactiveCall));
+
+        // Calls no transform claimed fall through to the runtime reactive()
+        let transformed = new Set(intents.replacements.map(r => r.node));
+
+        for (let i = 0, n = calls.length; i < n; i++) {
+            let call = calls[i];
+
+            if (transformed.has(call) || transformed.has(call.expression)) {
+                continue;
+            }
+
+            intents.replacements.push({
+                generate: () => `${NAMESPACE}.reactive(${call.arguments.map(a => a.getText(sourceFile)).join(', ')})`,
+                node: call
             });
         }
 
+        intents.imports.push({
+            namespace: NAMESPACE,
+            package: PACKAGE_NAME,
+            remove: [ENTRYPOINT]
+        });
+
         return intents;
     }
 };

package/src/compiler/object.ts

@@ -1,8 +1,8 @@
 import { ts } from '@esportsplus/typescript';
-import { code, imports, uid } from '@esportsplus/typescript/compiler';
+import { code, uid } from '@esportsplus/typescript/compiler';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME, TYPES } from './constants';
-import type { Bindings } from './types';
+import { NAMESPACE, TYPES } from './constants';
+import type { Bindings, IsReactiveCall } from './types';
 
 
 interface AnalyzedProperty {
@@ -28,7 +28,7 @@ interface ReactiveObjectCall {
 interface VisitContext {
     bindings: Bindings;
     calls: ReactiveObjectCall[];
-    checker: ts.TypeChecker | undefined;
+    isReactiveCall: IsReactiveCall;
     sourceFile: ts.SourceFile;
 }
 
@@ -51,11 +51,11 @@ function analyzeProperty(prop: ts.ObjectLiteralElementLike, sourceFile: ts.Sourc
         value = unwrapped,
         valueText = value.getText(sourceFile);
 
-    while (ts.isAsExpression(unwrapped) || ts.isTypeAssertionExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped)) {
+    while (ts.isAsExpression(unwrapped) || ts.isTypeAssertion(unwrapped) || ts.isParenthesizedExpression(unwrapped)) {
         unwrapped = unwrapped.expression;
     }
 
-    if (ts.isAsExpression(value) || ts.isTypeAssertionExpression(value)) {
+    if (ts.isAsExpression(value) || ts.isTypeAssertion(value)) {
         let type = (value as ts.AsExpression).type;
 
         if (
@@ -216,24 +216,8 @@ function isStaticValue(node: ts.Node): boolean {
         (ts.isPrefixUnaryExpression(node) && ts.isNumericLiteral(node.operand));
 }
 
-function isReactiveCall(checker: ts.TypeChecker | undefined, node: ts.Node): node is ts.CallExpression {
-    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) {
-        return false;
-    }
-
-    let expr = node.expression;
-
-    // Use checker to verify symbol origin (handles re-exports)
-    if (checker) {
-        return imports.includes(checker, expr, PACKAGE_NAME, ENTRYPOINT);
-    }
-
-    // Fallback without checker: match by name only
-    return expr.text === ENTRYPOINT;
-}
-
 function visit(ctx: VisitContext, node: ts.Node): void {
-    if (isReactiveCall(ctx.checker, node)) {
+    if (ctx.isReactiveCall(node)) {
         let arg = node.arguments[0];
 
         if (arg && ts.isObjectLiteralExpression(arg)) {
@@ -243,21 +227,20 @@ function visit(ctx: VisitContext, node: ts.Node): void {
 
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 varname = node.parent.name.text;
-                ctx.bindings.set(varname, TYPES.Object);
             }
 
             for (let i = 0, n = props.length; i < n; i++) {
                 let prop = props[i];
 
                 if (ts.isSpreadAssignment(prop)) {
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
 
                 let analyzed = analyzeProperty(prop, ctx.sourceFile);
 
                 if (!analyzed) {
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
 
@@ -278,15 +261,15 @@ function visit(ctx: VisitContext, node: ts.Node): void {
         }
     }
 
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker): ObjectTransformResult => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): ObjectTransformResult => {
     let ctx: VisitContext = {
             bindings,
             calls: [],
-            checker,
+            isReactiveCall,
             sourceFile
         };
 

package/src/compiler/primitives.ts

@@ -1,10 +1,11 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import { NAMESPACE, TYPES } from './constants';
-import type { Bindings } from './types';
+import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants';
+import type { Bindings, IsReactiveCall } from './types';
 
 
 interface ScopeBinding {
+    depth: number;
     name: string;
     scope: ts.Node;
     type: TYPES;
@@ -12,31 +13,18 @@ interface ScopeBinding {
 
 interface TransformContext {
     bindings: Bindings;
-    isReactiveCall: (node: ts.Node) => boolean;
+    calls: ts.CallExpression[];
+    isReactiveCall: IsReactiveCall;
     replacements: ReplacementIntent[];
     scopedBindings: ScopeBinding[];
     sourceFile: ts.SourceFile;
     tmpCounter: number;
 }
 
-
-const COMPOUND_OPERATORS = new Map<ts.SyntaxKind, string>([
-    [ts.SyntaxKind.AmpersandAmpersandEqualsToken, '&&'],
-    [ts.SyntaxKind.AmpersandEqualsToken, '&'],
-    [ts.SyntaxKind.AsteriskAsteriskEqualsToken, '**'],
-    [ts.SyntaxKind.AsteriskEqualsToken, '*'],
-    [ts.SyntaxKind.BarBarEqualsToken, '||'],
-    [ts.SyntaxKind.BarEqualsToken, '|'],
-    [ts.SyntaxKind.CaretEqualsToken, '^'],
-    [ts.SyntaxKind.GreaterThanGreaterThanEqualsToken, '>>'],
-    [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, '>>>'],
-    [ts.SyntaxKind.LessThanLessThanEqualsToken, '<<'],
-    [ts.SyntaxKind.MinusEqualsToken, '-'],
-    [ts.SyntaxKind.PercentEqualsToken, '%'],
-    [ts.SyntaxKind.PlusEqualsToken, '+'],
-    [ts.SyntaxKind.QuestionQuestionEqualsToken, '??'],
-    [ts.SyntaxKind.SlashEqualsToken, '/']
-]);
+type PrimitivesTransformResult = {
+    calls: ts.CallExpression[];
+    replacements: ReplacementIntent[];
+};
 
 
 function inScope(reference: ts.Node, binding: ScopeBinding): boolean {
@@ -53,9 +41,44 @@ function inScope(reference: ts.Node, binding: ScopeBinding): boolean {
     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 {
     if (ctx.isReactiveCall(node)) {
-        let call = node as ts.CallExpression;
+        let call = node;
+
+        ctx.calls.push(call);
 
         if (call.arguments.length > 0) {
             let arg = call.arguments[0],
@@ -67,7 +90,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
             else {
                 let unwrapped = arg;
 
-                while (ts.isAsExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped) || ts.isTypeAssertionExpression(unwrapped)) {
+                while (ts.isAsExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped) || ts.isTypeAssertion(unwrapped)) {
                     unwrapped = unwrapped.expression;
                 }
 
@@ -80,7 +103,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
                         generate: () => `${NAMESPACE}.reactive`,
                         node: call.expression
                     });
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
             }
@@ -101,32 +124,10 @@ function visit(ctx: TransformContext, node: ts.Node): void {
                 }
 
                 if (varname) {
-                    let current = call.parent,
-                        scope;
-
-                    while (current) {
-                        if (
-                            ts.isArrowFunction(current) ||
-                            ts.isBlock(current) ||
-                            ts.isForInStatement(current) ||
-                            ts.isForOfStatement(current) ||
-                            ts.isForStatement(current) ||
-                            ts.isFunctionDeclaration(current) ||
-                            ts.isFunctionExpression(current) ||
-                            ts.isSourceFile(current)
-                        ) {
-                            scope = current;
-                        }
-
-                        current = current.parent;
-                    }
-
-                    if (!scope) {
-                        scope = call.getSourceFile();
-                    }
+                    let { depth, scope } = scopeOf(call);
 
                     ctx.bindings.set(varname, classification);
-                    ctx.scopedBindings.push({ name: varname, scope, type: classification });
+                    ctx.scopedBindings.push({ depth, name: varname, scope, type: classification });
                 }
 
                 // Replace just the 'reactive' identifier with the appropriate namespace function
@@ -148,7 +149,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         !(ts.isVariableDeclaration(node.parent) && node.parent.name === node)
     ) {
         if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            ts.forEachChild(node, n => visit(ctx, n));
+            node.forEachChild(n => visit(ctx, n));
             return;
         }
 
@@ -159,7 +160,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         for (let i = 0, n = bindings.length; i < n; i++) {
             let b = bindings[i];
 
-            if (b.name === name && inScope(node, b)) {
+            if (b.name === name && (!binding || b.depth >= binding.depth) && inScope(node, b)) {
                 binding = b;
             }
         }
@@ -251,13 +252,14 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         }
     }
 
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: (node: ts.Node) => boolean) => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): PrimitivesTransformResult => {
     let ctx: TransformContext = {
             bindings,
+            calls: [],
             isReactiveCall,
             replacements: [],
             scopedBindings: [],
@@ -267,5 +269,5 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: (
 
     visit(ctx, sourceFile);
 
-    return ctx.replacements;
+    return { calls: ctx.calls, replacements: ctx.replacements };
 };

package/src/compiler/types.ts

@@ -1,7 +1,10 @@
+import type { ts } from '@esportsplus/typescript';
 import { TYPES } from './constants';
 
 
 type Bindings = Map<string, TYPES>;
 
+type IsReactiveCall = (node: ts.Node) => node is ts.CallExpression;
 
-export type { Bindings };
+
+export type { Bindings, IsReactiveCall };

package/src/constants.ts

@@ -8,6 +8,8 @@ const REACTIVE_OBJECT = Symbol('reactivity.reactive.object');
 
 const SIGNAL = Symbol('reactivity.signal');
 
+const STABILIZER_DEFERRED = 4;
+
 const STABILIZER_IDLE = 0;
 
 const STABILIZER_RESCHEDULE = 1;
@@ -16,8 +18,6 @@ const STABILIZER_RUNNING = 2;
 
 const STABILIZER_SCHEDULED = 3;
 
-const STATE_NONE = 0;
-
 const STATE_CHECK = 1 << 0;
 
 const STATE_DIRTY = 1 << 1;
@@ -40,6 +40,6 @@ export {
     PACKAGE_NAME,
     REACTIVE_ARRAY, REACTIVE_OBJECT,
     SIGNAL,
-    STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
-    STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING
+    STABILIZER_DEFERRED, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
+    STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 };

package/src/reactive/array.ts

@@ -1,5 +1,5 @@
 import { isArray } from '@esportsplus/utilities';
-import { REACTIVE_ARRAY } from '~/constants';
+import { PACKAGE_NAME, REACTIVE_ARRAY } from '~/constants';
 import { read, signal, write } from '~/system';
 import type { Signal } from '~/types';
 import { isReactiveObject } from './object';
@@ -63,9 +63,16 @@ class ReactiveArray<T> extends Array<T> {
     listeners: Listeners<T> = {};
 
 
-    constructor(...items: T[]) {
-        super(...items);
-        this._length = signal(items.length);
+    constructor(items?: readonly T[]) {
+        super();
+
+        let n = items ? items.length : 0;
+
+        for (let i = 0; i < n; i++) {
+            this[i] = items![i];
+        }
+
+        this._length = signal(n);
     }
 
 
@@ -103,6 +110,7 @@ class ReactiveArray<T> extends Array<T> {
         }
 
         this.dispatch('set', { index: i, item: value });
+        dispose(prev);
     }
 
 
@@ -147,7 +155,8 @@ class ReactiveArray<T> extends Array<T> {
             return;
         }
 
-        let dirty = false;
+        let dirty = false,
+            errors: unknown[] | null = null;
 
         for (let i = 0, n = listeners.length; i < n; i++) {
             let listener = listeners[i];
@@ -164,9 +173,10 @@ class ReactiveArray<T> extends Array<T> {
                     listeners[i] = null;
                 }
             }
-            catch {
+            catch (e) {
                 dirty = true;
                 listeners[i] = null;
+                (errors ??= []).push(e);
             }
         }
 
@@ -175,6 +185,16 @@ class ReactiveArray<T> extends Array<T> {
                 listeners.pop();
             }
         }
+
+        if (errors !== null) {
+            let error = errors.length === 1
+                ? errors[0]
+                : new AggregateError(errors, `${PACKAGE_NAME}: dispatch produced multiple errors`);
+
+            queueMicrotask(() => {
+                throw error;
+            });
+        }
     }
 
     dispose() {
@@ -278,29 +298,25 @@ class ReactiveArray<T> extends Array<T> {
 
             super.sort(fn);
 
-            let buckets = new Map<T, number[]>(),
+            let buckets = new Map<T, { indices: number[]; next: number }>(),
                 order = new Array(n);
 
             for (let i = 0; i < n; i++) {
                 let value = before[i],
-                    list = buckets.get(value);
+                    bucket = buckets.get(value);
 
-                if (!list) {
-                    buckets.set(value, [i]);
+                if (bucket === undefined) {
+                    buckets.set(value, { indices: [i], next: 0 });
                 }
                 else {
-                    list.push(i);
+                    bucket.indices.push(i);
                 }
             }
 
             for (let i = 0; i < n; i++) {
-                let list = buckets.get(this[i])!;
+                let bucket = buckets.get(this[i])!;
 
-                order[i] = list.length === 1 ? list[0] : list[list.length - 1];
-
-                if (list.length > 1) {
-                    list.pop();
-                }
+                order[i] = bucket.indices[bucket.next++];
             }
 
             this.dispatch('sort', { order });

package/src/reactive/index.ts

@@ -18,31 +18,19 @@ function reactive<T extends unknown[]>(input: T): Reactive<T>;
 function reactive<T extends Record<PropertyKey, unknown>>(input: Guard<T>): Reactive<T>;
 function reactive<T>(input: T): Reactive<T>;
 function reactive<T>(input: T): Reactive<T> {
-    let dispose = false,
-        value = root(() => {
-            let response: Reactive<T> | undefined;
-
+    let value = root(() => {
             if (isObject(input)) {
-                response = new ReactiveObject(input) as unknown as Reactive<T>;
-            }
-            else if (isArray(input)) {
-                response = new ReactiveArray(...input) as unknown as Reactive<T>;
+                return new ReactiveObject(input) as unknown as Reactive<T>;
             }
 
-            if (response) {
-                if (root.disposables) {
-                    dispose = true;
-                }
-
-                return response;
+            if (isArray(input)) {
+                return new ReactiveArray(input) as unknown as Reactive<T>;
             }
 
             throw new Error(`${PACKAGE_NAME}: 'reactive' received invalid input - ${JSON.stringify(input)}`);
         });
 
-    if (dispose) {
-        onCleanup(() => (value as unknown as { dispose: VoidFunction }).dispose());
-    }
+    onCleanup(() => (value as unknown as { dispose: VoidFunction }).dispose());
 
     return value;
 }

package/src/reactive/object.ts

@@ -67,7 +67,7 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     }
 
     protected [REACTIVE_ARRAY]<U>(value: U[]): ReactiveArray<U> {
-        let node = new ReactiveArray(...value);
+        let node = new ReactiveArray(value);
 
         (this.disposers ??= []).push( () => node.dispose() );