@esportsplus/reactivity 0.24.4 → 0.25.0

package/src/types.ts

@@ -1,17 +1,12 @@
 import { COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
 import { ReactiveArray, ReactiveObject } from './reactive';
+import { ts } from '@esportsplus/typescript';
 
 
 type BindingType = 'array' | 'computed' | 'object' | 'signal';
 
 type Bindings = Map<string, BindingType>;
 
-interface Namespaces {
-    array: string;
-    constants: string;
-    reactivity: string;
-}
-
 interface Computed<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
@@ -48,14 +43,20 @@ type Signal<T> = {
     value: T;
 };
 
+interface TransformResult {
+    code: string;
+    sourceFile: ts.SourceFile;
+    transformed: boolean;
+}
+
 
 export type {
     BindingType,
     Bindings,
     Computed,
     Link,
-    Namespaces,
     ReactiveArray,
     ReactiveObject,
-    Signal
+    Signal,
+    TransformResult
 };

package/test/vite.config.ts

@@ -1,6 +1,6 @@
 import { resolve } from 'path';
 import { defineConfig } from 'vite';
-import reactivity from '../build/transformer/plugins/vite.js';
+import { plugin as reactivity } from '../build/plugins/vite.js';
 
 
 export default defineConfig({

package/build/transformer/factory.d.ts

@@ -1,13 +0,0 @@
-import { ts } from '@esportsplus/typescript';
-declare function createReadCall(factory: ts.NodeFactory, ns: string, expr: ts.Expression): ts.CallExpression;
-declare function createSetCall(factory: ts.NodeFactory, ns: string, target: ts.Expression, value: ts.Expression): ts.CallExpression;
-declare function createSignalCall(factory: ts.NodeFactory, ns: string, initialValue: ts.Expression): ts.CallExpression;
-declare function createComputedCall(factory: ts.NodeFactory, ns: string, fn: ts.Expression): ts.CallExpression;
-declare function createArrayLengthCall(factory: ts.NodeFactory, arrayExpr: ts.Expression): ts.CallExpression;
-declare function createArraySetCall(factory: ts.NodeFactory, arrayExpr: ts.Expression, index: ts.Expression, value: ts.Expression): ts.CallExpression;
-declare function createReactiveArrayNew(factory: ts.NodeFactory, ns: string, elements: ts.Expression[]): ts.NewExpression;
-declare function createDisposeCall(factory: ts.NodeFactory, ns: string, expr: ts.Expression): ts.CallExpression;
-declare function createBinaryExpr(factory: ts.NodeFactory, left: ts.Expression, op: ts.BinaryOperator, right: ts.Expression): ts.BinaryExpression;
-declare function createCommaExpr(factory: ts.NodeFactory, first: ts.Expression, second: ts.Expression): ts.ParenthesizedExpression;
-declare function createPostfixIncrementExpr(factory: ts.NodeFactory, ns: string, tmpName: string, signalName: string, op: ts.SyntaxKind.PlusToken | ts.SyntaxKind.MinusToken): ts.CallExpression;
-export { createArrayLengthCall, createArraySetCall, createBinaryExpr, createCommaExpr, createComputedCall, createDisposeCall, createPostfixIncrementExpr, createReactiveArrayNew, createReadCall, createSetCall, createSignalCall };

package/build/transformer/factory.js

@@ -1,36 +0,0 @@
-import { ts } from '@esportsplus/typescript';
-function createReadCall(factory, ns, expr) {
-    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'read'), undefined, [expr]);
-}
-function createSetCall(factory, ns, target, value) {
-    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'set'), undefined, [target, value]);
-}
-function createSignalCall(factory, ns, initialValue) {
-    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'signal'), undefined, [initialValue]);
-}
-function createComputedCall(factory, ns, fn) {
-    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'computed'), undefined, [fn]);
-}
-function createArrayLengthCall(factory, arrayExpr) {
-    return factory.createCallExpression(factory.createPropertyAccessExpression(arrayExpr, '$length'), undefined, []);
-}
-function createArraySetCall(factory, arrayExpr, index, value) {
-    return factory.createCallExpression(factory.createPropertyAccessExpression(arrayExpr, '$set'), undefined, [index, value]);
-}
-function createReactiveArrayNew(factory, ns, elements) {
-    return factory.createNewExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'ReactiveArray'), undefined, elements);
-}
-function createDisposeCall(factory, ns, expr) {
-    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'dispose'), undefined, [expr]);
-}
-function createBinaryExpr(factory, left, op, right) {
-    return factory.createBinaryExpression(left, op, right);
-}
-function createCommaExpr(factory, first, second) {
-    return factory.createParenthesizedExpression(factory.createBinaryExpression(first, ts.SyntaxKind.CommaToken, second));
-}
-function createPostfixIncrementExpr(factory, ns, tmpName, signalName, op) {
-    let tmpIdent = factory.createIdentifier(tmpName), signalIdent = factory.createIdentifier(signalName);
-    return factory.createCallExpression(factory.createParenthesizedExpression(factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, tmpIdent)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), createCommaExpr(factory, createSetCall(factory, ns, signalIdent, factory.createBinaryExpression(tmpIdent, op, factory.createNumericLiteral(1))), tmpIdent))), undefined, [factory.createPropertyAccessExpression(signalIdent, 'value')]);
-}
-export { createArrayLengthCall, createArraySetCall, createBinaryExpr, createCommaExpr, createComputedCall, createDisposeCall, createPostfixIncrementExpr, createReactiveArrayNew, createReadCall, createSetCall, createSignalCall };

