@esportsplus/reactivity 0.25.9 → 0.25.11

package/build/constants.d.ts

@@ -1,9 +1,12 @@
 declare const COMPILER_ENTRYPOINT = "reactive";
 declare const COMPILER_ENTRYPOINT_REGEX: RegExp;
 declare const COMPILER_NAMESPACE: string;
-declare const COMPILER_TYPE_ARRAY = "array";
-declare const COMPILER_TYPE_COMPUTED = "computed";
-declare const COMPILER_TYPE_SIGNAL = "signal";
+declare const enum COMPILER_TYPES {
+    Array = 0,
+    Computed = 1,
+    Object = 2,
+    Signal = 3
+}
 declare const COMPUTED: unique symbol;
 declare const PACKAGE = "@esportsplus/reactivity";
 declare const REACTIVE_ARRAY: unique symbol;
@@ -19,4 +22,4 @@ declare const STATE_DIRTY: number;
 declare const STATE_RECOMPUTING: number;
 declare const STATE_IN_HEAP: number;
 declare const STATE_NOTIFY_MASK: number;
-export { COMPILER_TYPE_ARRAY, COMPILER_TYPE_COMPUTED, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE, COMPILER_TYPE_SIGNAL, COMPUTED, PACKAGE, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };
+export { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE, COMPILER_TYPES, COMPUTED, PACKAGE, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };

package/build/constants.js

@@ -2,9 +2,13 @@ import { uid } from '@esportsplus/typescript/transformer';
 const COMPILER_ENTRYPOINT = 'reactive';
 const COMPILER_ENTRYPOINT_REGEX = /\breactive\b/;
 const COMPILER_NAMESPACE = uid(COMPILER_ENTRYPOINT);
-const COMPILER_TYPE_ARRAY = 'array';
-const COMPILER_TYPE_COMPUTED = 'computed';
-const COMPILER_TYPE_SIGNAL = 'signal';
+var COMPILER_TYPES;
+(function (COMPILER_TYPES) {
+    COMPILER_TYPES[COMPILER_TYPES["Array"] = 0] = "Array";
+    COMPILER_TYPES[COMPILER_TYPES["Computed"] = 1] = "Computed";
+    COMPILER_TYPES[COMPILER_TYPES["Object"] = 2] = "Object";
+    COMPILER_TYPES[COMPILER_TYPES["Signal"] = 3] = "Signal";
+})(COMPILER_TYPES || (COMPILER_TYPES = {}));
 const COMPUTED = Symbol('reactivity.computed');
 const PACKAGE = '@esportsplus/reactivity';
 const REACTIVE_ARRAY = Symbol('reactivity.reactive.array');
@@ -20,4 +24,4 @@ const STATE_DIRTY = 1 << 1;
 const STATE_RECOMPUTING = 1 << 2;
 const STATE_IN_HEAP = 1 << 3;
 const STATE_NOTIFY_MASK = (STATE_CHECK | STATE_DIRTY);
-export { COMPILER_TYPE_ARRAY, COMPILER_TYPE_COMPUTED, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE, COMPILER_TYPE_SIGNAL, COMPUTED, PACKAGE, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };
+export { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE, COMPILER_TYPES, COMPUTED, PACKAGE, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };

package/build/transformer/index.d.ts

@@ -1,5 +1,4 @@
 import { ts } from '@esportsplus/typescript';
 import type { TransformResult } from '../types.js';
-declare function contains(code: string): boolean;
 declare const transform: (sourceFile: ts.SourceFile) => TransformResult;
-export { contains, transform };
+export { transform };

package/build/transformer/index.js

@@ -58,4 +58,4 @@ const transform = (sourceFile) => {
     }
     return { code, sourceFile, transformed };
 };
-export { contains, transform };
+export { transform };

package/build/transformer/transforms/array.js

@@ -1,6 +1,6 @@
 import { code as c } from '@esportsplus/typescript/transformer';
 import { ts } from '@esportsplus/typescript';
