@esportsplus/reactivity 0.25.6 → 0.25.8

package/build/constants.d.ts

@@ -1,9 +1,9 @@
-declare const COMPILATION_ENTRYPOINT = "reactive";
-declare const COMPILATION_ENTRYPOINT_REGEX: RegExp;
-declare const COMPILATION_NAMESPACE: string;
-declare const COMPILATION_TYPE_ARRAY = "array";
-declare const COMPILATION_TYPE_COMPUTED = "computed";
-declare const COMPILATION_TYPE_SIGNAL = "signal";
+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 COMPUTED: unique symbol;
 declare const PACKAGE = "@esportsplus/reactivity";
 declare const REACTIVE_ARRAY: unique symbol;
@@ -19,4 +19,4 @@ declare const STATE_DIRTY: number;
 declare const STATE_RECOMPUTING: number;
 declare const STATE_IN_HEAP: number;
 declare const STATE_NOTIFY_MASK: number;
-export { COMPILATION_TYPE_ARRAY, COMPILATION_TYPE_COMPUTED, COMPILATION_ENTRYPOINT, COMPILATION_ENTRYPOINT_REGEX, COMPILATION_NAMESPACE, COMPILATION_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_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 };

package/build/constants.js

@@ -1,10 +1,10 @@
-import uid from 'node_modules/@esportsplus/typescript/build/transformer/uid';
-const COMPILATION_ENTRYPOINT = 'reactive';
-const COMPILATION_ENTRYPOINT_REGEX = /\breactive\b/;
-const COMPILATION_NAMESPACE = uid(COMPILATION_ENTRYPOINT);
-const COMPILATION_TYPE_ARRAY = 'array';
-const COMPILATION_TYPE_COMPUTED = 'computed';
-const COMPILATION_TYPE_SIGNAL = 'signal';
+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';
 const COMPUTED = Symbol('reactivity.computed');
 const PACKAGE = '@esportsplus/reactivity';
 const REACTIVE_ARRAY = Symbol('reactivity.reactive.array');
@@ -20,4 +20,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 { COMPILATION_TYPE_ARRAY, COMPILATION_TYPE_COMPUTED, COMPILATION_ENTRYPOINT, COMPILATION_ENTRYPOINT_REGEX, COMPILATION_NAMESPACE, COMPILATION_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_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 };

package/build/reactive/index.js

@@ -1,7 +1,7 @@
 import { ReactiveArray } from './array.js';
