@esportsplus/reactivity 0.25.13 → 0.26.0

package/build/{transformer/transforms → compiler}/array.d.ts

@@ -1,4 +1,4 @@
 import { ts } from '@esportsplus/typescript';
-import type { Bindings } from '../../types.js';
+import type { Bindings } from '../types.js';
 declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, _ns: string) => string;
 export default _default;

package/build/{transformer/transforms → compiler}/array.js

@@ -1,40 +1,13 @@
-import { code as c } from '@esportsplus/typescript/transformer';
+import { ast, code as c } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
-import { COMPILER_TYPES } from '../../constants.js';
-function getExpressionName(node) {
-    if (ts.isIdentifier(node)) {
-        return node.text;
-    }
-    if (ts.isPropertyAccessExpression(node)) {
-        return getPropertyPath(node);
-    }
-    return null;
-}
-function getPropertyPath(node) {
-    let current = node, parts = [];
-    while (ts.isPropertyAccessExpression(current)) {
-        parts.push(current.name.text);
-        current = current.expression;
-    }
-    if (ts.isIdentifier(current)) {
-        parts.push(current.text);
-        return parts.reverse().join('.');
-    }
-    return null;
-}
-function isAssignmentTarget(node) {
-    let parent = node.parent;
-    return !!parent && ((ts.isBinaryExpression(parent) && parent.left === node) ||
-        ts.isPostfixUnaryExpression(parent) ||
-        ts.isPrefixUnaryExpression(parent));
-}
+import { COMPILER_TYPES } from '../constants.js';
 function visit(ctx, node) {
     if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
         if (ts.isIdentifier(node.initializer) && ctx.bindings.get(node.initializer.text) === COMPILER_TYPES.Array) {
             ctx.bindings.set(node.name.text, COMPILER_TYPES.Array);
         }
         if (ts.isPropertyAccessExpression(node.initializer)) {
-            let path = getPropertyPath(node.initializer);
+            let path = ast.getPropertyPathString(node.initializer);
             if (path && ctx.bindings.get(path) === COMPILER_TYPES.Array) {
                 ctx.bindings.set(node.name.text, COMPILER_TYPES.Array);
             }
@@ -51,15 +24,17 @@ function visit(ctx, node) {
             }
         }
     }
