@esportsplus/reactivity 0.29.0 → 0.29.2

package/accordion.js

@@ -0,0 +1,45 @@
+import * as reactivity_1ihsmodgjbfar0 from '@esportsplus/reactivity';
+import { omit } from '@esportsplus/utilities';
+import template from '../../components/template/index.js';
+import './scss/index.scss';
+class ReactiveObject_xy8kflxy8kfl2 extends reactivity_1ihsmodgjbfar0.ReactiveObject {
+    #active = this[reactivity_1ihsmodgjbfar0.SIGNAL](0);
+    constructor() {
+        super(null);
+    }
+    get active() {
+        return reactivity_1ihsmodgjbfar0.read(this.#active);
+    }
+    set active(_v0) {
+        reactivity_1ihsmodgjbfar0.write(this.#active, _v0);
+    }
+}
+const OMIT = ['state'];
+let key = Symbol();
+export default template.factory(function (attributes, content) {
+    let ref, state = attributes.state || reactivity_1ihsmodgjbfar0.reactive({
+        active: 0
+    }), n, html;
+    `
+            <div
+                ${omit(attributes, OMIT)}
+                ${{
+        class: () => {
+            return state.active && '--active';
+        },
+        onrender: (element) => {
+            (ref = element)[key] = state;
+        },
+        style: () => {
+            let parent = ref.closest('accordion');
+            if (parent && key in parent) {
+                parent[key].active = (+parent[key].active) + 1;
+            }
+            return state.active && `--max-height: ${ref.scrollHeight}`;
+        }
+    }}
+            >
+                ${content}
+            </div>
+        `;
+});

package/accordion.ts

@@ -0,0 +1,51 @@
+import { reactive } from '@esportsplus/reactivity';
+import { html, Attributes } from '@esportsplus/template';
+import { omit } from '@esportsplus/utilities';
+import template from '~/components/template';
+import './scss/index.scss';
+
+
+type A = Attributes & { state?: { active: boolean | number } };
+
+type Accordion = HTMLElement & { [key: symbol]: { active: boolean | number } };
+
+
+const OMIT = ['state'];
+
+
+let key = Symbol();
+
+
+export default template.factory(
+    function(attributes: A, content) {
+        let ref: Accordion,
+            state = attributes.state || reactive({
+                active: 0
+            });
+
+        return html`
+            <div
+                ${omit(attributes, OMIT)}
+                ${{
+                    class: () => {
+                        return state.active && '--active';
+                    },
+                    onrender: (element) => {
+                        ( ref = element as Accordion )[key] = state;
+                    },
+                    style: () => {
+                        let parent = ref.closest<Accordion>('accordion');
+
+                        if (parent && key in parent) {
+                            parent[key].active = (+parent[key].active) + 1;
+                        }
+
+                        return state.active && `--max-height: ${ref.scrollHeight}`;
+                    }
+                }}
+            >
+                ${content}
+            </div>
+        `;
+    }
+);

package/build/compiler/array.d.ts

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

package/build/compiler/array.js

@@ -45,7 +45,7 @@ function visit(ctx, node) {
             ctx.bindings.set(node.name.text, COMPILER_TYPES.Array);
         }
         if (ts.isPropertyAccessExpression(node.initializer)) {
-            let path = ast.getPropertyPathString(node.initializer);
+            let path = ast.getPropertyPath(node.initializer);
             if (path && ctx.bindings.get(path) === COMPILER_TYPES.Array) {
                 ctx.bindings.set(node.name.text, COMPILER_TYPES.Array);
             }
@@ -92,10 +92,9 @@ function visit(ctx, node) {
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-export default (sourceFile, bindings, checker) => {
+export default (sourceFile, bindings) => {
     let ctx = {
         bindings,
-        checker,
         replacements: [],
         sourceFile
     };

package/build/compiler/index.js

@@ -4,30 +4,10 @@ import { COMPILER_ENTRYPOINT, COMPILER_NAMESPACE, PACKAGE } from '../constants.j
 import array from './array.js';
 import object from './object.js';
 import primitives from './primitives.js';
-function hasReactiveImport(sourceFile) {
-    return imports.find(sourceFile, PACKAGE).some(i => i.specifiers.has(COMPILER_ENTRYPOINT));
-}
-function isReactiveSymbol(checker, node) {
-    let symbol = checker.getSymbolAtLocation(node);
-    if (!symbol) {
-        return false;
-    }
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-        symbol = checker.getAliasedSymbol(symbol);
-    }
-    let declarations = symbol.getDeclarations();
-    if (!declarations || declarations.length === 0) {
-        return false;
-    }
-    for (let i = 0, n = declarations.length; i < n; i++) {
-        let decl = declarations[i], sourceFile = decl.getSourceFile();
-        if (sourceFile.fileName.includes(PACKAGE) || sourceFile.fileName.includes('reactivity')) {
-            if (symbol.name === COMPILER_ENTRYPOINT) {
-                return true;
-            }
-        }
-    }
-    return false;
+function findRemainingCalls(checker, sourceFile, transformedNodes) {
+    let ctx = { checker, replacements: [], sourceFile, transformedNodes };
+    visit(ctx, sourceFile);
+    return ctx.replacements;
 }
 function isReactiveCallExpression(checker, node) {
     if (!ts.isCallExpression(node)) {
@@ -39,39 +19,36 @@ function isReactiveCallExpression(checker, node) {
             return true;
         }
         if (checker) {
-            return isReactiveSymbol(checker, expr);
+            return imports.inPackage(checker, expr, PACKAGE, COMPILER_ENTRYPOINT);
         }
     }
     if (ts.isPropertyAccessExpression(expr) && expr.name.text === COMPILER_ENTRYPOINT && checker) {
-        return isReactiveSymbol(checker, expr);
+        return imports.inPackage(checker, expr, PACKAGE);
     }
     return false;
 }
+function visit(ctx, node) {
+    if (isReactiveCallExpression(ctx.checker, node) && !ctx.transformedNodes.has(node) && !ctx.transformedNodes.has(node.expression)) {
+        ctx.replacements.push({
+            generate: () => `${COMPILER_NAMESPACE}.reactive(${node.arguments.map(a => a.getText(ctx.sourceFile)).join(', ')})`,
+            node
+        });
+    }
+    ts.forEachChild(node, n => visit(ctx, n));
+}
 const plugin = {
     patterns: ['reactive(', 'reactive<'],
     transform: (ctx) => {
-        if (!hasReactiveImport(ctx.sourceFile)) {
+        if (!imports.find(ctx.sourceFile, PACKAGE).some(i => i.specifiers.has(COMPILER_ENTRYPOINT))) {
             return {};
         }
-        let bindings = new Map(), importsIntent = [], isReactiveCall = (node) => isReactiveCallExpression(ctx.checker, node), prepend = [], replacements = [];
-        replacements.push(...primitives(ctx.sourceFile, bindings, isReactiveCall, ctx.checker));
-        let objectResult = object(ctx.sourceFile, bindings, ctx.checker);
+        let bindings = new Map(), importsIntent = [], isReactive = (node) => isReactiveCallExpression(ctx.checker, node), prepend = [], replacements = [];
+        replacements.push(...primitives(ctx.sourceFile, bindings, isReactive));
+        let objectResult = object(ctx.sourceFile, bindings);
         prepend.push(...objectResult.prepend);
-        replacements.push(...objectResult.replacements, ...array(ctx.sourceFile, bindings, ctx.checker));
-        let transformedNodes = new Set(replacements.map(r => r.node));
-        function findRemainingReactiveCalls(node) {
-            if (isReactiveCall(node)) {
-                let call = node;
-                if (!transformedNodes.has(call) && !transformedNodes.has(call.expression)) {
-                    replacements.push({
-                        generate: () => `${COMPILER_NAMESPACE}.reactive(${call.arguments.map(a => a.getText(ctx.sourceFile)).join(', ')})`,
-                        node: call
-                    });
-                }
-            }
-            ts.forEachChild(node, findRemainingReactiveCalls);
-        }
-        findRemainingReactiveCalls(ctx.sourceFile);
+        replacements.push(...objectResult.replacements);
+        replacements.push(...array(ctx.sourceFile, bindings));
+        replacements.push(...findRemainingCalls(ctx.checker, ctx.sourceFile, new Set(replacements.map(r => r.node))));
         if (replacements.length > 0 || prepend.length > 0) {
             importsIntent.push({
                 namespace: COMPILER_NAMESPACE,

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;
+declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings) => ObjectTransformResult;
 export default _default;

package/build/compiler/object.js

@@ -145,11 +145,10 @@ function visit(ctx, node) {
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-export default (sourceFile, bindings, checker) => {
+export default (sourceFile, bindings) => {
     let ctx = {
         bindings,
         calls: [],
-        checker,
         sourceFile
     };
     visit(ctx, sourceFile);

package/build/compiler/primitives.d.ts

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

package/build/compiler/primitives.js

@@ -17,7 +17,7 @@ const COMPOUND_OPERATORS = new Map([
     [ts.SyntaxKind.QuestionQuestionEqualsToken, '??'],
     [ts.SyntaxKind.SlashEqualsToken, '/']
 ]);
-function isInScope(reference, binding) {
+function inScope(reference, binding) {
     let current = reference;
     while (current) {
         if (current === binding.scope) {
@@ -89,7 +89,7 @@ function visit(ctx, node) {
         let bindings = ctx.scopedBindings, binding, name = node.text;
         for (let i = 0, n = bindings.length; i < n; i++) {
             let b = bindings[i];
-            if (b.name === name && isInScope(node, b)) {
+            if (b.name === name && inScope(node, b)) {
                 binding = b;
             }
         }
@@ -166,10 +166,9 @@ function visit(ctx, node) {
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-export default (sourceFile, bindings, isReactiveCall, checker) => {
+export default (sourceFile, bindings, isReactiveCall) => {
     let ctx = {
         bindings,
-        checker,
         isReactiveCall,
         replacements: [],
         scopedBindings: [],

package/package.json

@@ -4,7 +4,7 @@
     "@esportsplus/utilities": "^0.27.2"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.25.0",
+    "@esportsplus/typescript": "^0.26.2",
     "@types/node": "^25.0.3",
     "vite": "^7.3.1"
   },
@@ -31,7 +31,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",

package/src/compiler/array.ts

@@ -5,14 +5,6 @@ import { COMPILER_NAMESPACE, COMPILER_TYPES } from '~/constants';
 import type { Bindings } from '~/types';
 
 
-interface VisitContext {
-    bindings: Bindings;
-    checker?: ts.TypeChecker;
-    replacements: ReplacementIntent[];
-    sourceFile: ts.SourceFile;
-}
-
-
 function getElementTypeText(typeNode: ts.TypeNode, sourceFile: ts.SourceFile): string | null {
     if (ts.isArrayTypeNode(typeNode)) {
         return typeNode.elementType.getText(sourceFile);
@@ -31,7 +23,7 @@ function getElementTypeText(typeNode: ts.TypeNode, sourceFile: ts.SourceFile): s
     return null;
 }
 
-function visit(ctx: VisitContext, node: ts.Node): void {
+function visit(ctx: { bindings: Bindings, replacements: ReplacementIntent[], sourceFile: ts.SourceFile }, node: ts.Node): void {
     if (
         ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
@@ -72,7 +64,7 @@ function visit(ctx: VisitContext, node: ts.Node): void {
         }
 
         if (ts.isPropertyAccessExpression(node.initializer)) {
-            let path = ast.getPropertyPathString(node.initializer);
+            let path = ast.getPropertyPath(node.initializer);
 
             if (path && ctx.bindings.get(path) === COMPILER_TYPES.Array) {
                 ctx.bindings.set(node.name.text, COMPILER_TYPES.Array);
@@ -140,10 +132,9 @@ function visit(ctx: VisitContext, node: ts.Node): void {
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker): ReplacementIntent[] => {
-    let ctx: VisitContext = {
+export default (sourceFile: ts.SourceFile, bindings: Bindings): ReplacementIntent[] => {
+    let ctx = {
             bindings,
-            checker,
             replacements: [],
             sourceFile
         };

package/src/compiler/index.ts

@@ -8,42 +8,23 @@ import object from './object';
 import primitives from './primitives';
 
 
-function hasReactiveImport(sourceFile: ts.SourceFile): boolean {
-    return imports.find(sourceFile, PACKAGE).some(i => i.specifiers.has(COMPILER_ENTRYPOINT));
-}
-
-function isReactiveSymbol(checker: ts.TypeChecker, node: ts.Node): boolean {
-    let symbol = checker.getSymbolAtLocation(node);
-
-    if (!symbol) {
-        return false;
-    }
-
-    // Follow aliases to original symbol
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-        symbol = checker.getAliasedSymbol(symbol);
-    }
-
-    let declarations = symbol.getDeclarations();
-
-    if (!declarations || declarations.length === 0) {
-        return false;
-    }
+type FindRemainingContext = {
+    checker: ts.TypeChecker | undefined;
+    replacements: ReplacementIntent[];
+    sourceFile: ts.SourceFile;
+    transformedNodes: Set<ts.Node>;
+};
 
-    for (let i = 0, n = declarations.length; i < n; i++) {
-        let decl = declarations[i],
-            sourceFile = decl.getSourceFile();
+function findRemainingCalls(
+    checker: ts.TypeChecker | undefined,
+    sourceFile: ts.SourceFile,
+    transformedNodes: Set<ts.Node>
+): ReplacementIntent[] {
+    let ctx: FindRemainingContext = { checker, replacements: [], sourceFile, transformedNodes };
 
-        // Check if declaration is from our package
-        if (sourceFile.fileName.includes(PACKAGE) || sourceFile.fileName.includes('reactivity')) {
-            // Verify it's the reactive export
-            if (symbol.name === COMPILER_ENTRYPOINT) {
-                return true;
-            }
-        }
-    }
+    visit(ctx, sourceFile);
 
-    return false;
+    return ctx.replacements;
 }
 
 function isReactiveCallExpression(checker: ts.TypeChecker | undefined, node: ts.Node): node is ts.CallExpression {
@@ -62,62 +43,59 @@ function isReactiveCallExpression(checker: ts.TypeChecker | undefined, node: ts.
 
         // Use checker to resolve aliases
         if (checker) {
-            return isReactiveSymbol(checker, expr);
+            return imports.inPackage(checker, expr, PACKAGE, COMPILER_ENTRYPOINT);
         }
     }
 
     // Property access: ns.reactive(...)
     if (ts.isPropertyAccessExpression(expr) && expr.name.text === COMPILER_ENTRYPOINT && checker) {
-        return isReactiveSymbol(checker, expr);
+        return imports.inPackage(checker, expr, PACKAGE);
     }
 
     return false;
 }
 
+function visit(ctx: FindRemainingContext, node: ts.Node): void {
+    // Check if call or its expression has already been transformed
+    if (isReactiveCallExpression(ctx.checker, node) && !ctx.transformedNodes.has(node) && !ctx.transformedNodes.has(node.expression)) {
+        ctx.replacements.push({
+            generate: () => `${COMPILER_NAMESPACE}.reactive(${node.arguments.map(a => a.getText(ctx.sourceFile)).join(', ')})`,
+            node
+        });
+    }
+
+    ts.forEachChild(node, n => visit(ctx, n));
+}
+
 
 const plugin: Plugin = {
     patterns: ['reactive(', 'reactive<'],
 
     transform: (ctx: TransformContext) => {
-        if (!hasReactiveImport(ctx.sourceFile)) {
+        if (!imports.find(ctx.sourceFile, PACKAGE).some(i => i.specifiers.has(COMPILER_ENTRYPOINT))) {
             return {};
         }
 
         let bindings: Bindings = new Map(),
             importsIntent: ImportIntent[] = [],
-            isReactiveCall = (node: ts.Node) => isReactiveCallExpression(ctx.checker, node),
+            isReactive = (node: ts.Node) => isReactiveCallExpression(ctx.checker, node),
             prepend: string[] = [],
             replacements: ReplacementIntent[] = [];
 
         // Run primitives transform first (tracks bindings for signal/computed)
-        replacements.push(...primitives(ctx.sourceFile, bindings, isReactiveCall, ctx.checker));
+        replacements.push(...primitives(ctx.sourceFile, bindings, isReactive));
 
         // Run object transform
-        let objectResult = object(ctx.sourceFile, bindings, ctx.checker);
+        let objectResult = object(ctx.sourceFile, bindings);
 
         prepend.push(...objectResult.prepend);
-        replacements.push(...objectResult.replacements, ...array(ctx.sourceFile, bindings, ctx.checker));
+        replacements.push(...objectResult.replacements);
 
-        // Find remaining reactive() calls that weren't transformed and replace with namespace version
-        let transformedNodes = new Set(replacements.map(r => r.node));
-
-        function findRemainingReactiveCalls(node: ts.Node): void {
-            if (isReactiveCall(node)) {
-                let call = node as ts.CallExpression;
-
-                // Check if call or its expression has already been transformed
-                if (!transformedNodes.has(call) && !transformedNodes.has(call.expression)) {
-                    replacements.push({
-                        generate: () => `${COMPILER_NAMESPACE}.reactive(${call.arguments.map(a => a.getText(ctx.sourceFile)).join(', ')})`,
-                        node: call
-                    });
-                }
-            }
-
-            ts.forEachChild(node, findRemainingReactiveCalls);
-        }
+        // Run array transform separately ( avoid race conditions )
+        replacements.push(...array(ctx.sourceFile, bindings));
 
-        findRemainingReactiveCalls(ctx.sourceFile);
+        // Find remaining reactive() calls that weren't transformed and replace with namespace version
+        replacements.push(...findRemainingCalls(ctx.checker, ctx.sourceFile, new Set(replacements.map(r => r.node))));
 
         // Build import intent
         if (replacements.length > 0 || prepend.length > 0) {

package/src/compiler/object.ts

@@ -22,7 +22,6 @@ interface ReactiveObjectCall {
 interface VisitContext {
     bindings: Bindings;
     calls: ReactiveObjectCall[];
-    checker?: ts.TypeChecker;
     sourceFile: ts.SourceFile;
 }
 
@@ -221,11 +220,10 @@ type ObjectTransformResult = {
 };
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker): ObjectTransformResult => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings): ObjectTransformResult => {
     let ctx: VisitContext = {
             bindings,
             calls: [],
-            checker,
             sourceFile
         };
 
@@ -245,9 +243,9 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.Type
         replacements.push({
             generate: () => ` new ${call.className}(${
                 call.properties
-                .filter(({ isStatic, type }) => !isStatic || type === COMPILER_TYPES.Computed)
-                .map(p => p.valueText)
-                .join(', ')
+                    .filter(({ isStatic, type }) => !isStatic || type === COMPILER_TYPES.Computed)
+                    .map(p => p.valueText)
+                    .join(', ')
             })`,
             node: call.node,
         });

package/src/compiler/primitives.ts

@@ -12,7 +12,6 @@ interface ScopeBinding {
 
 interface TransformContext {
     bindings: Bindings;
-    checker?: ts.TypeChecker;
     isReactiveCall: (node: ts.Node) => boolean;
     replacements: ReplacementIntent[];
     scopedBindings: ScopeBinding[];
@@ -40,7 +39,7 @@ const COMPOUND_OPERATORS = new Map<ts.SyntaxKind, string>([
 ]);
 
 
-function isInScope(reference: ts.Node, binding: ScopeBinding): boolean {
+function inScope(reference: ts.Node, binding: ScopeBinding): boolean {
     let current: ts.Node | undefined = reference;
 
     while (current) {
@@ -143,7 +142,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         for (let i = 0, n = bindings.length; i < n; i++) {
             let b = bindings[i];
 
-            if (b.name === name && isInScope(node, b)) {
+            if (b.name === name && inScope(node, b)) {
                 binding = b;
             }
         }
@@ -239,15 +238,9 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 }
 
 
-export default (
-    sourceFile: ts.SourceFile,
-    bindings: Bindings,
-    isReactiveCall: (node: ts.Node) => boolean,
-    checker?: ts.TypeChecker
-) => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: (node: ts.Node) => boolean) => {
     let ctx: TransformContext = {
             bindings,
-            checker,
             isReactiveCall,
             replacements: [],
             scopedBindings: [],