@esportsplus/reactivity 0.25.3 → 0.25.4

package/src/reactive/array.ts

@@ -1,5 +1,5 @@
 import { isArray } from '@esportsplus/utilities';
-import { read, set, signal } from '~/system';
+import { read, signal, write } from '~/system';
 import { REACTIVE_ARRAY, REACTIVE_OBJECT } from '~/constants';
 import type { Signal } from '~/types';
 
@@ -44,8 +44,10 @@ type Listener<V> = {
 type Listeners = Record<string, (Listener<any> | null)[]>;
 
 
-function isReactiveObject(value: unknown): value is { dispose(): void } {
-    return value !== null && typeof value === 'object' && (value as any)[REACTIVE_OBJECT] === true;
+function dispose(value: unknown) {
+    if (value !== null && typeof value === 'object' && (value as any)[REACTIVE_OBJECT] === true) {
+        (value as { dispose(): void }).dispose();
+    }
 }
 
 
@@ -75,7 +77,7 @@ class ReactiveArray<T> extends Array<T> {
         this[i] = value;
 
         if (i >= super.length) {
-            set(this._length, i + 1);
+            write(this._length, i + 1);
         }
 
         this.dispatch('set', { index: i, item: value });
@@ -83,7 +85,7 @@ class ReactiveArray<T> extends Array<T> {
 
     clear() {
         this.dispose();
-        set(this._length, 0);
+        write(this._length, 0);
         this.dispatch('clear');
     }
 
@@ -108,7 +110,7 @@ class ReactiveArray<T> extends Array<T> {
         }
 
         if (added.length) {
-            set(this._length, super.length);
+            write(this._length, super.length);
             this.dispatch('concat', { items: added });
         }
 
@@ -147,17 +149,11 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     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<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) {
@@ -197,11 +193,8 @@ class ReactiveArray<T> extends Array<T> {
         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 });
         }
@@ -216,7 +209,7 @@ class ReactiveArray<T> extends Array<T> {
 
         let length = super.push(...items);
 
-        set(this._length, length);
+        write(this._length, length);
         this.dispatch('push', { items });
 
         return length;
@@ -233,11 +226,8 @@ class ReactiveArray<T> extends Array<T> {
         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 });
         }
@@ -294,14 +284,10 @@ class ReactiveArray<T> extends Array<T> {
         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 });