+    let parent = node.parent;
     if (ts.isPropertyAccessExpression(node) &&
         node.name.text === 'length' &&
-        !isAssignmentTarget(node)) {
-        let name = getExpressionName(node.expression);
+        (!!parent && ((ts.isBinaryExpression(parent) && parent.left === node) ||
+            ts.isPostfixUnaryExpression(parent) ||
+            ts.isPrefixUnaryExpression(parent))) === false) {
+        let name = ast.getExpressionName(node.expression);
         if (name && ctx.bindings.get(name) === COMPILER_TYPES.Array) {
-            let objText = node.expression.getText(ctx.sourceFile);
             ctx.replacements.push({
                 end: node.end,
-                newText: `${objText}.$length()`,
+                newText: `${node.expression.getText(ctx.sourceFile)}.$length()`,
                 start: node.pos
             });
         }
@@ -67,12 +42,12 @@ function visit(ctx, node) {
     if (ts.isBinaryExpression(node) &&
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
         ts.isElementAccessExpression(node.left)) {
-        let elemAccess = node.left, objName = getExpressionName(elemAccess.expression);
+        let elemAccess = node.left, objName = ast.getExpressionName(elemAccess.expression);
         if (objName && ctx.bindings.get(objName) === COMPILER_TYPES.Array) {
-            let indexText = elemAccess.argumentExpression.getText(ctx.sourceFile), objText = elemAccess.expression.getText(ctx.sourceFile), valueText = node.right.getText(ctx.sourceFile);
+            let index = elemAccess.argumentExpression.getText(ctx.sourceFile), obj = elemAccess.expression.getText(ctx.sourceFile), value = node.right.getText(ctx.sourceFile);
             ctx.replacements.push({
                 end: node.end,
-                newText: `${objText}.$set(${indexText}, ${valueText})`,
+                newText: `${obj}.$set(${index}, ${value})`,
                 start: node.pos
             });
         }

package/build/{transformer → compiler}/index.js

@@ -1,9 +1,9 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c } from '@esportsplus/typescript/transformer';
+import { code as c } from '@esportsplus/typescript/compiler';
 import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE } from '../constants.js';
-import array from './transforms/array.js';
-import object from './transforms/object.js';
-import primitives from './transforms/primitives.js';
+import array from './array.js';
+import object from './object.js';
+import primitives from './primitives.js';
 let transforms = [object, array, primitives];
 function contains(code) {
     if (!c.contains(code, { regex: COMPILER_ENTRYPOINT_REGEX })) {

package/build/{transformer/transforms → compiler}/object.d.ts

@@ -1,4 +1,4 @@
 import { ts } from '@esportsplus/typescript';
-import type { Bindings } from '../../types.js';
+import type { Bindings } from '../types.js';
 declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, ns: string) => string;
 export default _default;

package/build/{transformer/transforms → compiler}/object.js

@@ -1,6 +1,6 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c } from '@esportsplus/typescript/transformer';
-import { COMPILER_TYPES, PACKAGE } from '../../constants.js';
+import { code as c } from '@esportsplus/typescript/compiler';
+import { COMPILER_TYPES, PACKAGE } from '../constants.js';
 function analyzeProperty(prop, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) {
         return null;
@@ -35,18 +35,18 @@ function buildClassCode(className, properties, ns) {
         let { key, type, valueText } = properties[i];
         if (type === COMPILER_TYPES.Signal) {
             let param = `_v${paramCounter++}`;
-            fields.push(`#${key} = ${ns}.signal(${valueText});`);
             accessors.push(`get ${key}() { return ${ns}.read(this.#${key}); }`);
             accessors.push(`set ${key}(${param}) { ${ns}.write(this.#${key}, ${param}); }`);
+            fields.push(`#${key} = ${ns}.signal(${valueText});`);
         }
         else if (type === COMPILER_TYPES.Array) {
-            fields.push(`${key} = new ${ns}.ReactiveArray(${valueText});`);
             disposeStatements.push(`this.${key}.dispose();`);
+            fields.push(`${key} = new ${ns}.ReactiveArray(${valueText});`);
         }
         else if (type === COMPILER_TYPES.Computed) {
-            fields.push(`#${key} = null;`);
             accessors.push(`get ${key}() { return ${ns}.read(this.#${key} ??= ${ns}.computed(${valueText})); }`);
             disposeStatements.push(`if (this.#${key}) ${ns}.dispose(this.#${key});`);
+            fields.push(`#${key} = null;`);
         }
     }
     return `

package/build/{transformer → compiler}/plugins/tsc.d.ts

@@ -1,3 +1,3 @@
-import { plugin } from '@esportsplus/typescript/transformer';
+import { plugin } from '@esportsplus/typescript/compiler';
 declare const _default: ReturnType<typeof plugin.tsc>;
 export default _default;

package/build/{transformer → compiler}/plugins/tsc.js

@@ -1,3 +1,3 @@
-import { plugin } from '@esportsplus/typescript/transformer';
+import { plugin } from '@esportsplus/typescript/compiler';
 import { transform } from '../index.js';
 export default plugin.tsc(transform);

package/build/{transformer → compiler}/plugins/vite.js

@@ -1,5 +1,5 @@
 import { PACKAGE } from '../../constants.js';
-import { plugin } from '@esportsplus/typescript/transformer';
+import { plugin } from '@esportsplus/typescript/compiler';
 import { transform } from '../index.js';
 export default plugin.vite({
     name: PACKAGE,

package/build/{transformer/transforms → compiler}/primitives.d.ts

@@ -1,4 +1,4 @@
 import { ts } from '@esportsplus/typescript';
-import type { Bindings } from '../../types.js';
+import type { Bindings } from '../types.js';
 declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, ns: string) => string;
 export default _default;

package/build/{transformer/transforms → compiler}/primitives.js

@@ -1,7 +1,7 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c } from '@esportsplus/typescript/transformer';
-import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '../../constants.js';
-let COMPOUND_OPERATORS = new Map([
+import { ast, code as c } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '../constants.js';
+const COMPOUND_OPERATORS = new Map([
     [ts.SyntaxKind.AmpersandAmpersandEqualsToken, '&&'],
     [ts.SyntaxKind.AmpersandEqualsToken, '&'],
     [ts.SyntaxKind.AsteriskAsteriskEqualsToken, '**'],
@@ -18,15 +18,6 @@ let COMPOUND_OPERATORS = new Map([
     [ts.SyntaxKind.QuestionQuestionEqualsToken, '??'],
     [ts.SyntaxKind.SlashEqualsToken, '/']
 ]);
-function classifyReactiveArg(arg) {
-    if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
-        return COMPILER_TYPES.Computed;
-    }
-    if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
-        return null;
-    }
-    return COMPILER_TYPES.Signal;
-}
 function findBinding(bindings, name, node) {
     for (let i = 0, n = bindings.length; i < n; i++) {
         let b = bindings[i];
@@ -53,15 +44,6 @@ function findEnclosingScope(node) {
     }
     return node.getSourceFile();
 }
-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;
-        }
-    }
-    return false;
-}
 function isInDeclarationInit(node) {
     let parent = node.parent;
     return ts.isVariableDeclaration(parent) && parent.initializer === node;
@@ -126,7 +108,13 @@ function visit(ctx, node) {
         ts.isIdentifier(node.expression) &&
         node.expression.text === COMPILER_ENTRYPOINT &&
         node.arguments.length > 0) {
-        let arg = node.arguments[0], classification = classifyReactiveArg(arg);
+        let arg = node.arguments[0], classification = COMPILER_TYPES.Signal;
+        if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+            classification = COMPILER_TYPES.Computed;
+        }
+        else if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
+            classification = null;
+        }
         if (classification) {
             let varName = null;
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
@@ -176,7 +164,7 @@ function visit(ctx, node) {
             return;
         }
         let nodeStart = node.getStart(ctx.sourceFile);
-        if (isInComputedRange(ctx.computedArgRanges, nodeStart, node.end)) {
+        if (ast.inRange(ctx.computedArgRanges, nodeStart, node.end)) {
             ts.forEachChild(node, n => visit(ctx, n));
             return;
         }

package/build/constants.js

@@ -1,4 +1,4 @@
-import { uid } from '@esportsplus/typescript/transformer';
+import { uid } from '@esportsplus/typescript/compiler';
 const COMPILER_ENTRYPOINT = 'reactive';
 const COMPILER_ENTRYPOINT_REGEX = /\breactive\b/;
 const COMPILER_NAMESPACE = uid(COMPILER_ENTRYPOINT);

package/package.json

@@ -4,7 +4,7 @@
     "@esportsplus/utilities": "^0.27.2"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.18.0",
+    "@esportsplus/typescript": "^0.21.0",
     "@types/node": "^25.0.3",
     "vite": "^7.3.0"
   },
@@ -13,18 +13,14 @@
       "import": "./build/index.js",
       "types": "./build/index.d.ts"
     },
-    "./constants": {
-      "import": "./build/constants.js",
-      "types": "./build/constants.d.ts"
+    "./compiler/tsc": {
+      "types": "./build/compiler/plugins/tsc.d.ts",
+      "import": "./build/compiler/plugins/tsc.js",
+      "require": "./build/compiler/plugins/tsc.js"
     },
-    "./plugins/tsc": {
-      "types": "./build/transformer/plugins/tsc.d.ts",
-      "import": "./build/transformer/plugins/tsc.js",
-      "require": "./build/transformer/plugins/tsc.js"
-    },
-    "./plugins/vite": {
-      "types": "./build/transformer/plugins/vite.d.ts",
-      "import": "./build/transformer/plugins/vite.js"
+    "./compiler/vite": {
+      "types": "./build/compiler/plugins/vite.d.ts",
+      "import": "./build/compiler/plugins/vite.js"
     }
   },
   "main": "build/index.js",
@@ -36,7 +32,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.25.13",
+  "version": "0.26.0",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",

package/src/{transformer/transforms → compiler}/array.ts

@@ -1,48 +1,9 @@
-import { code as c, type Replacement } from '@esportsplus/typescript/transformer';
+import { ast, code as c, type Replacement } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
 import { COMPILER_TYPES } from '~/constants';
 import type { Bindings } from '~/types';
 
 
-function getExpressionName(node: ts.Expression): string | null {
-    if (ts.isIdentifier(node)) {
-        return node.text;
-    }
-
-    if (ts.isPropertyAccessExpression(node)) {
-        return getPropertyPath(node);
-    }
-
-    return null;
-}
-
-function getPropertyPath(node: ts.PropertyAccessExpression): string | null {
-    let current: ts.Node = node,
-        parts: string[] = [];
-
-    while (ts.isPropertyAccessExpression(current)) {
-        parts.push(current.name.text);
-        current = current.expression;
-    }
-
-    if (ts.isIdentifier(current)) {
-        parts.push(current.text);
-        return parts.reverse().join('.');
-    }
-
-    return null;
-}
-
-function isAssignmentTarget(node: ts.Node): boolean {
-    let parent = node.parent;
-
-    return !!parent && (
-        (ts.isBinaryExpression(parent) && parent.left === node) ||
-        ts.isPostfixUnaryExpression(parent) ||
-        ts.isPrefixUnaryExpression(parent)
-    );
-}
-
 function visit(ctx: { bindings: Bindings, replacements: Replacement[], sourceFile: ts.SourceFile }, node: ts.Node): void {
     if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
         if (ts.isIdentifier(node.initializer) && ctx.bindings.get(node.initializer.text) === COMPILER_TYPES.Array) {
@@ -50,7 +11,7 @@ function visit(ctx: { bindings: Bindings, replacements: Replacement[], sourceFil
         }
 
         if (ts.isPropertyAccessExpression(node.initializer)) {
-            let path = getPropertyPath(node.initializer);
+            let path = ast.getPropertyPathString(node.initializer);
 
             if (path && ctx.bindings.get(path) === COMPILER_TYPES.Array) {
                 ctx.bindings.set(node.name.text, COMPILER_TYPES.Array);
@@ -73,19 +34,23 @@ function visit(ctx: { bindings: Bindings, replacements: Replacement[], sourceFil
         }
     }
 
+    let parent = node.parent;
+
     if (
         ts.isPropertyAccessExpression(node) &&
         node.name.text === 'length' &&
-        !isAssignmentTarget(node)
+        (!!parent && (
+            (ts.isBinaryExpression(parent) && parent.left === node) ||
+            ts.isPostfixUnaryExpression(parent) ||
+            ts.isPrefixUnaryExpression(parent)
+        )) === false
     ) {
-        let name = getExpressionName(node.expression);
+        let name = ast.getExpressionName(node.expression);
 
         if (name && ctx.bindings.get(name) === COMPILER_TYPES.Array) {
-            let objText = node.expression.getText(ctx.sourceFile);
-
             ctx.replacements.push({
                 end: node.end,
-                newText: `${objText}.$length()`,
+                newText: `${node.expression.getText(ctx.sourceFile)}.$length()`,
                 start: node.pos
             });
         }
@@ -97,16 +62,16 @@ function visit(ctx: { bindings: Bindings, replacements: Replacement[], sourceFil
         ts.isElementAccessExpression(node.left)
     ) {
         let elemAccess = node.left,
-            objName = getExpressionName(elemAccess.expression);
+            objName = ast.getExpressionName(elemAccess.expression);
 
         if (objName && ctx.bindings.get(objName) === COMPILER_TYPES.Array) {
-            let indexText = elemAccess.argumentExpression.getText(ctx.sourceFile),
-                objText = elemAccess.expression.getText(ctx.sourceFile),
-                valueText = node.right.getText(ctx.sourceFile);
+            let index = elemAccess.argumentExpression.getText(ctx.sourceFile),
+                obj = elemAccess.expression.getText(ctx.sourceFile),
+                value = node.right.getText(ctx.sourceFile);
 
             ctx.replacements.push({
                 end: node.end,
-                newText: `${objText}.$set(${indexText}, ${valueText})`,
+                newText: `${obj}.$set(${index}, ${value})`,
                 start: node.pos
             });
         }

package/src/{transformer → compiler}/index.ts

@@ -1,10 +1,10 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c } from '@esportsplus/typescript/transformer';
+import { code as c } from '@esportsplus/typescript/compiler';
 import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE } from '~/constants';
 import type { Bindings, TransformResult } from '~/types';
-import array from './transforms/array';
-import object from './transforms/object';
-import primitives from './transforms/primitives';
+import array from './array';
+import object from './object';
+import primitives from './primitives';
 
 
 let transforms = [object, array, primitives];

package/src/{transformer/transforms → compiler}/object.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c, type Replacement } from '@esportsplus/typescript/transformer';
+import { code as c, type Replacement } from '@esportsplus/typescript/compiler';
 import { COMPILER_TYPES, PACKAGE } from '~/constants';
 import type { Bindings } from '~/types';
 
@@ -82,18 +82,18 @@ function buildClassCode(className: string, properties: AnalyzedProperty[], ns: s
         if (type === COMPILER_TYPES.Signal) {
             let param = `_v${paramCounter++}`;
 
-            fields.push(`#${key} = ${ns}.signal(${valueText});`);
             accessors.push(`get ${key}() { return ${ns}.read(this.#${key}); }`);
             accessors.push(`set ${key}(${param}) { ${ns}.write(this.#${key}, ${param}); }`);
+            fields.push(`#${key} = ${ns}.signal(${valueText});`);
         }
         else if (type === COMPILER_TYPES.Array) {
-            fields.push(`${key} = new ${ns}.ReactiveArray(${valueText});`);
             disposeStatements.push(`this.${key}.dispose();`);
+            fields.push(`${key} = new ${ns}.ReactiveArray(${valueText});`);
         }
         else if (type === COMPILER_TYPES.Computed) {
-            fields.push(`#${key} = null;`);
             accessors.push(`get ${key}() { return ${ns}.read(this.#${key} ??= ${ns}.computed(${valueText})); }`);
             disposeStatements.push(`if (this.#${key}) ${ns}.dispose(this.#${key});`);
+            fields.push(`#${key} = null;`);
         }
     }
 

