@esportsplus/reactivity 0.24.1 → 0.24.3

package/build/transformer/transforms/primitives.js

@@ -1,5 +1,5 @@
 import { uid } from '@esportsplus/typescript/transformer';
-import { addMissingImports, applyReplacements } from './utilities.js';
+import { createCommaExpr, createComputedCall, createPostfixIncrementExpr, createReadCall, createSetCall, createSignalCall } from '../factory.js';
 import { ts } from '@esportsplus/typescript';
 function classifyReactiveArg(arg) {
     if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
@@ -22,14 +22,14 @@ function findBinding(bindings, name, node) {
 function findEnclosingScope(node) {
     let current = node.parent;
     while (current) {
-        if (ts.isBlock(current) ||
-            ts.isSourceFile(current) ||
+        if (ts.isArrowFunction(current) ||
+            ts.isBlock(current) ||
+            ts.isForInStatement(current) ||
+            ts.isForOfStatement(current) ||
+            ts.isForStatement(current) ||
             ts.isFunctionDeclaration(current) ||
             ts.isFunctionExpression(current) ||
-            ts.isArrowFunction(current) ||
-            ts.isForStatement(current) ||
-            ts.isForInStatement(current) ||
-            ts.isForOfStatement(current)) {
+            ts.isSourceFile(current)) {
             return current;
         }
         current = current.parent;
@@ -38,64 +38,72 @@ function findEnclosingScope(node) {
 }
 function getCompoundOperator(kind) {
     if (kind === ts.SyntaxKind.PlusEqualsToken) {
-        return '+';
+        return ts.SyntaxKind.PlusToken;
     }
     else if (kind === ts.SyntaxKind.MinusEqualsToken) {
-        return '-';
+        return ts.SyntaxKind.MinusToken;
     }
     else if (kind === ts.SyntaxKind.AsteriskEqualsToken) {
-        return '*';
+        return ts.SyntaxKind.AsteriskToken;
     }
     else if (kind === ts.SyntaxKind.SlashEqualsToken) {
-        return '/';
+        return ts.SyntaxKind.SlashToken;
     }
     else if (kind === ts.SyntaxKind.PercentEqualsToken) {
-        return '%';
+        return ts.SyntaxKind.PercentToken;
     }
     else if (kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
-        return '**';
+        return ts.SyntaxKind.AsteriskAsteriskToken;
     }
     else if (kind === ts.SyntaxKind.AmpersandEqualsToken) {
-        return '&';
+        return ts.SyntaxKind.AmpersandToken;
     }
     else if (kind === ts.SyntaxKind.BarEqualsToken) {
-        return '|';
+        return ts.SyntaxKind.BarToken;
     }
     else if (kind === ts.SyntaxKind.CaretEqualsToken) {
-        return '^';
+        return ts.SyntaxKind.CaretToken;
     }
     else if (kind === ts.SyntaxKind.LessThanLessThanEqualsToken) {
-        return '<<';
+        return ts.SyntaxKind.LessThanLessThanToken;
     }
     else if (kind === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken) {
-        return '>>';
+        return ts.SyntaxKind.GreaterThanGreaterThanToken;
     }
     else if (kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken) {
-        return '>>>';
+        return ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
     }
     else if (kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
-        return '&&';
+        return ts.SyntaxKind.AmpersandAmpersandToken;
     }
     else if (kind === ts.SyntaxKind.BarBarEqualsToken) {
-        return '||';
+        return ts.SyntaxKind.BarBarToken;
     }
     else if (kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
-        return '??';
+        return ts.SyntaxKind.QuestionQuestionToken;
     }
     else {
-        return '+';
+        return ts.SyntaxKind.PlusToken;
     }
 }
-function isInComputedRange(ranges, start, end) {
-    for (let i = 0, n = ranges.length; i < n; i++) {
-        let r = ranges[i];
-        if (start >= r.start && end <= r.end) {
-            return true;
-        }
+function isAssignmentOperator(kind) {
+    if (kind === ts.SyntaxKind.EqualsToken) {
+        return 'simple';
+    }
+    if (kind >= ts.SyntaxKind.PlusEqualsToken && kind <= ts.SyntaxKind.CaretEqualsToken) {
+        return 'compound';
+    }
+    if (kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
+        kind === ts.SyntaxKind.BarBarEqualsToken ||
+        kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
+        return 'compound';
     }
     return false;
 }
 function isInDeclarationInit(node) {
+    if (!node || !node.parent) {
+        return false;
+    }
     let parent = node.parent;
     if (ts.isVariableDeclaration(parent) && parent.initializer === node) {
         return true;
@@ -113,41 +121,14 @@ function isInScope(reference, binding) {
     return false;
 }
 function isReactiveReassignment(node) {
-    let parent = node.parent;
-    if (ts.isBinaryExpression(parent) &&
-        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-        parent.right === node &&
-        ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'reactive') {
+    let right = node.right;
+    if (ts.isCallExpression(right) &&
+        ts.isIdentifier(right.expression) &&
+        right.expression.text === 'reactive') {
         return true;
     }
     return false;
 }
-function isWriteContext(node) {
-    let parent = node.parent;
-    if (ts.isBinaryExpression(parent) && parent.left === node) {
-        let op = parent.operatorToken.kind;
-        if (op === ts.SyntaxKind.EqualsToken) {
-            return 'simple';
-        }
-        if (op >= ts.SyntaxKind.PlusEqualsToken && op <= ts.SyntaxKind.CaretEqualsToken) {
-            return 'compound';
-        }
-        if (op === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
-            op === ts.SyntaxKind.BarBarEqualsToken ||
-            op === ts.SyntaxKind.QuestionQuestionEqualsToken) {
-            return 'compound';
-        }
-    }
-    if (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) {
-        let op = parent.operator;
-        if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken) {
-            return 'increment';
-        }
-    }
-    return false;
-}
 function visit(ctx, node) {
     if (ts.isImportDeclaration(node) &&
         ts.isStringLiteral(node.moduleSpecifier) &&
@@ -170,166 +151,132 @@ function visit(ctx, node) {
         let arg = node.arguments[0], classification = classifyReactiveArg(arg);
         if (classification) {
             let varName = null;
-            if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+            if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 varName = node.parent.name.text;
             }
-            else if (ts.isBinaryExpression(node.parent) &&
+            else if (node.parent &&
+                ts.isBinaryExpression(node.parent) &&
                 node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
                 ts.isIdentifier(node.parent.left)) {
                 varName = node.parent.left.text;
             }
             if (varName) {
                 let scope = findEnclosingScope(node);
-                ctx.scopedBindings.push({ name: varName, scope, type: classification });
                 ctx.bindings.set(varName, classification);
+                ctx.scopedBindings.push({ name: varName, scope, type: classification });
             }
             if (classification === 'computed') {
-                ctx.computedArgRanges.push({
-                    end: arg.end,
-                    start: arg.getStart(ctx.sourceFile)
-                });
-                let argCtx = {
-                    argStart: arg.getStart(ctx.sourceFile),
-                    innerReplacements: [],
-                    neededImports: ctx.neededImports,
-                    scopedBindings: ctx.scopedBindings,
-                    sourceFile: ctx.sourceFile
-                };
-                visitArg(argCtx, arg);
-                let argText = applyReplacements(arg.getText(ctx.sourceFile), argCtx.innerReplacements);
-                ctx.replacements.push({
-                    end: node.end,
-                    newText: `computed(${argText})`,
-                    start: node.pos
-                });
                 ctx.neededImports.add('computed');
+                let transformedArg = ts.visitEachChild(arg, n => visitComputedArg(ctx, n), ctx.context);
+                return createComputedCall(ctx.factory, ctx.ns.reactivity, transformedArg);
             }
             else {
-                let argText = arg.getText(ctx.sourceFile);
-                ctx.replacements.push({
-                    end: node.end,
-                    newText: `signal(${argText})`,
-                    start: node.pos
-                });
                 ctx.neededImports.add('signal');
+                return createSignalCall(ctx.factory, ctx.ns.reactivity, arg);
             }
         }
     }
-    if (ts.isIdentifier(node) && !isInDeclarationInit(node.parent)) {
-        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            ts.forEachChild(node, n => visit(ctx, n));
-            return;
+    if (ts.isBinaryExpression(node) && ts.isIdentifier(node.left)) {
+        let assignType = isAssignmentOperator(node.operatorToken.kind);
+        if (assignType) {
+            let binding = findBinding(ctx.scopedBindings, node.left.text, node.left);
+            if (binding && binding.type !== 'computed' && !isReactiveReassignment(node)) {
+                ctx.neededImports.add('set');
+                let factory = ctx.factory, name = node.left.text, signalIdent = factory.createIdentifier(name), transformedRight = ts.visitEachChild(node.right, n => visit(ctx, n), ctx.context);
+                if (assignType === 'simple') {
+                    return createSetCall(factory, ctx.ns.reactivity, signalIdent, transformedRight);
+                }
+                else {
+                    let op = getCompoundOperator(node.operatorToken.kind), valueAccess = factory.createPropertyAccessExpression(signalIdent, 'value');
+                    return createSetCall(factory, ctx.ns.reactivity, signalIdent, factory.createBinaryExpression(valueAccess, op, transformedRight));
+                }
+            }
         }
-        let nodeStart = node.getStart(ctx.sourceFile);
-        if (isInComputedRange(ctx.computedArgRanges, nodeStart, node.end)) {
-            ts.forEachChild(node, n => visit(ctx, n));
-            return;
+    }
+    if (ts.isPrefixUnaryExpression(node) && ts.isIdentifier(node.operand)) {
+        let op = node.operator;
+        if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken) {
+            let binding = findBinding(ctx.scopedBindings, node.operand.text, node.operand);
+            if (binding && binding.type !== 'computed') {
+                ctx.neededImports.add('set');
+                let delta = op === ts.SyntaxKind.PlusPlusToken ? ts.SyntaxKind.PlusToken : ts.SyntaxKind.MinusToken, factory = ctx.factory, name = node.operand.text, signalIdent = factory.createIdentifier(name), valueAccess = factory.createPropertyAccessExpression(signalIdent, 'value');
+                if (node.parent && ts.isExpressionStatement(node.parent)) {
+                    return createSetCall(factory, ctx.ns.reactivity, signalIdent, factory.createBinaryExpression(valueAccess, delta, factory.createNumericLiteral(1)));
+                }
+                else {
+                    return createCommaExpr(factory, createSetCall(factory, ctx.ns.reactivity, signalIdent, factory.createBinaryExpression(valueAccess, delta, factory.createNumericLiteral(1))), factory.createPropertyAccessExpression(factory.createIdentifier(name), 'value'));
+                }
+            }
         }
-        let binding = findBinding(ctx.scopedBindings, node.text, node), name = node.text;
-        if (binding) {
-            if (!isReactiveReassignment(node.parent) &&
-                !(ts.isTypeOfExpression(node.parent) && node.parent.expression === node)) {
-                let writeCtx = isWriteContext(node);
-                if (writeCtx) {
-                    if (binding.type !== 'computed') {
-                        ctx.neededImports.add('set');
-                        let parent = node.parent;
-                        if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
-                            let valueText = parent.right.getText(ctx.sourceFile);
-                            ctx.replacements.push({
-                                end: parent.end,
-                                newText: `set(${name}, ${valueText})`,
-                                start: parent.pos
-                            });
-                        }
-                        else if (writeCtx === 'compound' && ts.isBinaryExpression(parent)) {
-                            let op = getCompoundOperator(parent.operatorToken.kind), valueText = parent.right.getText(ctx.sourceFile);
-                            ctx.replacements.push({
-                                end: parent.end,
-                                newText: `set(${name}, ${name}.value ${op} ${valueText})`,
-                                start: parent.pos
-                            });
-                        }
-                        else if (writeCtx === 'increment') {
-                            let isPrefix = ts.isPrefixUnaryExpression(parent), op = parent.operator, delta = op === ts.SyntaxKind.PlusPlusToken ? '+ 1' : '- 1';
-                            if (ts.isExpressionStatement(parent.parent)) {
-                                ctx.replacements.push({
-                                    end: parent.end,
-                                    newText: `set(${name}, ${name}.value ${delta})`,
-                                    start: parent.pos
-                                });
-                            }
-                            else if (isPrefix) {
-                                ctx.replacements.push({
-                                    end: parent.end,
-                                    newText: `(set(${name}, ${name}.value ${delta}), ${name}.value)`,
-                                    start: parent.pos
-                                });
-                            }
-                            else {
-                                let tmp = uid('tmp');
-                                ctx.replacements.push({
-                                    end: parent.end,
-                                    newText: `((${tmp}) => (set(${name}, ${tmp} ${delta}), ${tmp}))(${name}.value)`,
-                                    start: parent.pos
-                                });
-                            }
-                        }
-                    }
+    }
+    if (ts.isPostfixUnaryExpression(node) && ts.isIdentifier(node.operand)) {
+        let op = node.operator;
+        if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken) {
+            let binding = findBinding(ctx.scopedBindings, node.operand.text, node.operand);
+            if (binding && binding.type !== 'computed') {
+                ctx.neededImports.add('set');
+                let delta = op === ts.SyntaxKind.PlusPlusToken ? ts.SyntaxKind.PlusToken : ts.SyntaxKind.MinusToken, factory = ctx.factory, name = node.operand.text, signalIdent = factory.createIdentifier(name), valueAccess = factory.createPropertyAccessExpression(signalIdent, 'value');
+                if (node.parent && ts.isExpressionStatement(node.parent)) {
+                    return createSetCall(factory, ctx.ns.reactivity, signalIdent, factory.createBinaryExpression(valueAccess, delta, factory.createNumericLiteral(1)));
                 }
                 else {
-                    ctx.neededImports.add('read');
-                    ctx.replacements.push({
-                        end: node.end,
-                        newText: `read(${name})`,
-                        start: node.pos
-                    });
+                    return createPostfixIncrementExpr(factory, ctx.ns.reactivity, uid('tmp'), name, delta);
                 }
             }
         }
     }
-    ts.forEachChild(node, n => visit(ctx, n));
+    if (ts.isIdentifier(node) && node.parent && !isInDeclarationInit(node.parent)) {
+        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
+            return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+        }
+        if (ts.isBinaryExpression(node.parent) && node.parent.left === node) {
+            return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+        }
+        if ((ts.isPrefixUnaryExpression(node.parent) || ts.isPostfixUnaryExpression(node.parent)) &&
+            node.parent.operand === node) {
+            return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+        }
+        if (ts.isTypeOfExpression(node.parent) && node.parent.expression === node) {
+            return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+        }
+        let binding = findBinding(ctx.scopedBindings, node.text, node);
+        if (binding) {
+            ctx.neededImports.add('read');
+            return createReadCall(ctx.factory, ctx.ns.reactivity, ctx.factory.createIdentifier(node.text));
+        }
+    }
+    return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
 }
-function visitArg(ctx, node) {
-    if (ts.isIdentifier(node)) {
+function visitComputedArg(ctx, node) {
+    if (ts.isIdentifier(node) && node.parent) {
         if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            ts.forEachChild(node, n => visitArg(ctx, n));
-            return;
+            return ts.visitEachChild(node, n => visitComputedArg(ctx, n), ctx.context);
         }
         if (ts.isCallExpression(node.parent) && node.parent.expression === node) {
-            ts.forEachChild(node, n => visitArg(ctx, n));
-            return;
+            return ts.visitEachChild(node, n => visitComputedArg(ctx, n), ctx.context);
         }
         let binding = findBinding(ctx.scopedBindings, node.text, node);
         if (binding) {
             ctx.neededImports.add('read');
-            ctx.innerReplacements.push({
-                end: node.end - ctx.argStart,
-                newText: `read(${node.text})`,
-                start: node.getStart(ctx.sourceFile) - ctx.argStart
-            });
+            return createReadCall(ctx.factory, ctx.ns.reactivity, ctx.factory.createIdentifier(node.text));
         }
     }
-    ts.forEachChild(node, n => visitArg(ctx, n));
+    return ts.visitEachChild(node, n => visitComputedArg(ctx, n), ctx.context);
 }
-const transformReactivePrimitives = (sourceFile, bindings) => {
-    let code = sourceFile.getFullText(), ctx = {
-        bindings,
-        computedArgRanges: [],
-        hasReactiveImport: false,
-        neededImports: new Set(),
-        replacements: [],
-        scopedBindings: [],
-        sourceFile
+const createPrimitivesTransformer = (bindings, neededImports, ns) => {
+    return (context) => {
+        return (sourceFile) => {
+            let ctx = {
+                bindings,
+                context,
+                factory: context.factory,
+                hasReactiveImport: false,
+                neededImports,
+                ns,
+                scopedBindings: []
+            };
+            return ts.visitNode(sourceFile, n => visit(ctx, n));
+        };
     };
-    visit(ctx, sourceFile);
-    if (ctx.replacements.length === 0) {
-        return code;
-    }
-    let result = applyReplacements(code, ctx.replacements);
-    if (ctx.neededImports.size > 0) {
-        result = addMissingImports(result, ctx.neededImports);
-    }
-    return result;
 };
-export { transformReactivePrimitives };
+export { createPrimitivesTransformer };

package/build/types.d.ts

@@ -1,8 +1,12 @@
 import { COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
 import { ReactiveArray, ReactiveObject } from './reactive/index.js';
-import { ts } from '@esportsplus/typescript';
 type BindingType = 'array' | 'computed' | 'object' | 'signal';
 type Bindings = Map<string, BindingType>;
+interface Namespaces {
+    array: string;
+    constants: string;
+    reactivity: string;
+}
 interface Computed<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
@@ -31,9 +35,4 @@ type Signal<T> = {
     type: typeof SIGNAL;
     value: T;
 };
-interface TransformResult {
-    code: string;
-    sourceFile: ts.SourceFile;
-    transformed: boolean;
-}
-export type { BindingType, Bindings, Computed, Link, ReactiveArray, ReactiveObject, Signal, TransformResult };
+export type { BindingType, Bindings, Computed, Link, Namespaces, ReactiveArray, ReactiveObject, Signal };

package/package.json

@@ -36,7 +36,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.24.1",
+  "version": "0.24.3",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",

package/src/transformer/factory.ts

@@ -0,0 +1,141 @@
+import { ts } from '@esportsplus/typescript';
+
+
+// Create: ns.read(expr)
+function createReadCall(factory: ts.NodeFactory, ns: string, expr: ts.Expression): ts.CallExpression {
+    return factory.createCallExpression(
+        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'read'),
+        undefined,
+        [expr]
+    );
+}
+
+// Create: ns.set(target, value)
+function createSetCall(factory: ts.NodeFactory, ns: string, target: ts.Expression, value: ts.Expression): ts.CallExpression {
+    return factory.createCallExpression(
+        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'set'),
+        undefined,
+        [target, value]
+    );
+}
+
+// Create: ns.signal(initialValue)
+function createSignalCall(factory: ts.NodeFactory, ns: string, initialValue: ts.Expression): ts.CallExpression {
+    return factory.createCallExpression(
+        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'signal'),
+        undefined,
+        [initialValue]
+    );
+}
+
+// Create: ns.computed(fn)
+function createComputedCall(factory: ts.NodeFactory, ns: string, fn: ts.Expression): ts.CallExpression {
+    return factory.createCallExpression(
+        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'computed'),
+        undefined,
+        [fn]
+    );
+}
+
+// Create: arr.$length()
+function createArrayLengthCall(factory: ts.NodeFactory, arrayExpr: ts.Expression): ts.CallExpression {
+    return factory.createCallExpression(
+        factory.createPropertyAccessExpression(arrayExpr, '$length'),
+        undefined,
+        []
+    );
+}
+
+// Create: arr.$set(index, value)
+function createArraySetCall(factory: ts.NodeFactory, arrayExpr: ts.Expression, index: ts.Expression, value: ts.Expression): ts.CallExpression {
+    return factory.createCallExpression(
+        factory.createPropertyAccessExpression(arrayExpr, '$set'),
+        undefined,
+        [index, value]
+    );
+}
+
+// Create: new ns.ReactiveArray(elements...)
+function createReactiveArrayNew(factory: ts.NodeFactory, ns: string, elements: ts.Expression[]): ts.NewExpression {
+    return factory.createNewExpression(
+        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'ReactiveArray'),
+        undefined,
+        elements
+    );
+}
+
+// Create: ns.dispose(expr)
+function createDisposeCall(factory: ts.NodeFactory, ns: string, expr: ts.Expression): ts.CallExpression {
+    return factory.createCallExpression(
+        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'dispose'),
+        undefined,
+        [expr]
+    );
+}
+
+// Create binary expression: left op right
+function createBinaryExpr(factory: ts.NodeFactory, left: ts.Expression, op: ts.BinaryOperator, right: ts.Expression): ts.BinaryExpression {
+    return factory.createBinaryExpression(left, op, right);
+}
+
+// Create: (expr1, expr2) - comma expression
+function createCommaExpr(factory: ts.NodeFactory, first: ts.Expression, second: ts.Expression): ts.ParenthesizedExpression {
+    return factory.createParenthesizedExpression(
+        factory.createBinaryExpression(first, ts.SyntaxKind.CommaToken, second)
+    );
+}
+
+// Create: ((tmp) => (ns.set(name, tmp op delta), tmp))(name.value)
+function createPostfixIncrementExpr(
+    factory: ts.NodeFactory,
+    ns: string,
+    tmpName: string,
+    signalName: string,
+    op: ts.SyntaxKind.PlusToken | ts.SyntaxKind.MinusToken
+): ts.CallExpression {
+    let tmpIdent = factory.createIdentifier(tmpName),
+        signalIdent = factory.createIdentifier(signalName);
+
+    return factory.createCallExpression(
+        factory.createParenthesizedExpression(
+            factory.createArrowFunction(
+                undefined,
+                undefined,
+                [factory.createParameterDeclaration(undefined, undefined, tmpIdent)],
+                undefined,
+                factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+                createCommaExpr(
+                    factory,
+                    createSetCall(
+                        factory,
+                        ns,
+                        signalIdent,
+                        factory.createBinaryExpression(
+                            tmpIdent,
+                            op,
+                            factory.createNumericLiteral(1)
+                        )
+                    ),
+                    tmpIdent
+                )
+            )
+        ),
+        undefined,
+        [factory.createPropertyAccessExpression(signalIdent, 'value')]
+    );
+}
+
+
+export {
+    createArrayLengthCall,
+    createArraySetCall,
+    createBinaryExpr,
+    createCommaExpr,
+    createComputedCall,
+    createDisposeCall,
+    createPostfixIncrementExpr,
+    createReactiveArrayNew,
+    createReadCall,
+    createSetCall,
+    createSignalCall
+};