@@ -313,7 +299,7 @@ class ReactiveArray<T> extends Array<T> {
     unshift(...items: T[]) {
         let length = super.unshift(...items);
 
-        set(this._length, length);
+        write(this._length, length);
         this.dispatch('unshift', { items });
 
         return length;

package/src/reactive/index.ts

@@ -1,17 +1,26 @@
 import { Prettify } from '@esportsplus/utilities';
 import { ReactiveArray } from './array';
+import { PACKAGE } from '~/constants';
+import { Reactive } from '~/types';
 
 
 // Branded type to prevent assignment to computed values
 declare const READONLY: unique symbol;
 
+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)[]
-                ? ReactiveArray<U>
+                ? U[] & Pick<ReactiveArray<U>, 'clear' | 'on' | 'once'>
                 : T extends ReactiveObject<any>
                     ? T
                     : T extends Record<PropertyKey, unknown>
@@ -20,24 +29,18 @@ type Infer<T> =
 
 type ReactiveObject<T> =
     T extends Record<PropertyKey, unknown>
-        ? Prettify<{ [K in keyof T]: Infer<T[K]> } & { dispose: VoidFunction }>
+        ? Reactive< Prettify<{ [K in keyof T]: Infer<T[K]> } & { dispose: VoidFunction }> >
         : T extends (infer U)[]
-            ? ReactiveArray<U>
+            ? U[] & Pick<ReactiveArray<U>, 'clear' | 'on' | 'once'>
             : never;
 
-type ReactiveObjectGuard<T> = T extends { dispose: any } ? { never: '[ dispose ] is a reserved key' } : T;
-
 
-// Function input → branded return type (prevents assignment)
-function reactive<T extends () => unknown>(_input: T): ReturnType<T> & { readonly [READONLY]: true };
-// Object literal → existing ReactiveObject behavior
-function reactive<T extends Record<PropertyKey, any>>(_input: ReactiveObjectGuard<T>): ReactiveObject<T>;
-// Array literal → existing ReactiveArray behavior
-function reactive<T>(_input: T[]): ReactiveArray<T>;
-// Everything else → passthrough type (allows assignment)
-function reactive<T>(_input: T): T {
+function reactive<T extends () => unknown>(_input: T): Reactive< ReturnType<T> & { readonly [READONLY]: true } >;
+function reactive<T extends Record<PropertyKey, any>>(_input: Guard<T>): ReactiveObject<T>;
+function reactive<T>(_input: T[]): Reactive< T[] & Pick<ReactiveArray<T>, 'clear' | 'on' | 'once'> >;
+function reactive<T>(_input: T): Reactive<T> {
     throw new Error(
-        '@esportsplus/reactivity: reactive() called at runtime. ' +
+        `${PACKAGE}: reactive() called at runtime. ` +
         'Ensure vite-plugin-reactivity-compile is configured.'
     );
 }
@@ -45,4 +48,4 @@ function reactive<T>(_input: T): T {
 
 export default reactive;
 export { reactive, ReactiveArray };
-export type { ReactiveObject };
+export type { Reactive, ReactiveObject };

package/src/system.ts

@@ -1,16 +1,8 @@
 import {
     COMPUTED,
     SIGNAL,
-    STABILIZER_IDLE,
-    STABILIZER_RESCHEDULE,
-    STABILIZER_RUNNING,
-    STABILIZER_SCHEDULED,
-    STATE_CHECK,
-    STATE_DIRTY,
-    STATE_IN_HEAP,
-    STATE_NONE,
-    STATE_NOTIFY_MASK,
-    STATE_RECOMPUTING
+    STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
+    STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 } from './constants';
 import { Computed, Link, Signal } from './types';
 import { isObject } from '@esportsplus/utilities';
@@ -529,7 +521,16 @@ const root = <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => {
 
 root.disposables = 0;
 
-const set = <T>(signal: Signal<T>, value: T) => {
+const signal = <T>(value: T): Signal<T> => {
+    return {
+        subs: null,
+        subsTail: null,
+        type: SIGNAL,
+        value,
+    };
+};
+
+const write = <T>(signal: Signal<T>, value: T) => {
     if (signal.value === value) {
         return;
     }
@@ -548,15 +549,6 @@ const set = <T>(signal: Signal<T>, value: T) => {
     schedule();
 };
 
-const signal = <T>(value: T): Signal<T> => {
-    return {
-        subs: null,
-        subsTail: null,
-        type: SIGNAL,
-        value,
-    };
-};
-
 
 export {
     computed,
@@ -565,6 +557,7 @@ export {
     isComputed, isSignal,
     onCleanup,
     read, root,
-    set, signal
+    signal,
+    write
 };
 export type { Computed, Signal };

package/src/transformer/detector.ts

@@ -1,18 +1,10 @@
-import { mightNeedTransform as checkTransform } from '@esportsplus/typescript/transformer';
+import { code as c } from '@esportsplus/typescript/transformer';
 import { ts } from '@esportsplus/typescript';
+import { COMPILATION_ENTRYPOINT, COMPILATION_ENTRYPOINT_REGEX } from '~/constants';
 
 
-interface DetectContext {
-    hasImport: boolean;
-    hasUsage: boolean;
-}
-
-
-const REACTIVE_REGEX = /\breactive\b/;
-
-
-function visit(ctx: DetectContext, node: ts.Node): void {
-    if (ctx.hasImport && ctx.hasUsage) {
+function visit(ctx: { imported: boolean; used: boolean; }, node: ts.Node): void {
+    if (ctx.imported && ctx.used) {
         return;
     }
 
@@ -24,11 +16,10 @@ function visit(ctx: DetectContext, node: ts.Node): void {
         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;
+            let element = elements[i];
 
-            if (name === 'reactive') {
-                ctx.hasImport = true;
+            if ((element.propertyName?.text ?? element.name.text) === COMPILATION_ENTRYPOINT) {
+                ctx.imported = true;
                 break;
             }
         }
@@ -37,29 +28,29 @@ function visit(ctx: DetectContext, node: ts.Node): void {
     if (
         ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
-        node.expression.text === 'reactive'
+        node.expression.text === COMPILATION_ENTRYPOINT
     ) {
-        ctx.hasUsage = true;
+        ctx.used = true;
     }
 
     ts.forEachChild(node, n => visit(ctx, n));
 }
 
 
-const mightNeedTransform = (code: string): boolean => {
-    if (!checkTransform(code, { regex: REACTIVE_REGEX })) {
+const contains = (code: string): boolean => {
+    if (!c.contains(code, { regex: COMPILATION_ENTRYPOINT_REGEX })) {
         return false;
     }
 
-    let ctx: DetectContext = {
-            hasImport: false,
-            hasUsage: false
+    let ctx = {
+            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/src/transformer/index.ts

@@ -1,67 +1,45 @@
-import type { Bindings, TransformResult } from '~/types';
-import { mightNeedTransform } from './detector';
-import { transformReactiveArrays } from './transforms/array';
-import { transformReactiveObjects } from './transforms/object';
-import { transformReactivePrimitives } from './transforms/primitives';
 import { ts } from '@esportsplus/typescript';
+import { uid } from '@esportsplus/typescript/transformer';
+import { COMPILATION_NAMESPACE } from '~/constants.js';
+import type { Bindings, TransformResult } from '~/types';
+import { contains } from './detector';
+import array from './transforms/array';
+import object from './transforms/object';
+import primitives from './transforms/primitives';
 
 
-const createTransformer = (): ts.TransformerFactory<ts.SourceFile> => {
-    return () => {
-        return (sourceFile: ts.SourceFile): ts.SourceFile => {
-            let result = transform(sourceFile);
+let ns = uid(COMPILATION_NAMESPACE),
+    transforms = [object, array, primitives];
 
-            return result.transformed ? result.sourceFile : sourceFile;
-        };
-    };
-};
 
 const transform = (sourceFile: ts.SourceFile): TransformResult => {
     let bindings: Bindings = new Map(),
         code = sourceFile.getFullText(),
         current = sourceFile,
-        original = code,
-        result: string;
+        result: string,
+        transformed = false;
 
-    if (!mightNeedTransform(code)) {
+    if (!contains(code)) {
         return { code, sourceFile, transformed: false };
     }
 
-    // Run all transforms, only re-parse between transforms if code changed
-    result = transformReactiveObjects(current, bindings);
-
-    if (result !== code) {
-        current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
-        code = result;
-    }
-
-    result = transformReactiveArrays(current, bindings);
+    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;
+        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';
-export { transformReactiveObjects } from './transforms/object';
-export { transformReactivePrimitives } from './transforms/primitives';
+export { contains, transform };

package/src/transformer/plugins/tsc.ts

@@ -1,8 +1,14 @@
-import { createTransformer } from '~/transformer';
+import { transform } from '~/transformer';
 import { ts } from '@esportsplus/typescript';
 
 
 // TypeScript custom transformers API requires program parameter, but we don't use it
 export default (_program: ts.Program): ts.TransformerFactory<ts.SourceFile> => {
-    return createTransformer();
+    return () => {
+        return (sourceFile: ts.SourceFile): ts.SourceFile => {
+            let result = transform(sourceFile);
+
+            return result.transformed ? result.sourceFile : sourceFile;
+        };
+    };
 };

package/src/transformer/plugins/vite.ts

@@ -1,26 +1,23 @@
-import { TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
-import { mightNeedTransform, transform } from '~/transformer';
 import type { Plugin } from 'vite';
 import { ts } from '@esportsplus/typescript';
+import { TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
+import { contains, transform } from '~/transformer';
+import { PACKAGE } from '~/constants';
 
 
 export default (): Plugin => {
     return {
         enforce: 'pre',
-        name: '@esportsplus/reactivity/plugin-vite',
-
+        name: `${PACKAGE}/plugin-vite`,
         transform(code: string, id: string) {
-            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;
@@ -29,7 +26,7 @@ export default (): Plugin => {
                 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/src/transformer/transforms/array.ts

@@ -1,13 +1,7 @@
-import type { Bindings } from '~/types';
-import { applyReplacements, Replacement } from './utilities';
+import { code as c, type Replacement } from '@esportsplus/typescript/transformer';
 import { ts } from '@esportsplus/typescript';
-
-
-interface TransformContext {
-    bindings: Bindings;
-    replacements: Replacement[];
-    sourceFile: ts.SourceFile;
-}
+import { COMPILATION_TYPE_ARRAY } from '~/constants';
+import type { Bindings } from '~/types';
 
 
 function getExpressionName(node: ts.Expression): string | null {
@@ -27,13 +21,13 @@ function getPropertyPath(node: ts.PropertyAccessExpression): string | null {
         parts: string[] = [];
 
     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;
@@ -42,32 +36,24 @@ function getPropertyPath(node: ts.PropertyAccessExpression): string | null {
 function isAssignmentTarget(node: ts.Node): boolean {
     let parent = node.parent;
 
-    if (!parent) {
-        return false;
-    }
-
-    if (
+    return !!parent && (
         (ts.isBinaryExpression(parent) && parent.left === node) ||
         ts.isPostfixUnaryExpression(parent) ||
         ts.isPrefixUnaryExpression(parent)
-    ) {
-        return true;
-    }
-
-    return false;
+    );
 }
 
-function visit(ctx: TransformContext, node: ts.Node): void {
+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) === '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);
             }
         }
     }
@@ -82,7 +68,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
                 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);
             }
         }
     }
@@ -94,7 +80,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
     ) {
         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({
@@ -113,7 +99,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         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);
@@ -130,9 +116,9 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 }
 
 
-const transformReactiveArrays = (sourceFile: ts.SourceFile, bindings: Bindings): string => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, _ns: string): string => {
     let code = sourceFile.getFullText(),
-        ctx: TransformContext = {
+        ctx = {
             bindings,
             replacements: [],
             sourceFile
@@ -140,8 +126,5 @@ const transformReactiveArrays = (sourceFile: ts.SourceFile, bindings: Bindings):
 
     visit(ctx, sourceFile);
 
-    return applyReplacements(code, ctx.replacements);
-};
-
-
-export { transformReactiveArrays };
+    return c.replace(code, ctx.replacements);
+};