package/src/{transformer → compiler}/plugins/tsc.ts

@@ -1,4 +1,4 @@
-import { plugin } from '@esportsplus/typescript/transformer';
+import { plugin } from '@esportsplus/typescript/compiler';
 import { transform } from '..';
 
 

package/src/{transformer → compiler}/plugins/vite.ts

@@ -1,5 +1,5 @@
 import { PACKAGE } from '../../constants';
-import { plugin } from '@esportsplus/typescript/transformer';
+import { plugin } from '@esportsplus/typescript/compiler';
 import { transform } from '..';
 
 

package/src/{transformer/transforms → compiler}/primitives.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c, type Range, type Replacement } from '@esportsplus/typescript/transformer';
+import { ast, code as c, type Range, type Replacement } from '@esportsplus/typescript/compiler';
 import type { Bindings } from '~/types';
 import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '~/constants';
 
@@ -30,36 +30,24 @@ interface TransformContext {
 }
 
 
-let 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, '/']
-    ]);
-
-
-function classifyReactiveArg(arg: ts.Expression): COMPILER_TYPES | null {
-    if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
-        return COMPILER_TYPES.Computed;
-    }
-
-    if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
-        return null;
-    }
+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, '/']
+]);
 
-    return COMPILER_TYPES.Signal;
-}
 
 function findBinding(bindings: ScopeBinding[], name: string, node: ts.Node): ScopeBinding | undefined {
     for (let i = 0, n = bindings.length; i < n; i++) {
@@ -96,18 +84,6 @@ function findEnclosingScope(node: ts.Node): ts.Node {
     return node.getSourceFile();
 }
 
-function isInComputedRange(ranges: Range[], start: number, end: number): boolean {
-    for (let i = 0, n = ranges.length; i < n; i++) {
-        let r = ranges[i];
-
-        if (start >= r.start && end <= r.end) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
 function isInDeclarationInit(node: ts.Node): boolean {
     let parent = node.parent;
 
@@ -197,7 +173,14 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         node.arguments.length > 0
     ) {
         let arg = node.arguments[0],
-            classification = classifyReactiveArg(arg);
+            classification: COMPILER_TYPES | null = COMPILER_TYPES.Signal;
+
+        if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+            classification = COMPILER_TYPES.Computed;
+        }
+        else if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
+            classification = null;
+        }
 
         if (classification) {
             let varName: string | null = null;
@@ -262,7 +245,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 
         let nodeStart = node.getStart(ctx.sourceFile);
 
-        if (isInComputedRange(ctx.computedArgRanges, nodeStart, node.end)) {
+        if (ast.inRange(ctx.computedArgRanges, nodeStart, node.end)) {
             ts.forEachChild(node, n => visit(ctx, n));
             return;
         }
@@ -384,4 +367,4 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, ns: string): stri
     }
 
     return c.replace(code, ctx.replacements);
-};
+};

package/src/constants.ts

@@ -1,4 +1,4 @@
-import { uid } from '@esportsplus/typescript/transformer';
+import { uid } from '@esportsplus/typescript/compiler';
 
 
 const COMPILER_ENTRYPOINT = 'reactive';