@esportsplus/reactivity 0.25.2 → 0.25.4

package/build/constants.d.ts

@@ -1,4 +1,11 @@
+declare const COMPILATION_ENTRYPOINT = "reactive";
+declare const COMPILATION_ENTRYPOINT_REGEX: RegExp;
+declare const COMPILATION_NAMESPACE = "reactive";
+declare const COMPILATION_TYPE_ARRAY = "array";
+declare const COMPILATION_TYPE_COMPUTED = "computed";
+declare const COMPILATION_TYPE_SIGNAL = "signal";
 declare const COMPUTED: unique symbol;
+declare const PACKAGE = "@esportsplus/reactivity";
 declare const REACTIVE_ARRAY: unique symbol;
 declare const REACTIVE_OBJECT: unique symbol;
 declare const SIGNAL: unique symbol;
@@ -12,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 { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STATE_NOTIFY_MASK, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };
+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 };

package/build/constants.js

@@ -1,4 +1,11 @@
+const COMPILATION_ENTRYPOINT = 'reactive';
+const COMPILATION_ENTRYPOINT_REGEX = /\breactive\b/;
+const COMPILATION_NAMESPACE = 'reactive';
+const COMPILATION_TYPE_ARRAY = 'array';
+const COMPILATION_TYPE_COMPUTED = 'computed';
+const COMPILATION_TYPE_SIGNAL = 'signal';
 const COMPUTED = Symbol('reactivity.computed');
+const PACKAGE = '@esportsplus/reactivity';
 const REACTIVE_ARRAY = Symbol('reactivity.reactive.array');
 const REACTIVE_OBJECT = Symbol('reactivity.reactive.object');
 const SIGNAL = Symbol('reactivity.signal');
@@ -12,4 +19,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 { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STATE_NOTIFY_MASK, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };
+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 };

package/build/index.d.ts

@@ -1,4 +1,4 @@
-export { STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED } from './constants.js';
-export { default as reactive } from './reactive/index.js';
+export { REACTIVE_OBJECT } from './constants.js';
+export { default as reactive, ReactiveArray } from './reactive/index.js';
 export * from './system.js';
 export * from './types.js';

package/build/index.js

@@ -1,4 +1,4 @@
-export { STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED } from './constants.js';
-export { default as reactive } from './reactive/index.js';
+export { REACTIVE_OBJECT } from './constants.js';
+export { default as reactive, ReactiveArray } from './reactive/index.js';
 export * from './system.js';
 export * from './types.js';

package/build/reactive/array.js

@@ -1,8 +1,10 @@
 import { isArray } from '@esportsplus/utilities';
-import { read, set, signal } from '../system.js';
+import { read, signal, write } from '../system.js';
 import { REACTIVE_ARRAY, REACTIVE_OBJECT } from '../constants.js';