-import { COMPILATION_ENTRYPOINT, PACKAGE } from '../constants.js';
+import { COMPILER_ENTRYPOINT, PACKAGE } from '../constants.js';
 function reactive(_input) {
-    throw new Error(`${PACKAGE}: ${COMPILATION_ENTRYPOINT}() called at runtime. ` +
+    throw new Error(`${PACKAGE}: ${COMPILER_ENTRYPOINT}() called at runtime. ` +
         'Ensure vite plugin is configured.');
 }
 export default reactive;

package/build/transformer/detector.js

@@ -1,6 +1,6 @@
 import { code as c } from '@esportsplus/typescript/transformer';
 import { ts } from '@esportsplus/typescript';
-import { COMPILATION_ENTRYPOINT, COMPILATION_ENTRYPOINT_REGEX } from '../constants.js';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX } from '../constants.js';
 function visit(ctx, node) {
     if (ctx.imported && ctx.used) {
         return;
@@ -11,7 +11,7 @@ function visit(ctx, node) {
         let elements = node.importClause.namedBindings.elements;
         for (let i = 0, n = elements.length; i < n; i++) {
             let element = elements[i];
-            if ((element.propertyName?.text ?? element.name.text) === COMPILATION_ENTRYPOINT) {
+            if ((element.propertyName?.text ?? element.name.text) === COMPILER_ENTRYPOINT) {
                 ctx.imported = true;
                 break;
             }
@@ -19,13 +19,13 @@ function visit(ctx, node) {
     }
     if (ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILATION_ENTRYPOINT) {
+        node.expression.text === COMPILER_ENTRYPOINT) {
         ctx.used = true;
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
 const contains = (code) => {
-    if (!c.contains(code, { regex: COMPILATION_ENTRYPOINT_REGEX })) {
+    if (!c.contains(code, { regex: COMPILER_ENTRYPOINT_REGEX })) {
         return false;
     }
     let ctx = {

package/build/transformer/index.js

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
-import { COMPILATION_NAMESPACE } from '../constants.js';
+import { COMPILER_NAMESPACE } from '../constants.js';
 import { contains } from './detector.js';
 import array from './transforms/array.js';
 import object from './transforms/object.js';
@@ -11,7 +11,7 @@ const transform = (sourceFile) => {
         return { code, sourceFile, transformed: false };
     }
     for (let i = 0, n = transforms.length; i < n; i++) {
-        result = transforms[i](current, bindings, COMPILATION_NAMESPACE);
+        result = transforms[i](current, bindings, COMPILER_NAMESPACE);
         if (result !== code) {
             current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
             code = result;
@@ -19,7 +19,7 @@ const transform = (sourceFile) => {
         }
     }
     if (transformed) {
-        code = `import * as ${COMPILATION_NAMESPACE} from '@esportsplus/reactivity';\n` + code;
+        code = `import * as ${COMPILER_NAMESPACE} from '@esportsplus/reactivity';\n` + code;
         sourceFile = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
     }
     return { code, sourceFile, transformed };

package/build/transformer/transforms/array.js

@@ -1,6 +1,6 @@
 import { code as c } from '@esportsplus/typescript/transformer';
 import { ts } from '@esportsplus/typescript';
-import { COMPILATION_TYPE_ARRAY } from '../../constants.js';
+import { COMPILER_TYPE_ARRAY } 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) === COMPILATION_TYPE_ARRAY) {
-            ctx.bindings.set(node.name.text, COMPILATION_TYPE_ARRAY);
+        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.isPropertyAccessExpression(node.initializer)) {
             let path = getPropertyPath(node.initializer);
-            if (path && ctx.bindings.get(path) === COMPILATION_TYPE_ARRAY) {
-                ctx.bindings.set(node.name.text, COMPILATION_TYPE_ARRAY);
+            if (path && ctx.bindings.get(path) === COMPILER_TYPE_ARRAY) {
+                ctx.bindings.set(node.name.text, COMPILER_TYPE_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, COMPILATION_TYPE_ARRAY);
+                ctx.bindings.set(param.name.text, COMPILER_TYPE_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) === COMPILATION_TYPE_ARRAY) {
+        if (name && ctx.bindings.get(name) === COMPILER_TYPE_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) === COMPILATION_TYPE_ARRAY) {
+        if (objName && ctx.bindings.get(objName) === COMPILER_TYPE_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 { COMPILATION_TYPE_ARRAY, COMPILATION_TYPE_COMPUTED, COMPILATION_TYPE_SIGNAL, PACKAGE } from '../../constants.js';
+import { COMPILER_TYPE_ARRAY, COMPILER_TYPE_COMPUTED, COMPILER_TYPE_SIGNAL, 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: COMPILATION_TYPE_COMPUTED, valueText };
+        return { key, type: COMPILER_TYPE_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: COMPILATION_TYPE_ARRAY, valueText: elementsText };
+        return { key, type: COMPILER_TYPE_ARRAY, valueText: elementsText };
     }
-    return { key, type: COMPILATION_TYPE_SIGNAL, valueText };
+    return { key, type: COMPILER_TYPE_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 === COMPILATION_TYPE_SIGNAL) {
+        if (type === COMPILER_TYPE_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 === COMPILATION_TYPE_ARRAY) {
+        else if (type === COMPILER_TYPE_ARRAY) {
             fields.push(`${key} = new ${ns}.ReactiveArray(${valueText});`);
             disposeStatements.push(`this.${key}.dispose();`);
         }
-        else if (type === COMPILATION_TYPE_COMPUTED) {
+        else if (type === COMPILER_TYPE_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});`);
@@ -100,8 +100,8 @@ function visit(ctx, node) {
                     return;
                 }
                 properties.push(analyzed);
-                if (analyzed.type === COMPILATION_TYPE_ARRAY && varName) {
-                    ctx.bindings.set(`${varName}.${analyzed.key}`, COMPILATION_TYPE_ARRAY);
+                if (analyzed.type === COMPILER_TYPE_ARRAY && varName) {
+                    ctx.bindings.set(`${varName}.${analyzed.key}`, COMPILER_TYPE_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 { COMPILATION_TYPE_COMPUTED, COMPILATION_ENTRYPOINT, COMPILATION_TYPE_SIGNAL, PACKAGE } from '../../constants.js';
+import { COMPILER_TYPE_COMPUTED, COMPILER_ENTRYPOINT, COMPILER_TYPE_SIGNAL, 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 COMPILATION_TYPE_COMPUTED;
+        return COMPILER_TYPE_COMPUTED;
     }
     if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
         return null;
     }
-    return COMPILATION_TYPE_SIGNAL;
+    return COMPILER_TYPE_SIGNAL;
 }
 function findBinding(bindings, name, node) {
     for (let i = 0, n = bindings.length; i < n; i++) {
@@ -83,7 +83,7 @@ function isReactiveReassignment(node) {
         parent.right === node &&
         ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILATION_ENTRYPOINT) {
+        node.expression.text === COMPILER_ENTRYPOINT) {
         return true;
     }
     return false;
@@ -114,7 +114,7 @@ function visit(ctx, node) {
         let clause = node.importClause;
         if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
             for (let i = 0, n = clause.namedBindings.elements.length; i < n; i++) {
-                if (clause.namedBindings.elements[i].name.text === COMPILATION_ENTRYPOINT) {
+                if (clause.namedBindings.elements[i].name.text === COMPILER_ENTRYPOINT) {
                     ctx.hasReactiveImport = true;
                     break;
                 }
@@ -124,7 +124,7 @@ function visit(ctx, node) {
     if (ctx.hasReactiveImport &&
         ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILATION_ENTRYPOINT &&
+        node.expression.text === COMPILER_ENTRYPOINT &&
         node.arguments.length > 0) {
         let arg = node.arguments[0], classification = classifyReactiveArg(arg);
         if (classification) {
@@ -143,7 +143,7 @@ function visit(ctx, node) {
                 ctx.scopedBindings.push({ name: varName, scope, type: classification });
                 ctx.bindings.set(varName, classification);
             }
-            if (classification === COMPILATION_TYPE_COMPUTED) {
+            if (classification === COMPILER_TYPE_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 !== COMPILATION_TYPE_COMPUTED) {
+                    if (binding.type !== COMPILER_TYPE_COMPUTED) {
                         let parent = node.parent;
                         if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
                             ctx.replacements.push({

package/package.json

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

package/src/constants.ts

@@ -1,16 +1,17 @@
-import uid from 'node_modules/@esportsplus/typescript/build/transformer/uid';
+import { uid } from '@esportsplus/typescript/transformer';
 
-const COMPILATION_ENTRYPOINT = 'reactive';
 
-const COMPILATION_ENTRYPOINT_REGEX = /\breactive\b/;
+const COMPILER_ENTRYPOINT = 'reactive';
 
-const COMPILATION_NAMESPACE = uid(COMPILATION_ENTRYPOINT);
+const COMPILER_ENTRYPOINT_REGEX = /\breactive\b/;
 
-const COMPILATION_TYPE_ARRAY = 'array';
+const COMPILER_NAMESPACE = uid(COMPILER_ENTRYPOINT);
 
-const COMPILATION_TYPE_COMPUTED = 'computed';
+const COMPILER_TYPE_ARRAY = 'array';
 
-const COMPILATION_TYPE_SIGNAL = 'signal';
+const COMPILER_TYPE_COMPUTED = 'computed';
+
+const COMPILER_TYPE_SIGNAL = 'signal';
 
 
 const COMPUTED = Symbol('reactivity.computed');
@@ -47,7 +48,7 @@ const STATE_NOTIFY_MASK = (STATE_CHECK | STATE_DIRTY);
 
 
 export {
-    COMPILATION_TYPE_ARRAY, COMPILATION_TYPE_COMPUTED, COMPILATION_ENTRYPOINT, COMPILATION_ENTRYPOINT_REGEX, COMPILATION_NAMESPACE, COMPILATION_TYPE_SIGNAL, COMPUTED,
+    COMPILER_TYPE_ARRAY, COMPILER_TYPE_COMPUTED, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE, COMPILER_TYPE_SIGNAL, COMPUTED,
     PACKAGE,
     REACTIVE_ARRAY, REACTIVE_OBJECT,
     SIGNAL,

package/src/reactive/index.ts

@@ -1,5 +1,5 @@
 import { ReactiveArray } from './array';
-import { COMPILATION_ENTRYPOINT, PACKAGE } from '~/constants';
+import { COMPILER_ENTRYPOINT, PACKAGE } from '~/constants';
 import { Reactive } from '~/types';
 
 
@@ -14,7 +14,7 @@ type Guard<T> =
 function reactive<T extends Record<PropertyKey, any>>(_input: Guard<T>): Reactive<T>;
 function reactive<T>(_input: T): Reactive<T> {
     throw new Error(
-        `${PACKAGE}: ${COMPILATION_ENTRYPOINT}() called at runtime. ` +
+        `${PACKAGE}: ${COMPILER_ENTRYPOINT}() called at runtime. ` +
         'Ensure vite plugin is configured.'
     );
 }

package/src/transformer/detector.ts

@@ -1,6 +1,6 @@
 import { code as c } from '@esportsplus/typescript/transformer';
 import { ts } from '@esportsplus/typescript';
-import { COMPILATION_ENTRYPOINT, COMPILATION_ENTRYPOINT_REGEX } from '~/constants';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX } from '~/constants';
 
 
 function visit(ctx: { imported: boolean; used: boolean; }, node: ts.Node): void {
@@ -18,7 +18,7 @@ function visit(ctx: { imported: boolean; used: boolean; }, node: ts.Node): void
         for (let i = 0, n = elements.length; i < n; i++) {
             let element = elements[i];
 
-            if ((element.propertyName?.text ?? element.name.text) === COMPILATION_ENTRYPOINT) {
+            if ((element.propertyName?.text ?? element.name.text) === COMPILER_ENTRYPOINT) {
                 ctx.imported = true;
                 break;
             }
@@ -28,7 +28,7 @@ function visit(ctx: { imported: boolean; used: boolean; }, node: ts.Node): void
     if (
         ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILATION_ENTRYPOINT
+        node.expression.text === COMPILER_ENTRYPOINT
     ) {
         ctx.used = true;
     }
@@ -38,7 +38,7 @@ function visit(ctx: { imported: boolean; used: boolean; }, node: ts.Node): void
 
 
 const contains = (code: string): boolean => {
-    if (!c.contains(code, { regex: COMPILATION_ENTRYPOINT_REGEX })) {
+    if (!c.contains(code, { regex: COMPILER_ENTRYPOINT_REGEX })) {
         return false;
     }
 

package/src/transformer/index.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
-import { COMPILATION_NAMESPACE } from '~/constants.js';
+import { COMPILER_NAMESPACE } from '~/constants.js';
 import type { Bindings, TransformResult } from '~/types';
 import { contains } from './detector';
 import array from './transforms/array';
@@ -22,7 +22,7 @@ const transform = (sourceFile: ts.SourceFile): TransformResult => {
     }
 
     for (let i = 0, n = transforms.length; i < n; i++) {
-        result = transforms[i](current, bindings, COMPILATION_NAMESPACE);
+        result = transforms[i](current, bindings, COMPILER_NAMESPACE);
 
         if (result !== code) {
             current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
@@ -32,7 +32,7 @@ const transform = (sourceFile: ts.SourceFile): TransformResult => {
     }
 
     if (transformed) {
-        code = `import * as ${COMPILATION_NAMESPACE} from '@esportsplus/reactivity';\n` + code;
+        code = `import * as ${COMPILER_NAMESPACE} from '@esportsplus/reactivity';\n` + code;
         sourceFile = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
     }
 

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 { COMPILATION_TYPE_ARRAY } from '~/constants';
+import { COMPILER_TYPE_ARRAY } 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) === COMPILATION_TYPE_ARRAY) {
-            ctx.bindings.set(node.name.text, COMPILATION_TYPE_ARRAY);
+        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.isPropertyAccessExpression(node.initializer)) {
             let path = getPropertyPath(node.initializer);
 
-            if (path && ctx.bindings.get(path) === COMPILATION_TYPE_ARRAY) {
-                ctx.bindings.set(node.name.text, COMPILATION_TYPE_ARRAY);
+            if (path && ctx.bindings.get(path) === COMPILER_TYPE_ARRAY) {
+                ctx.bindings.set(node.name.text, COMPILER_TYPE_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, COMPILATION_TYPE_ARRAY);
+                ctx.bindings.set(param.name.text, COMPILER_TYPE_ARRAY);
             }
         }
     }
@@ -80,7 +80,7 @@ function visit(ctx: { bindings: Bindings, replacements: Replacement[], sourceFil
     ) {
         let name = getExpressionName(node.expression);
 
-        if (name && ctx.bindings.get(name) === COMPILATION_TYPE_ARRAY) {
+        if (name && ctx.bindings.get(name) === COMPILER_TYPE_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) === COMPILATION_TYPE_ARRAY) {
+        if (objName && ctx.bindings.get(objName) === COMPILER_TYPE_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,6 +1,6 @@
 import { ts } from '@esportsplus/typescript';
 import { code as c, type Replacement } from '@esportsplus/typescript/transformer';
-import { COMPILATION_TYPE_ARRAY, COMPILATION_TYPE_COMPUTED, COMPILATION_TYPE_SIGNAL, PACKAGE } from '~/constants';
+import { COMPILER_TYPE_ARRAY, COMPILER_TYPE_COMPUTED, COMPILER_TYPE_SIGNAL, PACKAGE } from '~/constants';
 import type { Bindings } from '~/types';
 
 
@@ -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: COMPILATION_TYPE_COMPUTED, valueText };
+        return { key, type: COMPILER_TYPE_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: COMPILATION_TYPE_ARRAY, valueText: elementsText };
+        return { key, type: COMPILER_TYPE_ARRAY, valueText: elementsText };
     }
 
-    return { key, type: COMPILATION_TYPE_SIGNAL, valueText };
+    return { key, type: COMPILER_TYPE_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 === COMPILATION_TYPE_SIGNAL) {
+        if (type === COMPILER_TYPE_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 === COMPILATION_TYPE_ARRAY) {
+        else if (type === COMPILER_TYPE_ARRAY) {
             fields.push(`${key} = new ${ns}.ReactiveArray(${valueText});`);
             disposeStatements.push(`this.${key}.dispose();`);
         }
-        else if (type === COMPILATION_TYPE_COMPUTED) {
+        else if (type === COMPILER_TYPE_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});`);
@@ -167,8 +167,8 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 
                 properties.push(analyzed);
 
-                if (analyzed.type === COMPILATION_TYPE_ARRAY && varName) {
-                    ctx.bindings.set(`${varName}.${analyzed.key}`, COMPILATION_TYPE_ARRAY);
+                if (analyzed.type === COMPILER_TYPE_ARRAY && varName) {
+                    ctx.bindings.set(`${varName}.${analyzed.key}`, COMPILER_TYPE_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 { COMPILATION_TYPE_COMPUTED, COMPILATION_ENTRYPOINT, COMPILATION_TYPE_SIGNAL, PACKAGE } from '~/constants';
+import { COMPILER_TYPE_COMPUTED, COMPILER_ENTRYPOINT, COMPILER_TYPE_SIGNAL, PACKAGE } from '~/constants';
 
 
 interface ArgContext {
@@ -51,14 +51,14 @@ let COMPOUND_OPERATORS = new Map<ts.SyntaxKind, string>([
 
 function classifyReactiveArg(arg: ts.Expression): BindingType | null {
     if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
-        return COMPILATION_TYPE_COMPUTED;
+        return COMPILER_TYPE_COMPUTED;
     }
 
     if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
         return null;
     }
 
-    return COMPILATION_TYPE_SIGNAL;
+    return COMPILER_TYPE_SIGNAL;
 }
 
 function findBinding(bindings: ScopeBinding[], name: string, node: ts.Node): ScopeBinding | undefined {
@@ -137,7 +137,7 @@ function isReactiveReassignment(node: ts.Node): boolean {
         parent.right === node &&
         ts.isCallExpression(node) &&
         ts.isIdentifier((node as ts.CallExpression).expression) &&
-        ((node as ts.CallExpression).expression as ts.Identifier).text === COMPILATION_ENTRYPOINT
+        ((node as ts.CallExpression).expression as ts.Identifier).text === COMPILER_ENTRYPOINT
     ) {
         return true;
     }
@@ -181,7 +181,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 
         if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
             for (let i = 0, n = clause.namedBindings.elements.length; i < n; i++) {
-                if (clause.namedBindings.elements[i].name.text === COMPILATION_ENTRYPOINT) {
+                if (clause.namedBindings.elements[i].name.text === COMPILER_ENTRYPOINT) {
                     ctx.hasReactiveImport = true;
                     break;
                 }
@@ -193,7 +193,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         ctx.hasReactiveImport &&
         ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILATION_ENTRYPOINT &&
+        node.expression.text === COMPILER_ENTRYPOINT &&
         node.arguments.length > 0
     ) {
         let arg = node.arguments[0],
@@ -221,7 +221,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
                 ctx.bindings.set(varName, classification);
             }
 
-            if (classification === COMPILATION_TYPE_COMPUTED) {
+            if (classification === COMPILER_TYPE_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 !== COMPILATION_TYPE_COMPUTED) {
+                    if (binding.type !== COMPILER_TYPE_COMPUTED) {
                         let parent = node.parent;
 
                         if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {