@esportsplus/reactivity 0.23.0 → 0.23.2

package/build/transformer/transforms/primitives.js

@@ -0,0 +1,335 @@
+import { uid } from '@esportsplus/typescript/transformer';
+import { addMissingImports, applyReplacements } from './utilities.js';
+import ts from 'typescript';
+function classifyReactiveArg(arg) {
+    if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+        return 'computed';
+    }
+    if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
+        return null;
+    }
+    return 'signal';
+}
+function findBinding(bindings, name, node) {
+    for (let i = 0, n = bindings.length; i < n; i++) {
+        let b = bindings[i];
+        if (b.name === name && isInScope(node, b)) {
+            return b;
+        }
+    }
+    return undefined;
+}
+function findEnclosingScope(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isBlock(current) ||
+            ts.isSourceFile(current) ||
+            ts.isFunctionDeclaration(current) ||
+            ts.isFunctionExpression(current) ||
+            ts.isArrowFunction(current) ||
+            ts.isForStatement(current) ||
+            ts.isForInStatement(current) ||
+            ts.isForOfStatement(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return node.getSourceFile();
+}
+function getCompoundOperator(kind) {
+    if (kind === ts.SyntaxKind.PlusEqualsToken) {
+        return '+';
+    }
+    else if (kind === ts.SyntaxKind.MinusEqualsToken) {
+        return '-';
+    }
+    else if (kind === ts.SyntaxKind.AsteriskEqualsToken) {
+        return '*';
+    }
+    else if (kind === ts.SyntaxKind.SlashEqualsToken) {
+        return '/';
+    }
+    else if (kind === ts.SyntaxKind.PercentEqualsToken) {
+        return '%';
+    }
+    else if (kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
+        return '**';
+    }
+    else if (kind === ts.SyntaxKind.AmpersandEqualsToken) {
+        return '&';
+    }
+    else if (kind === ts.SyntaxKind.BarEqualsToken) {
+        return '|';
+    }
+    else if (kind === ts.SyntaxKind.CaretEqualsToken) {
+        return '^';
+    }
+    else if (kind === ts.SyntaxKind.LessThanLessThanEqualsToken) {
+        return '<<';
+    }
+    else if (kind === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken) {
+        return '>>';
+    }
+    else if (kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken) {
+        return '>>>';
+    }
+    else if (kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
+        return '&&';
+    }
+    else if (kind === ts.SyntaxKind.BarBarEqualsToken) {
+        return '||';
+    }
+    else if (kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
+        return '??';
+    }
+    else {
+        return '+';
+    }
+}
+function isInComputedRange(ranges, start, end) {
+    for (let i = 0, n = ranges.length; i < n; i++) {
+        let r = ranges[i];
+        if (start >= r.start && end <= r.end) {
+            return true;
+        }
+    }
+    return false;
+}
+function isInDeclarationInit(node) {
+    let parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && parent.initializer === node) {
+        return true;
+    }
+    return false;
+}
+function isInScope(reference, binding) {
+    let current = reference;
+    while (current) {
+        if (current === binding.scope) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function isReactiveReassignment(node) {
+    let parent = node.parent;
+    if (ts.isBinaryExpression(parent) &&
+        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        parent.right === node &&
+        ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'reactive') {
+        return true;
+    }
+    return false;
+}
+function isWriteContext(node) {
+    let parent = node.parent;
+    if (ts.isBinaryExpression(parent) && parent.left === node) {
+        let op = parent.operatorToken.kind;
+        if (op === ts.SyntaxKind.EqualsToken) {
+            return 'simple';
+        }
+        if (op >= ts.SyntaxKind.PlusEqualsToken && op <= ts.SyntaxKind.CaretEqualsToken) {
+            return 'compound';
+        }
+        if (op === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
+            op === ts.SyntaxKind.BarBarEqualsToken ||
+            op === ts.SyntaxKind.QuestionQuestionEqualsToken) {
+            return 'compound';
+        }
+    }
+    if (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) {
+        let op = parent.operator;
+        if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken) {
+            return 'increment';
+        }
+    }
+    return false;
+}
+function visit(ctx, node) {
+    if (ts.isImportDeclaration(node) &&
+        ts.isStringLiteral(node.moduleSpecifier) &&
+        node.moduleSpecifier.text.includes('@esportsplus/reactivity')) {
+        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 === 'reactive') {
+                    ctx.hasReactiveImport = true;
+                    break;
+                }
+            }
+        }
+    }
+    if (ctx.hasReactiveImport &&
+        ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'reactive' &&
+        node.arguments.length > 0) {
+        let arg = node.arguments[0], classification = classifyReactiveArg(arg);
+        if (classification) {
+            let varName = null;
+            if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+                varName = node.parent.name.text;
+            }
+            else if (ts.isBinaryExpression(node.parent) &&
+                node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                ts.isIdentifier(node.parent.left)) {
+                varName = node.parent.left.text;
+            }
+            if (varName) {
+                let scope = findEnclosingScope(node);
+                ctx.scopedBindings.push({ name: varName, scope, type: classification });
+                ctx.bindings.set(varName, classification);
+            }
+            if (classification === 'computed') {
+                ctx.computedArgRanges.push({
+                    end: arg.end,
+                    start: arg.getStart(ctx.sourceFile)
+                });
+                let argCtx = {
+                    argStart: arg.getStart(ctx.sourceFile),
+                    innerReplacements: [],
+                    neededImports: ctx.neededImports,
+                    scopedBindings: ctx.scopedBindings,
+                    sourceFile: ctx.sourceFile
+                };
+                visitArg(argCtx, arg);
+                let argText = applyReplacements(arg.getText(ctx.sourceFile), argCtx.innerReplacements);
+                ctx.replacements.push({
+                    end: node.end,
+                    newText: `computed(${argText})`,
+                    start: node.pos
+                });
+                ctx.neededImports.add('computed');
+            }
+            else {
+                let argText = arg.getText(ctx.sourceFile);
+                ctx.replacements.push({
+                    end: node.end,
+                    newText: `signal(${argText})`,
+                    start: node.pos
+                });
+                ctx.neededImports.add('signal');
+            }
+        }
+    }
+    if (ts.isIdentifier(node) && !isInDeclarationInit(node.parent)) {
+        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
+            ts.forEachChild(node, n => visit(ctx, n));
+            return;
+        }
+        let nodeStart = node.getStart(ctx.sourceFile);
+        if (isInComputedRange(ctx.computedArgRanges, nodeStart, node.end)) {
+            ts.forEachChild(node, n => visit(ctx, n));
+            return;
+        }
+        let binding = findBinding(ctx.scopedBindings, node.text, node), name = node.text;
+        if (binding) {
+            if (!isReactiveReassignment(node.parent) &&
+                !(ts.isTypeOfExpression(node.parent) && node.parent.expression === node)) {
+                let writeCtx = isWriteContext(node);
+                if (writeCtx) {
+                    if (binding.type !== 'computed') {
+                        ctx.neededImports.add('set');
+                        let parent = node.parent;
+                        if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
+                            let valueText = parent.right.getText(ctx.sourceFile);
+                            ctx.replacements.push({
+                                end: parent.end,
+                                newText: `set(${name}, ${valueText})`,
+                                start: parent.pos
+                            });
+                        }
+                        else if (writeCtx === 'compound' && ts.isBinaryExpression(parent)) {
+                            let op = getCompoundOperator(parent.operatorToken.kind), valueText = parent.right.getText(ctx.sourceFile);
+                            ctx.replacements.push({
+                                end: parent.end,
+                                newText: `set(${name}, ${name}.value ${op} ${valueText})`,
+                                start: parent.pos
+                            });
+                        }
+                        else if (writeCtx === 'increment') {
+                            let isPrefix = ts.isPrefixUnaryExpression(parent), op = parent.operator, delta = op === ts.SyntaxKind.PlusPlusToken ? '+ 1' : '- 1';
+                            if (ts.isExpressionStatement(parent.parent)) {
+                                ctx.replacements.push({
+                                    end: parent.end,
+                                    newText: `set(${name}, ${name}.value ${delta})`,
+                                    start: parent.pos
+                                });
+                            }
+                            else if (isPrefix) {
+                                ctx.replacements.push({
+                                    end: parent.end,
+                                    newText: `(set(${name}, ${name}.value ${delta}), ${name}.value)`,
+                                    start: parent.pos
+                                });
+                            }
+                            else {
+                                let tmp = uid('tmp');
+                                ctx.replacements.push({
+                                    end: parent.end,
+                                    newText: `((${tmp}) => (set(${name}, ${tmp} ${delta}), ${tmp}))(${name}.value)`,
+                                    start: parent.pos
+                                });
+                            }
+                        }
+                    }
+                }
+                else {
+                    ctx.neededImports.add('read');
+                    ctx.replacements.push({
+                        end: node.end,
+                        newText: `read(${name})`,
+                        start: node.pos
+                    });
+                }
+            }
+        }
+    }
+    ts.forEachChild(node, n => visit(ctx, n));
+}
+function visitArg(ctx, node) {
+    if (ts.isIdentifier(node)) {
+        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
+            ts.forEachChild(node, n => visitArg(ctx, n));
+            return;
+        }
+        if (ts.isCallExpression(node.parent) && node.parent.expression === node) {
+            ts.forEachChild(node, n => visitArg(ctx, n));
+            return;
+        }
+        let binding = findBinding(ctx.scopedBindings, node.text, node);
+        if (binding) {
+            ctx.neededImports.add('read');
+            ctx.innerReplacements.push({
+                end: node.end - ctx.argStart,
+                newText: `read(${node.text})`,
+                start: node.getStart(ctx.sourceFile) - ctx.argStart
+            });
+        }
+    }
+    ts.forEachChild(node, n => visitArg(ctx, n));
+}
+const transformReactivePrimitives = (sourceFile, bindings) => {
+    let code = sourceFile.getFullText(), ctx = {
+        bindings,
+        computedArgRanges: [],
+        hasReactiveImport: false,
+        neededImports: new Set(),
+        replacements: [],
+        scopedBindings: [],
+        sourceFile
+    };
+    visit(ctx, sourceFile);
+    if (ctx.replacements.length === 0) {
+        return code;
+    }
+    let result = applyReplacements(code, ctx.replacements);
+    if (ctx.neededImports.size > 0) {
+        result = addMissingImports(result, ctx.neededImports);
+    }
+    return result;
+};
+export { transformReactivePrimitives };

package/build/transformer/{core/transforms → transforms}/utilities.d.ts

@@ -1,5 +1,4 @@
-import type { Replacement } from '@esportsplus/typescript/transformer';
-import { applyReplacements } from '@esportsplus/typescript/transformer';
+import { applyReplacements, type Replacement } from '@esportsplus/typescript/transformer';
 type ExtraImport = {
     module: string;
     specifier: string;

package/build/transformer/transforms/utilities.js

@@ -0,0 +1,73 @@
+import { applyReplacements } from '@esportsplus/typescript/transformer';
+import ts from 'typescript';
+function findReactivityImport(sourceFile) {
+    for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
+        let stmt = sourceFile.statements[i];
+        if (ts.isImportDeclaration(stmt) &&
+            ts.isStringLiteral(stmt.moduleSpecifier) &&
+            stmt.moduleSpecifier.text === '@esportsplus/reactivity' &&
+            stmt.importClause?.namedBindings &&
+            ts.isNamedImports(stmt.importClause.namedBindings)) {
+            return stmt;
+        }
+    }
+    return null;
+}
+function getExistingSpecifiers(namedImports) {
+    let existing = new Set();
+    for (let i = 0, n = namedImports.elements.length; i < n; i++) {
+        let el = namedImports.elements[i], name = el.propertyName?.text ?? el.name.text;
+        existing.add(name);
+    }
+    return existing;
+}
+function getFirstImportPos(sourceFile) {
+    for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
+        if (ts.isImportDeclaration(sourceFile.statements[i])) {
+            return sourceFile.statements[i].getStart(sourceFile);
+        }
+    }
+    return 0;
+}
+const addMissingImports = (code, needed, extraImports) => {
+    let sourceFile = ts.createSourceFile('temp.ts', code, ts.ScriptTarget.Latest, true), reactivityImport = findReactivityImport(sourceFile);
+    if (!reactivityImport) {
+        return code;
+    }
+    let extraSpecifiers = new Set(), namedImports = reactivityImport.importClause.namedBindings, existing = getExistingSpecifiers(namedImports), toAdd = [];
+    if (extraImports) {
+        for (let i = 0, n = extraImports.length; i < n; i++) {
+            extraSpecifiers.add(extraImports[i].specifier);
+        }
+    }
+    for (let imp of needed) {
+        if (!extraSpecifiers.has(imp) && !existing.has(imp)) {
+            toAdd.push(imp);
+        }
+    }
+    if (toAdd.length > 0) {
+        let combined = [];
+        for (let item of existing) {
+            combined.push(item);
+        }
+        for (let i = 0, n = toAdd.length; i < n; i++) {
+            combined.push(toAdd[i]);
+        }
+        combined.sort();
+        let newSpecifiers = `{ ${combined.join(', ')} }`, bindingsStart = namedImports.getStart(sourceFile), bindingsEnd = namedImports.getEnd();
+        code = code.substring(0, bindingsStart) + newSpecifiers + code.substring(bindingsEnd);
+    }
+    if (extraImports) {
+        let insertPos = getFirstImportPos(ts.createSourceFile('temp.ts', code, ts.ScriptTarget.Latest, true));
+        for (let i = 0, n = extraImports.length; i < n; i++) {
+            let extra = extraImports[i];
+            if (needed.has(extra.specifier) && !code.includes(extra.module)) {
+                code = code.substring(0, insertPos) +
+                    `import { ${extra.specifier} } from '${extra.module}';\n` +
+                    code.substring(insertPos);
+            }
+        }
+    }
+    return code;
+};
+export { addMissingImports, applyReplacements };

