@esportsplus/reactivity 0.29.21 → 0.30.0

package/build/compiler/array.js

@@ -24,6 +24,38 @@ function getElementTypeText(typeNode, sourceFile) {
     }
     return null;
 }
+function getOperator(kind) {
+    switch (kind) {
+        case ts.SyntaxKind.PlusEqualsToken: return '+';
+        case ts.SyntaxKind.MinusEqualsToken: return '-';
+        case ts.SyntaxKind.AsteriskEqualsToken: return '*';
+        case ts.SyntaxKind.SlashEqualsToken: return '/';
+        case ts.SyntaxKind.PercentEqualsToken: return '%';
+        case ts.SyntaxKind.AsteriskAsteriskEqualsToken: return '**';
+        case ts.SyntaxKind.AmpersandEqualsToken: return '&';
+        case ts.SyntaxKind.BarEqualsToken: return '|';
+        case ts.SyntaxKind.CaretEqualsToken: return '^';
+        default: return '+';
+    }
+}
+function isAssignmentOperator(kind) {
+    return kind === ts.SyntaxKind.EqualsToken ||
+        kind === ts.SyntaxKind.PlusEqualsToken ||
+        kind === ts.SyntaxKind.MinusEqualsToken ||
+        kind === ts.SyntaxKind.AsteriskEqualsToken ||
+        kind === ts.SyntaxKind.SlashEqualsToken ||
+        kind === ts.SyntaxKind.PercentEqualsToken ||
+        kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken ||
+        kind === ts.SyntaxKind.LessThanLessThanEqualsToken ||
+        kind === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken ||
+        kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken ||
+        kind === ts.SyntaxKind.AmpersandEqualsToken ||
+        kind === ts.SyntaxKind.BarEqualsToken ||
+        kind === ts.SyntaxKind.CaretEqualsToken ||
+        kind === ts.SyntaxKind.BarBarEqualsToken ||
+        kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
+        kind === ts.SyntaxKind.QuestionQuestionEqualsToken;
+}
 function visit(ctx, node) {
     if (isReactiveCall(ctx.checker, node) && node.arguments.length > 0) {
         let arg = node.arguments[0], expression = ts.isAsExpression(arg) ? arg.expression : arg;
@@ -69,18 +101,45 @@ function visit(ctx, node) {
             }
         }
     }
-    if (ts.isPropertyAccessExpression(node) &&
-        node.name.text === 'length' &&
-        (!node.parent ||
-            (!(ts.isBinaryExpression(node.parent) && node.parent.left === node) &&
-                !ts.isPostfixUnaryExpression(node.parent) &&
-                !ts.isPrefixUnaryExpression(node.parent)))) {
+    if (ts.isPropertyAccessExpression(node) && node.name.text === 'length') {
         let name = ast.expression.name(node.expression);
         if (name && ctx.bindings.get(name) === TYPES.Array) {
-            ctx.replacements.push({
-                node,
-                generate: (sf) => `${node.expression.getText(sf)}.$length()`
-            });
+            let expr = node.expression, parent = node.parent;
+            if (parent && ts.isBinaryExpression(parent) && parent.left === node && isAssignmentOperator(parent.operatorToken.kind)) {
+                let op = parent.operatorToken.kind;
+                if (op === ts.SyntaxKind.EqualsToken) {
+                    ctx.replacements.push({
+                        node: parent,
+                        generate: (sf) => `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
+                    });
+                }
+                else {
+                    ctx.replacements.push({
+                        node: parent,
+                        generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${getOperator(op)} ${parent.right.getText(sf)}`
+                    });
+                }
+            }
+            else if (parent && ts.isPostfixUnaryExpression(parent)) {
+                let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+                ctx.replacements.push({
+                    node: parent,
+                    generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
+                });
+            }
+            else if (parent && ts.isPrefixUnaryExpression(parent)) {
+                let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+                ctx.replacements.push({
+                    node: parent,
+                    generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
+                });
+            }
+            else {
+                ctx.replacements.push({
+                    node,
+                    generate: (sf) => `${expr.getText(sf)}.$length`
+                });
+            }
         }
     }
     if (ts.isBinaryExpression(node) &&
@@ -97,6 +156,22 @@ function visit(ctx, node) {
             });
         }
     }