-import { COMPILER_TYPE_ARRAY } from '../../constants.js';
+import { COMPILER_TYPES } from '../../constants.js';
 function getExpressionName(node) {
     if (ts.isIdentifier(node)) {
         return node.text;
@@ -30,13 +30,13 @@ function isAssignmentTarget(node) {
 }
 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_TYPE_ARRAY) {
-            ctx.bindings.set(node.name.text, COMPILER_TYPE_ARRAY);
+        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);
-            if (path && ctx.bindings.get(path) === COMPILER_TYPE_ARRAY) {
-                ctx.bindings.set(node.name.text, COMPILER_TYPE_ARRAY);
+            if (path && ctx.bindings.get(path) === COMPILER_TYPES.Array) {
+                ctx.bindings.set(node.name.text, COMPILER_TYPES.Array);
             }
         }
     }
@@ -47,7 +47,7 @@ function visit(ctx, node) {
                 ts.isTypeReferenceNode(param.type) &&
                 ts.isIdentifier(param.type.typeName) &&
                 param.type.typeName.text === 'ReactiveArray') {
-                ctx.bindings.set(param.name.text, COMPILER_TYPE_ARRAY);
+                ctx.bindings.set(param.name.text, COMPILER_TYPES.Array);
             }
         }
     }
@@ -55,7 +55,7 @@ function visit(ctx, node) {
         node.name.text === 'length' &&
         !isAssignmentTarget(node)) {
         let name = getExpressionName(node.expression);
-        if (name && ctx.bindings.get(name) === COMPILER_TYPE_ARRAY) {
+        if (name && ctx.bindings.get(name) === COMPILER_TYPES.Array) {
             let objText = node.expression.getText(ctx.sourceFile);
             ctx.replacements.push({
                 end: node.end,
@@ -68,7 +68,7 @@ function visit(ctx, node) {
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
         ts.isElementAccessExpression(node.left)) {
         let elemAccess = node.left, objName = getExpressionName(elemAccess.expression);
-        if (objName && ctx.bindings.get(objName) === COMPILER_TYPE_ARRAY) {
+        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);
             ctx.replacements.push({
                 end: node.end,

package/build/transformer/transforms/object.js

@@ -1,6 +1,6 @@
 import { ts } from '@esportsplus/typescript';
 import { code as c } from '@esportsplus/typescript/transformer';
-import { COMPILER_TYPE_ARRAY, COMPILER_TYPE_COMPUTED, COMPILER_TYPE_SIGNAL, PACKAGE } from '../../constants.js';
+import { COMPILER_TYPES, PACKAGE } from '../../constants.js';
 function analyzeProperty(prop, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) {
         return null;
@@ -14,7 +14,7 @@ function analyzeProperty(prop, sourceFile) {
     }
     let value = prop.initializer, valueText = value.getText(sourceFile);
     if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
-        return { key, type: COMPILER_TYPE_COMPUTED, valueText };
+        return { key, type: COMPILER_TYPES.Computed, valueText };
     }
     if (ts.isArrayLiteralExpression(value)) {
         let elements = value.elements, elementsText = '';
@@ -24,26 +24,26 @@ function analyzeProperty(prop, sourceFile) {
             }
             elementsText += elements[i].getText(sourceFile);
         }
-        return { key, type: COMPILER_TYPE_ARRAY, valueText: elementsText };
+        return { key, type: COMPILER_TYPES.Array, valueText: elementsText };
     }
-    return { key, type: COMPILER_TYPE_SIGNAL, valueText };
+    return { key, type: COMPILER_TYPES.Signal, valueText };
 }
 function buildClassCode(className, properties, ns) {
     let accessors = [], disposeStatements = [], fields = [], paramCounter = 0;
     fields.push(`[${ns}.REACTIVE_OBJECT] = true;`);
     for (let i = 0, n = properties.length; i < n; i++) {
         let { key, type, valueText } = properties[i];
-        if (type === COMPILER_TYPE_SIGNAL) {
+        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}); }`);
         }
-        else if (type === COMPILER_TYPE_ARRAY) {
+        else if (type === COMPILER_TYPES.Array) {
             fields.push(`${key} = new ${ns}.ReactiveArray(${valueText});`);
             disposeStatements.push(`this.${key}.dispose();`);
         }
-        else if (type === COMPILER_TYPE_COMPUTED) {
+        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});`);
@@ -86,7 +86,7 @@ function visit(ctx, node) {
             let properties = [], props = arg.properties, varName = null;
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 varName = node.parent.name.text;
-                ctx.bindings.set(varName, 'object');
+                ctx.bindings.set(varName, COMPILER_TYPES.Object);
             }
             for (let i = 0, n = props.length; i < n; i++) {
                 let prop = props[i];
@@ -100,8 +100,8 @@ function visit(ctx, node) {
                     return;
                 }
                 properties.push(analyzed);
-                if (analyzed.type === COMPILER_TYPE_ARRAY && varName) {
-                    ctx.bindings.set(`${varName}.${analyzed.key}`, COMPILER_TYPE_ARRAY);
+                if (analyzed.type === COMPILER_TYPES.Array && varName) {
+                    ctx.bindings.set(`${varName}.${analyzed.key}`, COMPILER_TYPES.Array);
                 }
             }
             ctx.calls.push({

package/build/transformer/transforms/primitives.js

@@ -1,6 +1,6 @@
 import { ts } from '@esportsplus/typescript';
 import { code as c } from '@esportsplus/typescript/transformer';
-import { COMPILER_TYPE_COMPUTED, COMPILER_ENTRYPOINT, COMPILER_TYPE_SIGNAL, PACKAGE } from '../../constants.js';
+import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '../../constants.js';
 let COMPOUND_OPERATORS = new Map([
     [ts.SyntaxKind.AmpersandAmpersandEqualsToken, '&&'],
     [ts.SyntaxKind.AmpersandEqualsToken, '&'],
@@ -20,12 +20,12 @@ let COMPOUND_OPERATORS = new Map([
 ]);
 function classifyReactiveArg(arg) {
     if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
-        return COMPILER_TYPE_COMPUTED;
+        return COMPILER_TYPES.Computed;
     }
     if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
         return null;
     }
-    return COMPILER_TYPE_SIGNAL;
+    return COMPILER_TYPES.Signal;
 }
 function findBinding(bindings, name, node) {
     for (let i = 0, n = bindings.length; i < n; i++) {
@@ -143,7 +143,7 @@ function visit(ctx, node) {
                 ctx.scopedBindings.push({ name: varName, scope, type: classification });
                 ctx.bindings.set(varName, classification);
             }
-            if (classification === COMPILER_TYPE_COMPUTED) {
+            if (classification === COMPILER_TYPES.Computed) {
                 let argStart = arg.getStart(ctx.sourceFile);
                 ctx.computedArgRanges.push({ end: arg.end, start: argStart });
                 let argCtx = {
@@ -186,7 +186,7 @@ function visit(ctx, node) {
                 !(ts.isTypeOfExpression(node.parent) && node.parent.expression === node)) {
                 let writeCtx = isWriteContext(node);
                 if (writeCtx) {
-                    if (binding.type !== COMPILER_TYPE_COMPUTED) {
+                    if (binding.type !== COMPILER_TYPES.Computed) {
                         let parent = node.parent;
                         if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
                             ctx.replacements.push({

package/build/types.d.ts

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

package/package.json

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

package/src/constants.ts

@@ -7,11 +7,12 @@ const COMPILER_ENTRYPOINT_REGEX = /\breactive\b/;
 
 const COMPILER_NAMESPACE = uid(COMPILER_ENTRYPOINT);
 
-const COMPILER_TYPE_ARRAY = 'array';
-
-const COMPILER_TYPE_COMPUTED = 'computed';
-
-const COMPILER_TYPE_SIGNAL = 'signal';
+const enum COMPILER_TYPES {
+    Array,
+    Computed,
+    Object,
+    Signal
+}
 
 
 const COMPUTED = Symbol('reactivity.computed');
@@ -48,7 +49,7 @@ const STATE_NOTIFY_MASK = (STATE_CHECK | STATE_DIRTY);
 
 
 export {
-    COMPILER_TYPE_ARRAY, COMPILER_TYPE_COMPUTED, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE, COMPILER_TYPE_SIGNAL, COMPUTED,
+    COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE, COMPILER_TYPES, COMPUTED,
     PACKAGE,
     REACTIVE_ARRAY, REACTIVE_OBJECT,
     SIGNAL,

package/src/transformer/index.ts

@@ -89,4 +89,4 @@ const transform = (sourceFile: ts.SourceFile): TransformResult => {
 };
 
 
-export { contains, transform };
+export { transform };

package/src/transformer/transforms/array.ts

@@ -1,6 +1,6 @@
 import { code as c, type Replacement } from '@esportsplus/typescript/transformer';
 import { ts } from '@esportsplus/typescript';
-import { COMPILER_TYPE_ARRAY } from '~/constants';
+import { COMPILER_TYPES } from '~/constants';
 import type { Bindings } from '~/types';
 
 
@@ -45,15 +45,15 @@ function isAssignmentTarget(node: ts.Node): boolean {
 
 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_TYPE_ARRAY) {
-            ctx.bindings.set(node.name.text, COMPILER_TYPE_ARRAY);
+        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);
 
-            if (path && ctx.bindings.get(path) === COMPILER_TYPE_ARRAY) {
-                ctx.bindings.set(node.name.text, COMPILER_TYPE_ARRAY);
+            if (path && ctx.bindings.get(path) === COMPILER_TYPES.Array) {
+                ctx.bindings.set(node.name.text, COMPILER_TYPES.Array);
             }
         }
     }
@@ -68,7 +68,7 @@ function visit(ctx: { bindings: Bindings, replacements: Replacement[], sourceFil
                 ts.isIdentifier(param.type.typeName) &&
                 param.type.typeName.text === 'ReactiveArray'
             ) {
-                ctx.bindings.set(param.name.text, COMPILER_TYPE_ARRAY);
+                ctx.bindings.set(param.name.text, COMPILER_TYPES.Array);
             }
         }
     }
@@ -80,7 +80,7 @@ function visit(ctx: { bindings: Bindings, replacements: Replacement[], sourceFil
     ) {
         let name = getExpressionName(node.expression);
 
-        if (name && ctx.bindings.get(name) === COMPILER_TYPE_ARRAY) {
+        if (name && ctx.bindings.get(name) === COMPILER_TYPES.Array) {
             let objText = node.expression.getText(ctx.sourceFile);
 
             ctx.replacements.push({
@@ -99,7 +99,7 @@ function visit(ctx: { bindings: Bindings, replacements: Replacement[], sourceFil
         let elemAccess = node.left,
             objName = getExpressionName(elemAccess.expression);
 
-        if (objName && ctx.bindings.get(objName) === COMPILER_TYPE_ARRAY) {
+        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);

package/src/transformer/transforms/object.ts

@@ -1,12 +1,12 @@
 import { ts } from '@esportsplus/typescript';
 import { code as c, type Replacement } from '@esportsplus/typescript/transformer';
-import { COMPILER_TYPE_ARRAY, COMPILER_TYPE_COMPUTED, COMPILER_TYPE_SIGNAL, PACKAGE } from '~/constants';
+import { COMPILER_TYPES, PACKAGE } from '~/constants';
 import type { Bindings } from '~/types';
 
 
 interface AnalyzedProperty {
     key: string;
-    type: 'array' | 'computed' | 'signal';
+    type: COMPILER_TYPES;
     valueText: string;
 }
 
@@ -47,7 +47,7 @@ function analyzeProperty(prop: ts.ObjectLiteralElementLike, sourceFile: ts.Sourc
         valueText = value.getText(sourceFile);
 
     if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
-        return { key, type: COMPILER_TYPE_COMPUTED, valueText };
+        return { key, type: COMPILER_TYPES.Computed, valueText };
     }
 
     if (ts.isArrayLiteralExpression(value)) {
@@ -62,10 +62,10 @@ function analyzeProperty(prop: ts.ObjectLiteralElementLike, sourceFile: ts.Sourc
             elementsText += elements[i].getText(sourceFile);
         }
 
-        return { key, type: COMPILER_TYPE_ARRAY, valueText: elementsText };
+        return { key, type: COMPILER_TYPES.Array, valueText: elementsText };
     }
 
-    return { key, type: COMPILER_TYPE_SIGNAL, valueText };
+    return { key, type: COMPILER_TYPES.Signal, valueText };
 }
 
 function buildClassCode(className: string, properties: AnalyzedProperty[], ns: string): string {
@@ -79,18 +79,18 @@ function buildClassCode(className: string, properties: AnalyzedProperty[], ns: s
     for (let i = 0, n = properties.length; i < n; i++) {
         let { key, type, valueText } = properties[i];
 
-        if (type === COMPILER_TYPE_SIGNAL) {
+        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}); }`);
         }
-        else if (type === COMPILER_TYPE_ARRAY) {
+        else if (type === COMPILER_TYPES.Array) {
             fields.push(`${key} = new ${ns}.ReactiveArray(${valueText});`);
             disposeStatements.push(`this.${key}.dispose();`);
         }
-        else if (type === COMPILER_TYPE_COMPUTED) {
+        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});`);
@@ -147,7 +147,7 @@ function visit(ctx: TransformContext, 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, 'object');
+                ctx.bindings.set(varName, COMPILER_TYPES.Object);
             }
 
             for (let i = 0, n = props.length; i < n; i++) {
@@ -167,8 +167,8 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 
                 properties.push(analyzed);
 
-                if (analyzed.type === COMPILER_TYPE_ARRAY && varName) {
-                    ctx.bindings.set(`${varName}.${analyzed.key}`, COMPILER_TYPE_ARRAY);
+                if (analyzed.type === COMPILER_TYPES.Array && varName) {
+                    ctx.bindings.set(`${varName}.${analyzed.key}`, COMPILER_TYPES.Array);
                 }
             }
 

package/src/transformer/transforms/primitives.ts

@@ -1,7 +1,7 @@
 import { ts } from '@esportsplus/typescript';
 import { code as c, type Range, type Replacement } from '@esportsplus/typescript/transformer';
-import type { BindingType, Bindings } from '~/types';
-import { COMPILER_TYPE_COMPUTED, COMPILER_ENTRYPOINT, COMPILER_TYPE_SIGNAL, PACKAGE } from '~/constants';
+import type { Bindings } from '~/types';
+import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '~/constants';
 
 
 interface ArgContext {
@@ -15,7 +15,7 @@ interface ArgContext {
 interface ScopeBinding {
     name: string;
     scope: ts.Node;
-    type: BindingType;
+    type: COMPILER_TYPES;
 }
 
 interface TransformContext {
@@ -49,16 +49,16 @@ let COMPOUND_OPERATORS = new Map<ts.SyntaxKind, string>([
     ]);
 
 
-function classifyReactiveArg(arg: ts.Expression): BindingType | null {
+function classifyReactiveArg(arg: ts.Expression): COMPILER_TYPES | null {
     if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
-        return COMPILER_TYPE_COMPUTED;
+        return COMPILER_TYPES.Computed;
     }
 
     if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
         return null;
     }
 
-    return COMPILER_TYPE_SIGNAL;
+    return COMPILER_TYPES.Signal;
 }
 
 function findBinding(bindings: ScopeBinding[], name: string, node: ts.Node): ScopeBinding | undefined {
@@ -221,7 +221,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
                 ctx.bindings.set(varName, classification);
             }
 
-            if (classification === COMPILER_TYPE_COMPUTED) {
+            if (classification === COMPILER_TYPES.Computed) {
                 let argStart = arg.getStart(ctx.sourceFile);
 
                 ctx.computedArgRanges.push({ end: arg.end, start: argStart });
@@ -278,7 +278,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
                 let writeCtx = isWriteContext(node);
 
                 if (writeCtx) {
-                    if (binding.type !== COMPILER_TYPE_COMPUTED) {
+                    if (binding.type !== COMPILER_TYPES.Computed) {
                         let parent = node.parent;
 
                         if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {

package/src/types.ts

@@ -1,11 +1,9 @@
 import { ts } from '@esportsplus/typescript';
-import { COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
+import { COMPILER_TYPES, COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
 import { ReactiveArray } from './reactive';
 
 
-type BindingType = 'array' | 'computed' | 'object' | 'signal';
-
-type Bindings = Map<string, BindingType>;
+type Bindings = Map<string, COMPILER_TYPES>;
 
 interface Computed<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
@@ -65,7 +63,7 @@ interface TransformResult {
 
 
 export type {
-    BindingType, Bindings,
+    Bindings,
     Computed,
     Link,
     Reactive,