package/build/types.d.ts

@@ -31,12 +31,9 @@ type Signal<T> = {
     type: typeof SIGNAL;
     value: T;
 };
-interface TransformOptions {
-    autoDispose?: boolean;
-}
 interface TransformResult {
     code: string;
     sourceFile: ts.SourceFile;
     transformed: boolean;
 }
-export type { BindingType, Bindings, Computed, Link, ReactiveArray, ReactiveObject, Signal, TransformOptions, TransformResult };
+export type { BindingType, Bindings, Computed, Link, ReactiveArray, ReactiveObject, Signal, TransformResult };

package/package.json

@@ -4,7 +4,7 @@
     "@esportsplus/utilities": "^0.27.2"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.11.0",
+    "@esportsplus/typescript": "^0.12.2",
     "@types/node": "^25.0.3",
     "esbuild": "^0.27.2",
     "typescript": "^5.9.3",
@@ -20,20 +20,16 @@
       "types": "./build/constants.d.ts"
     },
     "./plugins/esbuild": {
-      "import": "./build/plugins/esbuild.js",
-      "types": "./build/plugins/esbuild.d.ts"
+      "import": "./build/transformer/plugins/esbuild.js",
+      "types": "./build/transformer/plugins/esbuild.d.ts"
     },
     "./plugins/tsc": {
-      "import": "./build/plugins/tsc.js",
-      "types": "./build/plugins/tsc.d.ts"
+      "import": "./build/transformer/plugins/tsc.js",
+      "types": "./build/transformer/plugins/tsc.d.ts"
     },
     "./plugins/vite": {
-      "import": "./build/plugins/vite.js",
-      "types": "./build/plugins/vite.d.ts"
-    },
-    "./reactive/array": {
-      "import": "./build/reactive/array.js",
-      "types": "./build/reactive/array.d.ts"
+      "import": "./build/transformer/plugins/vite.js",
+      "types": "./build/transformer/plugins/vite.d.ts"
     }
   },
   "main": "build/index.js",