-function isReactiveObject(value) {
-    return value !== null && typeof value === 'object' && value[REACTIVE_OBJECT] === true;
+function dispose(value) {
+    if (value !== null && typeof value === 'object' && value[REACTIVE_OBJECT] === true) {
+        value.dispose();
+    }
 }
 class ReactiveArray extends Array {
     _length;
@@ -21,13 +23,13 @@ class ReactiveArray extends Array {
         }
         this[i] = value;
         if (i >= super.length) {
-            set(this._length, i + 1);
+            write(this._length, i + 1);
         }
         this.dispatch('set', { index: i, item: value });
     }
     clear() {
         this.dispose();
-        set(this._length, 0);
+        write(this._length, 0);
         this.dispatch('clear');
     }
     concat(...items) {
@@ -46,7 +48,7 @@ class ReactiveArray extends Array {
             }
         }
         if (added.length) {
-            set(this._length, super.length);
+            write(this._length, super.length);
             this.dispatch('concat', { items: added });
         }
         return this;
@@ -76,14 +78,10 @@ class ReactiveArray extends Array {
         }
     }
     dispose() {
-        let item;
         while (this.length) {
-            item = super.pop();
-            if (isReactiveObject(item)) {
-                item.dispose();
-            }
+            dispose(super.pop());
         }
-        set(this._length, 0);
+        write(this._length, 0);
     }
     on(event, listener) {
         let listeners = this.listeners[event];
@@ -114,10 +112,8 @@ class ReactiveArray extends Array {
     pop() {
         let item = super.pop();
         if (item !== undefined) {
-            set(this._length, super.length);
-            if (isReactiveObject(item)) {
-                item.dispose();
-            }
+            dispose(item);
+            write(this._length, super.length);
             this.dispatch('pop', { item });
         }
         return item;
@@ -127,7 +123,7 @@ class ReactiveArray extends Array {
             return super.length;
         }
         let length = super.push(...items);
-        set(this._length, length);
+        write(this._length, length);
         this.dispatch('push', { items });
         return length;
     }
@@ -139,10 +135,8 @@ class ReactiveArray extends Array {
     shift() {
         let item = super.shift();
         if (item !== undefined) {
-            set(this._length, super.length);
-            if (isReactiveObject(item)) {
-                item.dispose();
-            }
+            dispose(item);
+            write(this._length, super.length);
             this.dispatch('shift', { item });
         }
         return item;
@@ -179,12 +173,9 @@ class ReactiveArray extends Array {
     splice(start, deleteCount = this.length, ...items) {
         let removed = super.splice(start, deleteCount, ...items);
         if (items.length > 0 || removed.length > 0) {
-            set(this._length, super.length);
+            write(this._length, super.length);
             for (let i = 0, n = removed.length; i < n; i++) {
-                let item = removed[i];
-                if (isReactiveObject(item)) {
-                    item.dispose();
-                }
+                dispose(removed[i]);
             }
             this.dispatch('splice', { deleteCount, items, start });
         }
@@ -192,7 +183,7 @@ class ReactiveArray extends Array {
     }
     unshift(...items) {
         let length = super.unshift(...items);
-        set(this._length, length);
+        write(this._length, length);
         this.dispatch('unshift', { items });
         return length;
     }

package/build/reactive/index.d.ts

@@ -1,26 +1,25 @@
 import { Prettify } from '@esportsplus/utilities';
-import { REACTIVE_OBJECT } from '../constants.js';
 import { ReactiveArray } from './array.js';
+import { Reactive } from '../types.js';
 declare const READONLY: unique symbol;
-type Infer<T> = T extends (...args: unknown[]) => Promise<infer R> ? R | undefined : T extends (...args: any[]) => infer R ? R : T extends (infer U)[] ? ReactiveArray<U> : T extends ReactiveObject<any> ? T : T extends Record<PropertyKey, unknown> ? {
+type Guard<T> = T extends Record<PropertyKey, unknown> ? T extends {
+    dispose: any;
+} ? {
+    never: '[ dispose ] is a reserved key';
+} : T : never;
+type Infer<T> = T extends (...args: unknown[]) => Promise<infer R> ? R | undefined : T extends (...args: any[]) => infer R ? R : T extends (infer U)[] ? U[] & Pick<ReactiveArray<U>, 'clear' | 'on' | 'once'> : T extends ReactiveObject<any> ? T : T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: T[K];
 } : T;
-type ReactiveObject<T> = T extends Record<PropertyKey, unknown> ? Prettify<{
+type ReactiveObject<T> = T extends Record<PropertyKey, unknown> ? Reactive<Prettify<{
     [K in keyof T]: Infer<T[K]>;
 } & {
-    [REACTIVE_OBJECT]: true;
     dispose: VoidFunction;
-}> : T extends (infer U)[] ? ReactiveArray<U> : never;
-type ReactiveObjectGuard<T> = T extends {
-    dispose: any;
-} ? {
-    never: '[ dispose ] is a reserved key';
-} : T;
-declare function reactive<T extends () => unknown>(_input: T): ReturnType<T> & {
+}>> : T extends (infer U)[] ? U[] & Pick<ReactiveArray<U>, 'clear' | 'on' | 'once'> : never;
+declare function reactive<T extends () => unknown>(_input: T): Reactive<ReturnType<T> & {
     readonly [READONLY]: true;
-};
-declare function reactive<T extends Record<PropertyKey, any>>(_input: ReactiveObjectGuard<T>): ReactiveObject<T>;
-declare function reactive<T>(_input: T[]): ReactiveArray<T>;
+}>;
+declare function reactive<T extends Record<PropertyKey, any>>(_input: Guard<T>): ReactiveObject<T>;
+declare function reactive<T>(_input: T[]): Reactive<T[] & Pick<ReactiveArray<T>, 'clear' | 'on' | 'once'>>;
 export default reactive;
 export { reactive, ReactiveArray };
-export type { ReactiveObject };
+export type { Reactive, ReactiveObject };

package/build/reactive/index.js

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

package/build/system.d.ts

@@ -10,7 +10,7 @@ declare const root: {
     <T>(fn: ((dispose: VoidFunction) => T) | (() => T)): T;
     disposables: number;
 };
-declare const set: <T>(signal: Signal<T>, value: T) => void;
 declare const signal: <T>(value: T) => Signal<T>;
-export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, set, signal };
+declare const write: <T>(signal: Signal<T>, value: T) => void;
+export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, write };
 export type { Computed, Signal };

package/build/system.js

@@ -368,7 +368,15 @@ const root = (fn) => {
     return value;
 };
 root.disposables = 0;
-const set = (signal, value) => {
+const signal = (value) => {
+    return {
+        subs: null,
+        subsTail: null,
+        type: SIGNAL,
+        value,
+    };
+};
+const write = (signal, value) => {
     if (signal.value === value) {
         return;
     }
@@ -382,12 +390,4 @@ const set = (signal, value) => {
     }
     schedule();
 };
-const signal = (value) => {
-    return {
-        subs: null,
-        subsTail: null,
-        type: SIGNAL,
-        value,
-    };
-};
-export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, set, signal };
+export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, write };

package/build/transformer/detector.d.ts

@@ -1,2 +1,2 @@
-declare const mightNeedTransform: (code: string) => boolean;
-export { mightNeedTransform };
+declare const contains: (code: string) => boolean;
+export { contains };

package/build/transformer/detector.js

@@ -1,8 +1,8 @@
-import { mightNeedTransform as checkTransform } from '@esportsplus/typescript/transformer';
+import { code as c } from '@esportsplus/typescript/transformer';
 import { ts } from '@esportsplus/typescript';
-const REACTIVE_REGEX = /\breactive\b/;
+import { COMPILATION_ENTRYPOINT, COMPILATION_ENTRYPOINT_REGEX } from '../constants.js';
 function visit(ctx, node) {
-    if (ctx.hasImport && ctx.hasUsage) {
+    if (ctx.imported && ctx.used) {
         return;
     }
     if (ts.isImportDeclaration(node) &&
@@ -10,29 +10,29 @@ function visit(ctx, node) {
         ts.isNamedImports(node.importClause.namedBindings)) {
         let elements = node.importClause.namedBindings.elements;
         for (let i = 0, n = elements.length; i < n; i++) {
-            let el = elements[i], name = el.propertyName?.text ?? el.name.text;
-            if (name === 'reactive') {
-                ctx.hasImport = true;
+            let element = elements[i];
+            if ((element.propertyName?.text ?? element.name.text) === COMPILATION_ENTRYPOINT) {
+                ctx.imported = true;
                 break;
             }
         }
     }
     if (ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
-        node.expression.text === 'reactive') {
-        ctx.hasUsage = true;
+        node.expression.text === COMPILATION_ENTRYPOINT) {
+        ctx.used = true;
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-const mightNeedTransform = (code) => {
-    if (!checkTransform(code, { regex: REACTIVE_REGEX })) {
+const contains = (code) => {
+    if (!c.contains(code, { regex: COMPILATION_ENTRYPOINT_REGEX })) {
         return false;
     }
     let ctx = {
-        hasImport: false,
-        hasUsage: false
+        imported: false,
+        used: false
     };
     visit(ctx, ts.createSourceFile('detect.ts', code, ts.ScriptTarget.Latest, false));
-    return ctx.hasImport && ctx.hasUsage;
+    return ctx.imported && ctx.used;
 };
-export { mightNeedTransform };
+export { contains };

package/build/transformer/index.d.ts

@@ -1,9 +1,5 @@
-import type { TransformResult } from '../types.js';
-import { mightNeedTransform } from './detector.js';
 import { ts } from '@esportsplus/typescript';
-declare const createTransformer: () => ts.TransformerFactory<ts.SourceFile>;
+import type { TransformResult } from '../types.js';
+import { contains } from './detector.js';
 declare const transform: (sourceFile: ts.SourceFile) => TransformResult;
-export { createTransformer, mightNeedTransform, transform };
-export { transformReactiveArrays } from './transforms/array.js';
-export { transformReactiveObjects } from './transforms/object.js';
-export { transformReactivePrimitives } from './transforms/primitives.js';
+export { contains, transform };

package/build/transformer/index.js

@@ -1,46 +1,28 @@
-import { mightNeedTransform } from './detector.js';
-import { transformReactiveArrays } from './transforms/array.js';
-import { transformReactiveObjects } from './transforms/object.js';
-import { transformReactivePrimitives } from './transforms/primitives.js';
 import { ts } from '@esportsplus/typescript';
-const createTransformer = () => {
-    return () => {
-        return (sourceFile) => {
-            let result = transform(sourceFile);
-            return result.transformed ? result.sourceFile : sourceFile;
-        };
-    };
-};
+import { uid } from '@esportsplus/typescript/transformer';
+import { COMPILATION_NAMESPACE } from '../constants.js';
+import { contains } from './detector.js';
+import array from './transforms/array.js';
+import object from './transforms/object.js';
+import primitives from './transforms/primitives.js';
+let ns = uid(COMPILATION_NAMESPACE), transforms = [object, array, primitives];
 const transform = (sourceFile) => {
-    let bindings = new Map(), code = sourceFile.getFullText(), current = sourceFile, original = code, result;
-    if (!mightNeedTransform(code)) {
+    let bindings = new Map(), code = sourceFile.getFullText(), current = sourceFile, result, transformed = false;
+    if (!contains(code)) {
         return { code, sourceFile, transformed: false };
     }
-    result = transformReactiveObjects(current, bindings);
-    if (result !== code) {
-        current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
-        code = result;
-    }
-    result = transformReactiveArrays(current, bindings);
-    if (result !== code) {
-        current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
-        code = result;
+    for (let i = 0, n = transforms.length; i < n; i++) {
+        result = transforms[i](current, bindings, ns);
+        if (result !== code) {
+            current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
+            code = result;
+            transformed = true;
+        }
     }
-    result = transformReactivePrimitives(current, bindings);
-    if (result !== code) {
-        current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
-        code = result;
-    }
-    if (code === original) {
-        return { code, sourceFile, transformed: false };
+    if (transformed) {
+        code = `import * as ${ns} from '@esportsplus/reactivity';\n` + code;
+        sourceFile = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
     }
-    return {
-        code,
-        sourceFile: current,
-        transformed: true
-    };
+    return { code, sourceFile, transformed };
 };
-export { createTransformer, mightNeedTransform, transform };
-export { transformReactiveArrays } from './transforms/array.js';
-export { transformReactiveObjects } from './transforms/object.js';
-export { transformReactivePrimitives } from './transforms/primitives.js';
+export { contains, transform };

package/build/transformer/plugins/tsc.js

@@ -1,4 +1,9 @@
-import { createTransformer } from '../../transformer/index.js';
+import { transform } from '../../transformer/index.js';
 export default (_program) => {
-    return createTransformer();
+    return () => {
+        return (sourceFile) => {
+            let result = transform(sourceFile);
+            return result.transformed ? result.sourceFile : sourceFile;
+        };
+    };
 };

package/build/transformer/plugins/vite.js

@@ -1,26 +1,24 @@
-import { TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
-import { mightNeedTransform, transform } from '../../transformer/index.js';
 import { ts } from '@esportsplus/typescript';
+import { TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
+import { contains, transform } from '../../transformer/index.js';
+import { PACKAGE } from '../../constants.js';
 export default () => {
     return {
         enforce: 'pre',
-        name: '@esportsplus/reactivity/plugin-vite',
+        name: `${PACKAGE}/plugin-vite`,
         transform(code, id) {
-            if (!TRANSFORM_PATTERN.test(id) || id.includes('node_modules')) {
-                return null;
-            }
-            if (!mightNeedTransform(code)) {
+            if (!TRANSFORM_PATTERN.test(id) || id.includes('node_modules') || !contains(code)) {
                 return null;
             }
             try {
-                let sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true), result = transform(sourceFile);
+                let result = transform(ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true));
                 if (!result.transformed) {
                     return null;
                 }
                 return { code: result.code, map: null };
             }
             catch (error) {
-                console.error(`@esportsplus/reactivity: Error transforming ${id}:`, error);
+                console.error(`${PACKAGE}: Error transforming ${id}:`, error);
                 return null;
             }
         }

package/build/transformer/transforms/array.d.ts

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

package/build/transformer/transforms/array.js

@@ -1,5 +1,6 @@
-import { applyReplacements } from './utilities.js';
+import { code as c } from '@esportsplus/typescript/transformer';
 import { ts } from '@esportsplus/typescript';
+import { COMPILATION_TYPE_ARRAY } from '../../constants.js';
 function getExpressionName(node) {
     if (ts.isIdentifier(node)) {
         return node.text;
@@ -12,33 +13,30 @@ function getExpressionName(node) {
 function getPropertyPath(node) {
     let current = node, parts = [];
     while (ts.isPropertyAccessExpression(current)) {
-        parts.unshift(current.name.text);
+        parts.push(current.name.text);
         current = current.expression;
     }
     if (ts.isIdentifier(current)) {
-        parts.unshift(current.text);
-        return parts.join('.');
+        parts.push(current.text);
+        return parts.reverse().join('.');
     }
     return null;
 }
 function isAssignmentTarget(node) {
     let parent = node.parent;
-    if ((ts.isBinaryExpression(parent) && parent.left === node) ||
+    return !!parent && ((ts.isBinaryExpression(parent) && parent.left === node) ||
         ts.isPostfixUnaryExpression(parent) ||
-        ts.isPrefixUnaryExpression(parent)) {
-        return true;
-    }
-    return false;
+        ts.isPrefixUnaryExpression(parent));
 }
 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) === 'array') {
-            ctx.bindings.set(node.name.text, 'array');
+        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.isPropertyAccessExpression(node.initializer)) {
             let path = getPropertyPath(node.initializer);
-            if (path && ctx.bindings.get(path) === 'array') {
-                ctx.bindings.set(node.name.text, 'array');
+            if (path && ctx.bindings.get(path) === COMPILATION_TYPE_ARRAY) {
+                ctx.bindings.set(node.name.text, COMPILATION_TYPE_ARRAY);
             }
         }
     }
@@ -49,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, 'array');
+                ctx.bindings.set(param.name.text, COMPILATION_TYPE_ARRAY);
             }
         }
     }
@@ -57,7 +55,7 @@ function visit(ctx, node) {
         node.name.text === 'length' &&
         !isAssignmentTarget(node)) {
         let name = getExpressionName(node.expression);
-        if (name && ctx.bindings.get(name) === 'array') {
+        if (name && ctx.bindings.get(name) === COMPILATION_TYPE_ARRAY) {
             let objText = node.expression.getText(ctx.sourceFile);
             ctx.replacements.push({
                 end: node.end,
@@ -70,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) === 'array') {
+        if (objName && ctx.bindings.get(objName) === COMPILATION_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,
@@ -81,13 +79,12 @@ function visit(ctx, node) {
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-const transformReactiveArrays = (sourceFile, bindings) => {
+export default (sourceFile, bindings, _ns) => {
     let code = sourceFile.getFullText(), ctx = {
         bindings,
         replacements: [],
         sourceFile
     };
     visit(ctx, sourceFile);
-    return applyReplacements(code, ctx.replacements);
+    return c.replace(code, ctx.replacements);
 };
-export { transformReactiveArrays };

package/build/transformer/transforms/object.d.ts

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