+    if (ts.isBinaryExpression(node) &&
+        node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        ts.isIdentifier(node.left)) {
+        let name = node.left.text, right = node.right;
+        while (ts.isAsExpression(right) || ts.isTypeAssertionExpression(right)) {
+            right = right.expression;
+        }
+        if (ctx.bindings.get(name) === TYPES.Array && ts.isArrayLiteralExpression(right)) {
+            ctx.replacements.push({
+                node,
+                generate: (sf) => right.elements.length > 0
+                    ? `${name}.splice(0, ${name}.length, ...${right.getText(sf)})`
+                    : `${name}.splice(0, ${name}.length)`
+            });
+        }
+    }
     ts.forEachChild(node, n => visit(ctx, n));
 }
 export default (sourceFile, bindings, checker) => {

package/build/reactive/array.d.ts

@@ -38,7 +38,8 @@ declare class ReactiveArray<T> extends Array<T> {
     private _length;
     listeners: Listeners;
     constructor(...items: T[]);
-    $length(): number;
+    get $length(): number;
+    set $length(value: number);
     $set(i: number, value: T): void;
     clear(): void;
     concat(...items: ConcatArray<T>[]): ReactiveArray<T>;

package/build/reactive/array.js

@@ -14,9 +14,15 @@ class ReactiveArray extends Array {
         super(...items);
         this._length = signal(items.length);
     }
-    $length() {
+    get $length() {
         return read(this._length);
     }
+    set $length(value) {
+        if (value > super.length) {
+            throw Error(`@esportsplus/reactivity: cannot set length to a value larger than the current length, use splice instead.`);
+        }
+        this.splice(value, super.length);
+    }
     $set(i, value) {
         let prev = this[i];
         if (prev === value) {

package/package.json

@@ -4,7 +4,7 @@
     "@esportsplus/utilities": "^0.27.2"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.28.3",
+    "@esportsplus/typescript": "^0.28.4",
     "@types/node": "^25.0.8",
     "vite": "^7.3.1"
   },
@@ -35,7 +35,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.29.21",
+  "version": "0.30.0",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",

package/src/compiler/array.ts

@@ -47,13 +47,47 @@ function getElementTypeText(typeNode: ts.TypeNode, sourceFile: ts.SourceFile): s
     return null;
 }
 
+function getOperator(kind: ts.SyntaxKind) {
+    switch (kind) {
+        case ts.SyntaxKind.PlusEqualsToken: return '+';
+        case ts.SyntaxKind.MinusEqualsToken: return '-';
+        case ts.SyntaxKind.AsteriskEqualsToken: return '*';
+        case ts.SyntaxKind.SlashEqualsToken: return '/';
+        case ts.SyntaxKind.PercentEqualsToken: return '%';
+        case ts.SyntaxKind.AsteriskAsteriskEqualsToken: return '**';
+        case ts.SyntaxKind.AmpersandEqualsToken: return '&';
+        case ts.SyntaxKind.BarEqualsToken: return '|';
+        case ts.SyntaxKind.CaretEqualsToken: return '^';
+        default: return '+';
+    }
+}
+
+function isAssignmentOperator(kind: ts.SyntaxKind) {
+    return kind === ts.SyntaxKind.EqualsToken ||
+        kind === ts.SyntaxKind.PlusEqualsToken ||
+        kind === ts.SyntaxKind.MinusEqualsToken ||
+        kind === ts.SyntaxKind.AsteriskEqualsToken ||
+        kind === ts.SyntaxKind.SlashEqualsToken ||
+        kind === ts.SyntaxKind.PercentEqualsToken ||
+        kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken ||
+        kind === ts.SyntaxKind.LessThanLessThanEqualsToken ||
+        kind === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken ||
+        kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken ||
+        kind === ts.SyntaxKind.AmpersandEqualsToken ||
+        kind === ts.SyntaxKind.BarEqualsToken ||
+        kind === ts.SyntaxKind.CaretEqualsToken ||
+        kind === ts.SyntaxKind.BarBarEqualsToken ||
+        kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
+        kind === ts.SyntaxKind.QuestionQuestionEqualsToken;
+}
+
 function visit(ctx: VisitContext, node: ts.Node): void {
     if (isReactiveCall(ctx.checker, node) && node.arguments.length > 0) {
         let arg = node.arguments[0],
             expression = ts.isAsExpression(arg) ? arg.expression : arg;
 
         if (ts.isArrayLiteralExpression(expression)) {
-            let elementType: string | null = null;
+            let elementType = null;
 
             if (ts.isAsExpression(arg) && arg.type) {
                 elementType = getElementTypeText(arg.type, ctx.sourceFile);
@@ -106,25 +140,55 @@ function visit(ctx: VisitContext, node: ts.Node): void {
         }
     }
 
-    if (
-        ts.isPropertyAccessExpression(node) &&
-        node.name.text === 'length' &&
-        (
-            !node.parent ||
-            (
-                !(ts.isBinaryExpression(node.parent) && node.parent.left === node) &&
-                !ts.isPostfixUnaryExpression(node.parent) &&
-                !ts.isPrefixUnaryExpression(node.parent)
-            )
-        )
-    ) {
+    if (ts.isPropertyAccessExpression(node) && node.name.text === 'length') {
         let name = ast.expression.name(node.expression);
 
         if (name && ctx.bindings.get(name) === TYPES.Array) {
-            ctx.replacements.push({
-                node,
-                generate: (sf) => `${node.expression.getText(sf)}.$length()`
-            });
+            let expr = node.expression,
+                parent = node.parent;
+
+            // arr.length = value OR arr.length += value
+            if (parent && ts.isBinaryExpression(parent) && parent.left === node && isAssignmentOperator(parent.operatorToken.kind)) {
+                let op = parent.operatorToken.kind;
+
+                if (op === ts.SyntaxKind.EqualsToken) {
+                    ctx.replacements.push({
+                        node: parent,
+                        generate: (sf) => `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
+                    });
+                }
+                else {
+                    ctx.replacements.push({
+                        node: parent,
+                        generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${getOperator(op)} ${parent.right.getText(sf)}`
+                    });
+                }
+            }
+            // arr.length++ or arr.length--
+            else if (parent && ts.isPostfixUnaryExpression(parent)) {
+                let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+
+                ctx.replacements.push({
+                    node: parent,
+                    generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
+                });
+            }
+            // ++arr.length or --arr.length
+            else if (parent && ts.isPrefixUnaryExpression(parent)) {
+                let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+
+                ctx.replacements.push({
+                    node: parent,
+                    generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
+                });
+            }
+            // Read-only: arr.length → arr.$length
+            else {
+                ctx.replacements.push({
+                    node,
+                    generate: (sf) => `${expr.getText(sf)}.$length`
+                });
+            }
         }
     }
 
@@ -147,6 +211,29 @@ function visit(ctx: VisitContext, node: ts.Node): void {
         }
     }
 
+    if (
+        ts.isBinaryExpression(node) &&
+        node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        ts.isIdentifier(node.left)
+    ) {
+        let name = node.left.text,
+            right = node.right;
+
+        // Unwrap "as" expressions: arr = [] as Type[]
+        while (ts.isAsExpression(right) || ts.isTypeAssertionExpression(right)) {
+            right = right.expression;
+        }
+
+        if (ctx.bindings.get(name) === TYPES.Array && ts.isArrayLiteralExpression(right)) {
+            ctx.replacements.push({
+                node,
+                generate: (sf) => right.elements.length > 0
+                    ? `${name}.splice(0, ${name}.length, ...${right.getText(sf)})`
+                    : `${name}.splice(0, ${name}.length)`
+            });
+        }
+    }
+
     ts.forEachChild(node, n => visit(ctx, n));
 }
 

package/src/reactive/array.ts

@@ -64,10 +64,19 @@ class ReactiveArray<T> extends Array<T> {
     }
 
 
-    $length() {
+    get $length() {
         return read(this._length);
     }
 
+    set $length(value: number) {
+        if (value > super.length) {
+            throw Error(`@esportsplus/reactivity: cannot set length to a value larger than the current length, use splice instead.`);
+        }
+
+        this.splice(value, super.length);
+    }
+
+
     $set(i: number, value: T) {
         let prev = this[i];