@esportsplus/reactivity 0.33.0 → 0.34.0

package/build/compiler/array.d.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import type { Bindings } from './types.js';
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker) => ReplacementIntent[];
 export default _default;
+declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.Checker): ReplacementIntent[];

package/build/compiler/array.js

@@ -160,7 +160,7 @@ function visit(ctx, node) {
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
         ts.isIdentifier(node.left)) {
         let name = node.left.text, right = node.right;
-        while (ts.isAsExpression(right) || ts.isTypeAssertionExpression(right)) {
+        while (ts.isAsExpression(right) || ts.isTypeAssertion(right)) {
             right = right.expression;
         }
         if (ctx.bindings.get(name) === TYPES.Array && ts.isArrayLiteralExpression(right)) {
@@ -172,7 +172,7 @@ function visit(ctx, node) {
             });
         }
     }
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 export default (sourceFile, bindings, checker) => {
     let ctx = {

package/build/compiler/index.js

@@ -27,7 +27,7 @@ function hasReactiveCalls(checker, node) {
         return true;
     }
     let found = false;
-    ts.forEachChild(node, child => {
+    node.forEachChild(child => {
         if (!found && hasReactiveCalls(checker, child)) {
             found = true;
         }
@@ -41,7 +41,7 @@ function visit(ctx, node) {
             node
         });
     }
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 export default {
     patterns: ['reactive(', 'reactive<'],

package/build/compiler/object.d.ts

@@ -5,5 +5,5 @@ type ObjectTransformResult = {
     prepend: string[];
     replacements: ReplacementIntent[];
 };
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker) => ObjectTransformResult;
 export default _default;
+declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.Checker): ObjectTransformResult;

package/build/compiler/object.js

@@ -13,10 +13,10 @@ function analyzeProperty(prop, sourceFile) {
         return null;
     }
     let unwrapped = prop.initializer, value = unwrapped, valueText = value.getText(sourceFile);
-    while (ts.isAsExpression(unwrapped) || ts.isTypeAssertionExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped)) {
+    while (ts.isAsExpression(unwrapped) || ts.isTypeAssertion(unwrapped) || ts.isParenthesizedExpression(unwrapped)) {
         unwrapped = unwrapped.expression;
     }
-    if (ts.isAsExpression(value) || ts.isTypeAssertionExpression(value)) {
+    if (ts.isAsExpression(value) || ts.isTypeAssertion(value)) {
         let type = value.type;
         if (ts.isArrayTypeNode(type) ||
             (ts.isTypeReferenceNode(type) &&
@@ -161,12 +161,12 @@ function visit(ctx, node) {
             for (let i = 0, n = props.length; i < n; i++) {
                 let prop = props[i];
                 if (ts.isSpreadAssignment(prop)) {
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
                 let analyzed = analyzeProperty(prop, ctx.sourceFile);
                 if (!analyzed) {
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
                 properties.push(analyzed);
@@ -183,7 +183,7 @@ function visit(ctx, node) {
             });
         }
     }
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 export default (sourceFile, bindings, checker) => {
     let ctx = {

package/build/compiler/plugins/vite.d.ts

@@ -1,12 +1,14 @@
 declare const _default: ({ root }?: {
     root?: string;
 }) => {
+    closeBundle: () => void;
+    closeWatcher: () => void;
     configResolved: (config: unknown) => void;
-    enforce: "pre";
+    enforce: 'pre';
     name: string;
     transform: (code: string, id: string) => {
         code: string;
-        map: null;
+        map: import("@esportsplus/typescript/compiler").SourceMapV3;
     } | null;
     watchChange: (id: string) => void;
 };

package/build/compiler/primitives.d.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import type { Bindings } from './types.js';
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: (node: ts.Node) => boolean) => ReplacementIntent[];
 export default _default;
+declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: (node: ts.Node) => boolean): ReplacementIntent[];

package/build/compiler/primitives.js

@@ -37,7 +37,7 @@ function visit(ctx, node) {
             }
             else {
                 let unwrapped = arg;
-                while (ts.isAsExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped) || ts.isTypeAssertionExpression(unwrapped)) {
+                while (ts.isAsExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped) || ts.isTypeAssertion(unwrapped)) {
                     unwrapped = unwrapped.expression;
                 }
                 if (ts.isArrayLiteralExpression(unwrapped) || ts.isObjectLiteralExpression(unwrapped)) {
@@ -48,7 +48,7 @@ function visit(ctx, node) {
                         generate: () => `${NAMESPACE}.reactive`,
                         node: call.expression
                     });
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
             }
@@ -97,7 +97,7 @@ function visit(ctx, node) {
         node.parent &&
         !(ts.isVariableDeclaration(node.parent) && node.parent.name === node)) {
         if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            ts.forEachChild(node, n => visit(ctx, n));
+            node.forEachChild(n => visit(ctx, n));
             return;
         }
         let bindings = ctx.scopedBindings, binding, name = node.text;
@@ -178,7 +178,7 @@ function visit(ctx, node) {
             }
         }
     }
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 export default (sourceFile, bindings, isReactiveCall) => {
     let ctx = {

package/build/system.d.ts

@@ -1,25 +1,25 @@
 import { Computed, ComputedResult, Settled, Signal } from './types.js';
 declare const batch: <T>(fn: () => T) => T;
-declare const computed: {
-    <T>(fn: Computed<T>["fn"], equals?: ((a: Settled<T>, b: Settled<T>) => boolean) | null): ComputedResult<T>;
-    invalidate<T>(c: Computed<T>): void;
-};
+declare function computed<T>(fn: Computed<T>['fn'], equals?: ((a: Settled<T>, b: Settled<T>) => boolean) | null): ComputedResult<T>;
+declare namespace computed {
+    var invalidate: <T>(c: Computed<T>) => void;
+}
 declare const dispose: <T>(computed: Computed<T>) => void;
-declare const effect: <T>(fn: Computed<T>["fn"], apply?: (value: T, prev: T | undefined) => void) => () => void;
+declare const effect: <T>(fn: Computed<T>['fn'], apply?: (value: T, prev: T | undefined) => void) => () => void;
 declare const flush: () => void;
 declare const isComputed: (value: unknown) => value is Computed<unknown>;
 declare const isSignal: (value: unknown) => value is Signal<unknown>;
 declare const onCleanup: (fn: VoidFunction) => typeof fn;
 declare const peek: <T>(node: Signal<T> | Computed<T>) => T;
 declare const read: <T>(node: Signal<T> | Computed<T>) => T;
-declare const root: {
-    <T>(fn: ((dispose: VoidFunction) => T) | (() => T)): T;
-    disposables: number;
-};
-declare const signal: {
-    <T>(value: T, equals?: ((a: T, b: T) => boolean) | null): Signal<T>;
-    selector<T>(node: Signal<T>, key: T): boolean;
-};
+declare function root<T>(fn: ((dispose: VoidFunction) => T) | (() => T)): T;
+declare namespace root {
+    var disposables: number;
+}
+declare function signal<T>(value: T, equals?: ((a: T, b: T) => boolean) | null): Signal<T>;
+declare namespace signal {
+    var selector: <T>(node: Signal<T>, key: T) => boolean;
+}
 declare const untrack: <T>(fn: () => T) => T;
 declare const write: <T>(signal: Signal<T>, value: T) => void;
 export { batch, computed, dispose, effect, flush, isComputed, isSignal, onCleanup, peek, read, root, signal, untrack, write };

package/package.json

@@ -4,7 +4,7 @@
     "@esportsplus/utilities": "^0.28.0"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.29.5",
+    "@esportsplus/typescript": "^0.31.0",
     "@types/node": "^26.1.1",
     "vite": "^8.1.5",
     "vitest": "^4.1.10"
@@ -36,7 +36,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "scripts": {
     "agent:bench": "vitest bench --run",
     "agent:test": "tsc --noEmit && vitest run",

package/pnpm-workspace.yaml

@@ -1,2 +1,4 @@
 allowBuilds:
   esbuild: true
+minimumReleaseAgeExclude:
+  - '@esportsplus/typescript@0.31.0'

package/src/compiler/array.ts

@@ -7,13 +7,13 @@ import type { Bindings } from './types';
 
 type VisitContext = {
     bindings: Bindings;
-    checker: ts.TypeChecker | undefined;
+    checker: ts.Checker | undefined;
     replacements: ReplacementIntent[];
     sourceFile: ts.SourceFile;
 };
 
 
-function isReactiveCall(checker: ts.TypeChecker | undefined, node: ts.Node): node is ts.CallExpression {
+function isReactiveCall(checker: ts.Checker | undefined, node: ts.Node): node is ts.CallExpression {
     if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) {
         return false;
     }
@@ -220,7 +220,7 @@ function visit(ctx: VisitContext, node: ts.Node): void {
             right = node.right;
 
         // Unwrap "as" expressions: arr = [] as Type[]
-        while (ts.isAsExpression(right) || ts.isTypeAssertionExpression(right)) {
+        while (ts.isAsExpression(right) || ts.isTypeAssertion(right)) {
             right = right.expression;
         }
 
@@ -234,11 +234,11 @@ function visit(ctx: VisitContext, node: ts.Node): void {
         }
     }
 
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker): ReplacementIntent[] => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.Checker): ReplacementIntent[] => {
     let ctx: VisitContext = {
             bindings,
             checker,

package/src/compiler/index.ts

@@ -10,7 +10,7 @@ import primitives from './primitives';
 
 
 type FindRemainingContext = {
-    checker: ts.TypeChecker;
+    checker: ts.Checker;
     replacements: ReplacementIntent[];
     sourceFile: ts.SourceFile;
     transformedNodes: Set<ts.Node>;
@@ -18,7 +18,7 @@ type FindRemainingContext = {
 
 
 function findRemainingCalls(
-    checker: ts.TypeChecker,
+    checker: ts.Checker,
     sourceFile: ts.SourceFile,
     transformedNodes: Set<ts.Node>
 ): ReplacementIntent[] {
@@ -29,7 +29,7 @@ function findRemainingCalls(
     return ctx.replacements;
 }
 
-function isReactiveCallExpression(checker: ts.TypeChecker, node: ts.Node): node is ts.CallExpression {
+function isReactiveCallExpression(checker: ts.Checker, node: ts.Node): node is ts.CallExpression {
     if (!ts.isCallExpression(node)) {
         return false;
     }
@@ -49,14 +49,14 @@ function isReactiveCallExpression(checker: ts.TypeChecker, node: ts.Node): node
     return false;
 }
 
-function hasReactiveCalls(checker: ts.TypeChecker, node: ts.Node): boolean {
+function hasReactiveCalls(checker: ts.Checker, node: ts.Node): boolean {
     if (isReactiveCallExpression(checker, node)) {
         return true;
     }
 
     let found = false;
 
-    ts.forEachChild(node, child => {
+    node.forEachChild(child => {
         if (!found && hasReactiveCalls(checker, child)) {
             found = true;
         }
@@ -73,7 +73,7 @@ function visit(ctx: FindRemainingContext, node: ts.Node): void {
         });
     }
 
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 
 

package/src/compiler/object.ts

@@ -28,7 +28,7 @@ interface ReactiveObjectCall {
 interface VisitContext {
     bindings: Bindings;
     calls: ReactiveObjectCall[];
-    checker: ts.TypeChecker | undefined;
+    checker: ts.Checker | undefined;
     sourceFile: ts.SourceFile;
 }
 
@@ -51,11 +51,11 @@ function analyzeProperty(prop: ts.ObjectLiteralElementLike, sourceFile: ts.Sourc
         value = unwrapped,
         valueText = value.getText(sourceFile);
 
-    while (ts.isAsExpression(unwrapped) || ts.isTypeAssertionExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped)) {
+    while (ts.isAsExpression(unwrapped) || ts.isTypeAssertion(unwrapped) || ts.isParenthesizedExpression(unwrapped)) {
         unwrapped = unwrapped.expression;
     }
 
-    if (ts.isAsExpression(value) || ts.isTypeAssertionExpression(value)) {
+    if (ts.isAsExpression(value) || ts.isTypeAssertion(value)) {
         let type = (value as ts.AsExpression).type;
 
         if (
@@ -216,7 +216,7 @@ function isStaticValue(node: ts.Node): boolean {
         (ts.isPrefixUnaryExpression(node) && ts.isNumericLiteral(node.operand));
 }
 
-function isReactiveCall(checker: ts.TypeChecker | undefined, node: ts.Node): node is ts.CallExpression {
+function isReactiveCall(checker: ts.Checker | undefined, node: ts.Node): node is ts.CallExpression {
     if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) {
         return false;
     }
@@ -250,14 +250,14 @@ function visit(ctx: VisitContext, node: ts.Node): void {
                 let prop = props[i];
 
                 if (ts.isSpreadAssignment(prop)) {
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
 
                 let analyzed = analyzeProperty(prop, ctx.sourceFile);
 
                 if (!analyzed) {
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
 
@@ -278,11 +278,11 @@ function visit(ctx: VisitContext, node: ts.Node): void {
         }
     }
 
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker): ObjectTransformResult => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.Checker): ObjectTransformResult => {
     let ctx: VisitContext = {
             bindings,
             calls: [],

package/src/compiler/primitives.ts

@@ -67,7 +67,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
             else {
                 let unwrapped = arg;
 
-                while (ts.isAsExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped) || ts.isTypeAssertionExpression(unwrapped)) {
+                while (ts.isAsExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped) || ts.isTypeAssertion(unwrapped)) {
                     unwrapped = unwrapped.expression;
                 }
 
@@ -80,7 +80,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
                         generate: () => `${NAMESPACE}.reactive`,
                         node: call.expression
                     });
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
             }
@@ -148,7 +148,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         !(ts.isVariableDeclaration(node.parent) && node.parent.name === node)
     ) {
         if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            ts.forEachChild(node, n => visit(ctx, n));
+            node.forEachChild(n => visit(ctx, n));
             return;
         }
 
@@ -251,7 +251,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         }
     }
 
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 
 

package/test/compiler/compiler.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { ts } from '@esportsplus/typescript';
+import { languageService } from '@esportsplus/typescript/compiler';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { NAMESPACE } from '~/compiler/constants';
 import type { Bindings } from '~/compiler/types';
@@ -30,7 +31,7 @@ function isReactiveCall(node: ts.Node): boolean {
 }
 
 function parse(code: string): ts.SourceFile {
-    return ts.createSourceFile('test.ts', code, ts.ScriptTarget.Latest, true);
+    return languageService.parse(process.cwd() + '/test.ts', code);
 }
 
 function transformPrimitives(code: string): { bindings: Bindings; output: string } {