@@ -45,7 +41,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "scripts": {
     "build": "tsc && tsc-alias",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",

package/readme.md

@@ -147,30 +147,6 @@ For direct TypeScript compilation using `ttsc` or `ts-patch`:
 }
 ```
 
-## Plugin Options
-
-All plugins accept the same options:
-
-```typescript
-interface TransformOptions {
-    // Inject automatic disposal tracking (experimental)
-    autoDispose?: boolean;
-}
-```
-
-Example with options:
-
-```typescript
-// vite.config.ts
-import { plugin as reactivity } from '@esportsplus/reactivity/plugins/vite';
-
-export default defineConfig({
-    plugins: [
-        reactivity({ autoDispose: true })
-    ]
-});
-```
-
 ## How It Works
 
 The transformer converts your code at compile time:

package/src/transformer/detector.ts

@@ -0,0 +1,65 @@
+import { mightNeedTransform as checkTransform } from '@esportsplus/typescript/transformer';
+import ts from 'typescript';
+
+
+interface DetectContext {
+    hasImport: boolean;
+    hasUsage: boolean;
+}
+
+
+const REACTIVE_REGEX = /\breactive\b/;
+
+
+function visit(ctx: DetectContext, node: ts.Node): void {
+    if (ctx.hasImport && ctx.hasUsage) {
+        return;
+    }
+
+    if (
+        ts.isImportDeclaration(node) &&
+        node.importClause?.namedBindings &&
+        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;
+                break;
+            }
+        }
+    }
+
+    if (
+        ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'reactive'
+    ) {
+        ctx.hasUsage = true;
+    }
+
+    ts.forEachChild(node, n => visit(ctx, n));
+}
+
+
+const mightNeedTransform = (code: string): boolean => {
+    if (!checkTransform(code, { regex: REACTIVE_REGEX })) {
+        return false;
+    }
+
+    let ctx: DetectContext = {
+            hasImport: false,
+            hasUsage: false
+        };
+
+    visit(ctx, ts.createSourceFile('detect.ts', code, ts.ScriptTarget.Latest, false));
+
+    return ctx.hasImport && ctx.hasUsage;
+};
+
+
+export { mightNeedTransform };

package/src/transformer/{core/index.ts → index.ts}

@@ -1,27 +1,22 @@
-import type { Bindings, TransformOptions, TransformResult } from '~/types';
-import { injectAutoDispose } from './transforms/auto-dispose';
+import type { Bindings, TransformResult } from '~/types';
 import { mightNeedTransform } from './detector';
-import { transformReactiveArrays } from './transforms/reactive-array';
-import { transformReactiveObjects } from './transforms/reactive-object';
-import { transformReactivePrimitives } from './transforms/reactive-primitives';
+import { transformReactiveArrays } from './transforms/array';
+import { transformReactiveObjects } from './transforms/object';
+import { transformReactivePrimitives } from './transforms/primitives';
 import ts from 'typescript';
 
 
-const createTransformer = (options?: TransformOptions): ts.TransformerFactory<ts.SourceFile> => {
+const createTransformer = (): ts.TransformerFactory<ts.SourceFile> => {
     return () => {
         return (sourceFile: ts.SourceFile): ts.SourceFile => {
-            let result = transform(sourceFile, options);
+            let result = transform(sourceFile);
 
             return result.transformed ? result.sourceFile : sourceFile;
         };
     };
 };
 
-
-const transform = (
-    sourceFile: ts.SourceFile,
-    options?: TransformOptions
-): TransformResult => {
+const transform = (sourceFile: ts.SourceFile): TransformResult => {
     let bindings: Bindings = new Map(),
         code = sourceFile.getFullText(),
         current = sourceFile,
@@ -54,15 +49,6 @@ const transform = (
         code = result;
     }
 
-    if (options?.autoDispose) {
-        result = injectAutoDispose(current);
-
-        if (result !== code) {
-            current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
-            code = result;
-        }
-    }
-
     if (code === original) {
         return { code, sourceFile, transformed: false };
     }
@@ -76,7 +62,6 @@ const transform = (
 
 
 export { createTransformer, mightNeedTransform, transform };
-export { injectAutoDispose } from './transforms/auto-dispose';
-export { transformReactiveArrays } from './transforms/reactive-array';
-export { transformReactiveObjects } from './transforms/reactive-object';
-export { transformReactivePrimitives } from './transforms/reactive-primitives';
+export { transformReactiveArrays } from './transforms/array';
+export { transformReactiveObjects } from './transforms/object';
+export { transformReactivePrimitives } from './transforms/primitives';

package/src/transformer/plugins/esbuild.ts

@@ -1,16 +1,16 @@
-import { mightNeedTransform, transform } from '~/transformer/core';
+import { TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
+import { mightNeedTransform, transform } from '~/transformer';
 import type { OnLoadArgs, Plugin, PluginBuild } from 'esbuild';
-import type { TransformOptions } from '~/types';
 import fs from 'fs';
 import ts from 'typescript';
 
 
-export default (options?: TransformOptions): Plugin => {
+export default (): Plugin => {
     return {
         name: '@esportsplus/reactivity/plugin-esbuild',
 
         setup(build: PluginBuild) {
-            build.onLoad({ filter: /\.[tj]sx?$/ }, async (args: OnLoadArgs) => {
+            build.onLoad({ filter: TRANSFORM_PATTERN }, async (args: OnLoadArgs) => {
                 let code = await fs.promises.readFile(args.path, 'utf8');
 
                 if (!mightNeedTransform(code)) {
@@ -24,7 +24,7 @@ export default (options?: TransformOptions): Plugin => {
                             ts.ScriptTarget.Latest,
                             true
                         ),
-                        result = transform(sourceFile, options);
+                        result = transform(sourceFile);
 
                     if (!result.transformed) {
                         return null;
@@ -43,4 +43,3 @@ export default (options?: TransformOptions): Plugin => {
         }
     };
 };
-export type { TransformOptions as PluginOptions };

package/src/transformer/plugins/tsc.ts

@@ -1,4 +1,4 @@
-import { createTransformer } from '~/transformer/core';
+import { createTransformer } from '~/transformer';
 import ts from 'typescript';