@esportsplus/reactivity 0.37.0 → 0.37.2

package/build/compiler/primitives.js

@@ -1,40 +1,7 @@
 import { ts } from '@esportsplus/typescript';
 import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants.js';
-function inScope(reference, binding) {
-    let current = reference;
-    while (current) {
-        if (current === binding.scope) {
-            return true;
-        }
-        current = current.parent;
-    }
-    return false;
-}
-function isScope(node) {
-    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);
-}
-function scopeOf(node) {
-    let current = node.parent, depth = 0, scope = 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, node) {
+import scope from './bindings.js';
+function declare(ctx, node) {
     if (ctx.isReactiveCall(node)) {
         let call = node;
         ctx.calls.push(call);
@@ -52,32 +19,20 @@ function visit(ctx, node) {
                     classification = null;
                 }
                 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 = null;
-                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 (classification !== null) {
+                let target = targetOf(call), type = classification;
+                if (target) {
+                    scope.declare(ctx.bindings, target, type);
                 }
                 ctx.replacements.push({
-                    generate: () => classification === TYPES.Computed
+                    generate: () => type === TYPES.Computed
                         ? `${NAMESPACE}.computed`
                         : `${NAMESPACE}.signal`,
                     node: call.expression
@@ -85,92 +40,137 @@ function visit(ctx, node) {
             }
         }
     }
-    if (ts.isIdentifier(node) &&
-        node.parent &&
-        !(ts.isVariableDeclaration(node.parent) && node.parent.name === node)) {
-        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            node.forEachChild(n => visit(ctx, n));
-            return;
+    node.forEachChild(child => declare(ctx, child));
+}
+function isName(node, parent) {
+    if (ts.isShorthandPropertyAssignment(parent)) {
+        return false;
+    }
+    let slots = parent;
+    return slots.name === node || slots.propertyName === node || slots.label === node;
+}
+function isPatternTarget(node) {
+    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, node) {
+    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.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.left === node && ctx.isReactiveCall(parent.right)) ||
+        (ts.isTypeOfExpression(parent) && parent.expression === node) ||
+        isPatternTarget(node)) {
+        return;
+    }
+    let name = node.text;
+    if (ts.isShorthandPropertyAssignment(parent)) {
+        ctx.replacements.push({
+            generate: () => `${name}: ${NAMESPACE}.read(${name})`,
+            node: parent
+        });
+        return;
+    }
+    let writeCtx;
+    if (ts.isBinaryExpression(parent) && parent.left === node) {
+        let op = parent.operatorToken.kind;
+        if (op === ts.SyntaxKind.EqualsToken) {
+            writeCtx = 'simple';
         }
-        let bindings = ctx.scopedBindings, binding, name = node.text;
-        for (let i = 0, n = bindings.length; i < n; i++) {
-            let b = bindings[i];
-            if (b.name === name && (!binding || b.depth >= binding.depth) && inScope(node, b)) {
-                binding = b;
-            }
+        else if (COMPOUND_OPERATORS.has(op)) {
+            writeCtx = 'compound';
         }
-        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 (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.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
-                    });
-                }
-            }
+    }
+    else if (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) {
+        let op = parent.operator;
+        if (op === ts.SyntaxKind.MinusMinusToken || op === ts.SyntaxKind.PlusPlusToken) {
+            writeCtx = 'increment';
         }
     }
-    node.forEachChild(n => visit(ctx, n));
+    if (!writeCtx) {
+        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, 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
+            });
+        }
+    }
+}
+function rewrite(ctx, node) {
+    if (ts.isTypeNode(node)) {
+        return;
+    }
+    if (ts.isIdentifier(node)) {
+        reference(ctx, node);
+        return;
+    }
+    node.forEachChild(child => rewrite(ctx, child));
+}
+function targetOf(call) {
+    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;
+    }
+    return null;
 }
 export default (sourceFile, bindings, isReactiveCall) => {
     let ctx = {
@@ -178,10 +178,9 @@ export default (sourceFile, bindings, isReactiveCall) => {
         calls: [],
         isReactiveCall,
         replacements: [],
-        scopedBindings: [],
-        sourceFile,
         tmpCounter: 0
     };
-    visit(ctx, sourceFile);
+    declare(ctx, sourceFile);
+    rewrite(ctx, sourceFile);
     return { calls: ctx.calls, replacements: ctx.replacements };
 };

package/build/compiler/types.d.ts

@@ -1,5 +1,10 @@
 import type { ts } from '@esportsplus/typescript';
-import { TYPES } from './constants.js';
-type Bindings = Map<string, TYPES>;
+import type { TYPES } from './constants.js';
+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;
 export type { Bindings, IsReactiveCall };

package/build/reactive/array.js

@@ -140,12 +140,13 @@ class ReactiveArray extends Array {
         this.on(event, listener);
     }
     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();
+        dispose(item);
+        write(this._length, this.length);
+        this.dispatch('pop', { item });
         return item;
     }
     push(...items) {
@@ -163,12 +164,13 @@ class ReactiveArray extends Array {
         return this;
     }
     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();
+        dispose(item);
+        write(this._length, this.length);
+        this.dispatch('shift', { item });
         return item;
     }
     sort(fn) {
@@ -200,13 +202,18 @@ class ReactiveArray extends Array {
         return this;
     }
     splice(start, deleteCount = this.length, ...items) {
-        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);
             for (let i = 0, n = removed.length; i < n; i++) {
                 dispose(removed[i]);
             }
-            this.dispatch('splice', { deleteCount, items, start });
+            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/build/system.js

@@ -451,7 +451,7 @@ function makeAsyncComputed(factory) {
         else if (result != null && typeof result[Symbol.asyncIterator] === 'function') {
             let it = result[Symbol.asyncIterator]();
             onCleanup(() => {
-                it.return?.();
+                it.return?.().then(undefined, () => { });
             });
             let step = (r) => {
                 if (stale()) {

package/package.json

@@ -1,10 +1,10 @@
 {
   "author": "ICJR",
   "dependencies": {
-    "@esportsplus/utilities": "^0.28.4"
+    "@esportsplus/utilities": "^0.28.6"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.34.4",
+    "@esportsplus/typescript": "^0.36.1",
     "@types/node": "^26.4.1",
     "vite": "^8.2.2",
     "vitest": "^5.0.0"
@@ -36,7 +36,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.37.0",
+  "version": "0.37.2",
   "scripts": {
     "agent:bench": "vitest bench --run",
     "agent:test": "tsc --noEmit && vitest run",

package/pnpm-workspace.yaml

@@ -1,10 +1,8 @@
 allowBuilds:
   esbuild: true
 minimumReleaseAgeExclude:
-  - '@esportsplus/utilities@0.28.4'
-  - '@esportsplus/typescript@0.34.4'
-  - '@esportsplus/utilities@0.28.1 || 0.28.3'
-  - '@esportsplus/typescript@0.31.0 || 0.32.0 || 0.33.0 || 0.33.2 || 0.33.4 || 0.34.1 || 0.34.3'
+  - '@esportsplus/utilities@0.28.1 || 0.28.3 || 0.28.4 || 0.28.6'
+  - '@esportsplus/typescript@0.31.0 || 0.32.0 || 0.33.0 || 0.33.2 || 0.33.4 || 0.34.1 || 0.34.3 || 0.34.4 || 0.36.0 || 0.36.1'
   - tsc-alias@1.9.4
   - '@vitest/mocker@5.0.0'
   - '@vitest/spy@5.0.0'