package/src/transformer/factory.ts

@@ -1,141 +0,0 @@
-import { ts } from '@esportsplus/typescript';
-
-
-// Create: ns.read(expr)
-function createReadCall(factory: ts.NodeFactory, ns: string, expr: ts.Expression): ts.CallExpression {
-    return factory.createCallExpression(
-        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'read'),
-        undefined,
-        [expr]
-    );
-}
-
-// Create: ns.set(target, value)
-function createSetCall(factory: ts.NodeFactory, ns: string, target: ts.Expression, value: ts.Expression): ts.CallExpression {
-    return factory.createCallExpression(
-        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'set'),
-        undefined,
-        [target, value]
-    );
-}
-
-// Create: ns.signal(initialValue)
-function createSignalCall(factory: ts.NodeFactory, ns: string, initialValue: ts.Expression): ts.CallExpression {
-    return factory.createCallExpression(
-        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'signal'),
-        undefined,
-        [initialValue]
-    );
-}
-
-// Create: ns.computed(fn)
-function createComputedCall(factory: ts.NodeFactory, ns: string, fn: ts.Expression): ts.CallExpression {
-    return factory.createCallExpression(
-        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'computed'),
-        undefined,
-        [fn]
-    );
-}
-
-// Create: arr.$length()
-function createArrayLengthCall(factory: ts.NodeFactory, arrayExpr: ts.Expression): ts.CallExpression {
-    return factory.createCallExpression(
-        factory.createPropertyAccessExpression(arrayExpr, '$length'),
-        undefined,
-        []
-    );
-}
-
-// Create: arr.$set(index, value)
-function createArraySetCall(factory: ts.NodeFactory, arrayExpr: ts.Expression, index: ts.Expression, value: ts.Expression): ts.CallExpression {
-    return factory.createCallExpression(
-        factory.createPropertyAccessExpression(arrayExpr, '$set'),
-        undefined,
-        [index, value]
-    );
-}
-
-// Create: new ns.ReactiveArray(elements...)
-function createReactiveArrayNew(factory: ts.NodeFactory, ns: string, elements: ts.Expression[]): ts.NewExpression {
-    return factory.createNewExpression(
-        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'ReactiveArray'),
-        undefined,
-        elements
-    );
-}
-
-// Create: ns.dispose(expr)
-function createDisposeCall(factory: ts.NodeFactory, ns: string, expr: ts.Expression): ts.CallExpression {
-    return factory.createCallExpression(
-        factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'dispose'),
-        undefined,
-        [expr]
-    );
-}
-
-// Create binary expression: left op right
-function createBinaryExpr(factory: ts.NodeFactory, left: ts.Expression, op: ts.BinaryOperator, right: ts.Expression): ts.BinaryExpression {
-    return factory.createBinaryExpression(left, op, right);
-}
-
-// Create: (expr1, expr2) - comma expression
-function createCommaExpr(factory: ts.NodeFactory, first: ts.Expression, second: ts.Expression): ts.ParenthesizedExpression {
-    return factory.createParenthesizedExpression(
-        factory.createBinaryExpression(first, ts.SyntaxKind.CommaToken, second)
-    );
-}
-
-// Create: ((tmp) => (ns.set(name, tmp op delta), tmp))(name.value)
-function createPostfixIncrementExpr(
-    factory: ts.NodeFactory,
-    ns: string,
-    tmpName: string,
-    signalName: string,
-    op: ts.SyntaxKind.PlusToken | ts.SyntaxKind.MinusToken
-): ts.CallExpression {
-    let tmpIdent = factory.createIdentifier(tmpName),
-        signalIdent = factory.createIdentifier(signalName);
-
-    return factory.createCallExpression(
-        factory.createParenthesizedExpression(
-            factory.createArrowFunction(
-                undefined,
-                undefined,
-                [factory.createParameterDeclaration(undefined, undefined, tmpIdent)],
-                undefined,
-                factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-                createCommaExpr(
-                    factory,
-                    createSetCall(
-                        factory,
-                        ns,
-                        signalIdent,
-                        factory.createBinaryExpression(
-                            tmpIdent,
-                            op,
-                            factory.createNumericLiteral(1)
-                        )
-                    ),
-                    tmpIdent
-                )
-            )
-        ),
-        undefined,
-        [factory.createPropertyAccessExpression(signalIdent, 'value')]
-    );
-}
-
-
-export {
-    createArrayLengthCall,
-    createArraySetCall,
-    createBinaryExpr,
-    createCommaExpr,
-    createComputedCall,
-    createDisposeCall,
-    createPostfixIncrementExpr,
-    createReactiveArrayNew,
-    createReadCall,
-    createSetCall,
-    createSignalCall
-};