@eventra_dev/eventra-cli 0.1.9 → 0.1.11

package/dist/commands/sync.js

@@ -25,11 +25,21 @@ async function sync() {
     const engine = new engine_1.EventraEngine(process.cwd());
     const detectedFn = new Set();
     const detectedCmp = new Map();
+    const fileCache = [];
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf-8");
             const { content, virtualFile } = (0, processFile_1.processFile)(file, raw);
-            const res = engine.scanFile(virtualFile, content, config);
+            fileCache.push({ file: virtualFile, content });
+            engine["ts"].updateFile(virtualFile, content);
+        }
+        catch {
+            // ignore
+        }
+    }
+    for (const { file, content } of fileCache) {
+        try {
+            const res = engine.scanFile(file, content, config);
             for (const w of res.detectedFunctionWrappers) {
                 detectedFn.add(w);
             }

package/dist/engine/languageService.js

@@ -48,9 +48,6 @@ class TSService {
             },
             getScriptVersion: (file) => this.files.get(file)?.version.toString() ?? "0",
             getScriptSnapshot: (file) => {
-                if (!this.fileNames.has(file)) {
-                    return undefined;
-                }
                 const f = this.files.get(file);
                 if (f) {
                     return typescript_1.default.ScriptSnapshot.fromString(f.content);

package/dist/engine/resolver.js

@@ -70,6 +70,7 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
             if (s.flags & typescript_1.default.SymbolFlags.Alias) {
                 s = checker.getAliasedSymbol(s);
             }
+            // ENUM support
             for (const decl of s.getDeclarations() ?? []) {
                 if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
                     if (typescript_1.default.isStringLiteral(decl.initializer)) {
@@ -81,6 +82,26 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
+        // OBJECT support
+        if (typescript_1.default.isIdentifier(node.expression)) {
+            const objSymbol = checker.getSymbolAtLocation(node.expression);
+            if (objSymbol) {
+                for (const decl of objSymbol.getDeclarations() ?? []) {
+                    if (typescript_1.default.isVariableDeclaration(decl) &&
+                        decl.initializer &&
+                        typescript_1.default.isObjectLiteralExpression(decl.initializer)) {
+                        for (const prop of decl.initializer.properties) {
+                            if (!typescript_1.default.isPropertyAssignment(prop))
+                                continue;
+                            const name = prop.name.getText();
+                            if (name === node.name.text) {
+                                return resolveNodeValue(prop.initializer, checker, paramMap, seen);
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
     if (typescript_1.default.isObjectLiteralExpression(node)) {
         const values = [];

package/dist/engine/scanner.js

@@ -37,8 +37,10 @@ function isPropUsedInTracking(fn, prop) {
     function visit(node) {
         if (typescript_1.default.isCallExpression(node)) {
             const name = getCallName(node.expression);
-            if (!TRACKING_NAMES.has(name))
+            if (!TRACKING_NAMES.has(name)) {
+                typescript_1.default.forEachChild(node, visit);
                 return;
+            }
             for (const arg of node.arguments) {
                 if ((typescript_1.default.isIdentifier(arg) && arg.text === prop) ||
                     (typescript_1.default.isPropertyAccessExpression(arg) &&
@@ -65,22 +67,40 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
         if (typescript_1.default.isCallExpression(node)) {
             const name = getCallName(node.expression);
             const isKnownWrapper = config.functionWrappers.some(w => w.name === name);
-            const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-            const isAutoWrapper = fn && (0, functionAnalyzer_1.findTrackParamIndex)(fn) !== null;
+            let resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
+            // fallback: tracker.track(...)
+            if (!resolvedFn && typescript_1.default.isPropertyAccessExpression(node.expression)) {
+                const symbol = checker.getSymbolAtLocation(node.expression.name);
+                if (symbol) {
+                    const decls = symbol.getDeclarations();
+                    if (decls?.length) {
+                        const d = decls[0];
+                        if (typescript_1.default.isMethodDeclaration(d) ||
+                            typescript_1.default.isFunctionDeclaration(d) ||
+                            typescript_1.default.isFunctionExpression(d) ||
+                            typescript_1.default.isArrowFunction(d)) {
+                            resolvedFn = d;
+                        }
+                    }
+                }
+            }
+            const isAutoWrapper = resolvedFn && (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn) !== null;
             const isTracking = isKnownWrapper ||
                 TRACKING_NAMES.has(name) ||
                 (isAutoWrapper &&
-                    fn &&
-                    !(0, boundary_1.isExternalFile)(fn.getSourceFile().fileName));
-            if (!isTracking)
+                    resolvedFn &&
+                    !(0, boundary_1.isExternalFile)(resolvedFn.getSourceFile().fileName));
+            if (!isTracking) {
+                typescript_1.default.forEachChild(node, visit);
                 return;
+            }
             if (!isKnownWrapper && isAutoWrapper && !TRACKING_NAMES.has(name)) {
                 detectedFunctionWrappers.add(name);
             }
-            // paramMap
+            // paramMap (chain support)
             const paramMap = new Map(inheritedParamMap ?? []);
-            if (fn && typescript_1.default.isFunctionLike(fn)) {
-                fn.parameters.forEach((param, i) => {
+            if (resolvedFn && typescript_1.default.isFunctionLike(resolvedFn)) {
+                resolvedFn.parameters.forEach((param, i) => {
                     const arg = node.arguments[i];
                     if (!arg)
                         return;
@@ -90,8 +110,8 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
                 });
             }
             let handled = false;
-            if (fn) {
-                const idx = (0, functionAnalyzer_1.findTrackParamIndex)(fn);
+            if (resolvedFn) {
+                const idx = (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn);
                 if (idx !== null && node.arguments[idx]) {
                     const res = (0, resolver_1.resolveNodeValue)(node.arguments[idx], checker, paramMap);
                     res?.values.forEach(v => {
@@ -101,7 +121,6 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
                     handled = true;
                 }
             }
-            // fallback
             if (!handled) {
                 for (const arg of node.arguments) {
                     const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
@@ -111,9 +130,9 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
                     });
                 }
             }
-            // cross-file WITH paramMap
-            if (fn) {
-                const sf = fn.getSourceFile();
+            // cross-file with paramMap
+            if (resolvedFn) {
+                const sf = resolvedFn.getSourceFile();
                 if (!visited.has(sf.fileName)) {
                     const res = scanSource(sf, checker, config, visited, depth + 1, paramMap);
                     res.events.forEach(e => events.add(e));
@@ -133,8 +152,10 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
             if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
                 symbol = checker.getAliasedSymbol(symbol);
             }
-            if (!symbol)
+            if (!symbol) {
+                typescript_1.default.forEachChild(node, visit);
                 return;
+            }
             const tagName = typescript_1.default.isPropertyAccessExpression(node.tagName)
                 ? node.tagName.name.getText()
                 : node.tagName.getText();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {

package/src/commands/sync.ts

@@ -26,13 +26,24 @@ export async function sync() {
   const detectedFn = new Set<string>();
   const detectedCmp = new Map<string, string>();
 
+  const fileCache: { file: string; content: string }[] = [];
+
   for (const file of files) {
     try {
       const raw = await fs.readFile(file, "utf-8");
-
       const { content, virtualFile } = processFile(file, raw);
 
-      const res = engine.scanFile(virtualFile, content, config);
+      fileCache.push({ file: virtualFile, content });
+
+      engine["ts"].updateFile(virtualFile, content);
+    } catch {
+      // ignore
+    }
+  }
+
+  for (const { file, content } of fileCache) {
+    try {
+      const res = engine.scanFile(file, content, config);
 
       for (const w of res.detectedFunctionWrappers) {
         detectedFn.add(w);

package/src/engine/languageService.ts

@@ -62,10 +62,6 @@ export class TSService {
         this.files.get(file)?.version.toString() ?? "0",
 
       getScriptSnapshot: (file) => {
-        if (!this.fileNames.has(file)) {
-          return undefined;
-        }
-
         const f = this.files.get(file);
 
         if (f) {

package/src/engine/resolver.ts

@@ -107,6 +107,7 @@ export function resolveNodeValue(
         s = checker.getAliasedSymbol(s);
       }
 
+      // ENUM support
       for (const decl of s.getDeclarations() ?? []) {
         if (ts.isEnumMember(decl) && decl.initializer) {
           if (ts.isStringLiteral(decl.initializer)) {
@@ -118,6 +119,36 @@ export function resolveNodeValue(
         }
       }
     }
+
+    // OBJECT support
+    if (ts.isIdentifier(node.expression)) {
+      const objSymbol = checker.getSymbolAtLocation(node.expression);
+
+      if (objSymbol) {
+        for (const decl of objSymbol.getDeclarations() ?? []) {
+          if (
+            ts.isVariableDeclaration(decl) &&
+            decl.initializer &&
+            ts.isObjectLiteralExpression(decl.initializer)
+          ) {
+            for (const prop of decl.initializer.properties) {
+              if (!ts.isPropertyAssignment(prop)) continue;
+
+              const name = prop.name.getText();
+
+              if (name === node.name.text) {
+                return resolveNodeValue(
+                  prop.initializer,
+                  checker,
+                  paramMap,
+                  seen
+                );
+              }
+            }
+          }
+        }
+      }
+    }
   }
 
   if (ts.isObjectLiteralExpression(node)) {

package/src/engine/scanner.ts

@@ -40,7 +40,10 @@ function isPropUsedInTracking(
     if (ts.isCallExpression(node)) {
       const name = getCallName(node.expression);
 
-      if (!TRACKING_NAMES.has(name)) return;
+      if (!TRACKING_NAMES.has(name)) {
+        ts.forEachChild(node, visit);
+        return;
+      }
 
       for (const arg of node.arguments) {
         if (
@@ -93,29 +96,54 @@ export function scanSource(
         w => w.name === name
       );
 
-      const fn = resolveFunctionFromCall(node.expression, checker);
+      let resolvedFn = resolveFunctionFromCall(node.expression, checker);
+
+      // fallback: tracker.track(...)
+      if (!resolvedFn && ts.isPropertyAccessExpression(node.expression)) {
+        const symbol = checker.getSymbolAtLocation(node.expression.name);
+
+        if (symbol) {
+          const decls = symbol.getDeclarations();
+
+          if (decls?.length) {
+            const d = decls[0];
+
+            if (
+              ts.isMethodDeclaration(d) ||
+              ts.isFunctionDeclaration(d) ||
+              ts.isFunctionExpression(d) ||
+              ts.isArrowFunction(d)
+            ) {
+              resolvedFn = d;
+            }
+          }
+        }
+      }
 
       const isAutoWrapper =
-        fn && findTrackParamIndex(fn) !== null;
+        resolvedFn && findTrackParamIndex(resolvedFn) !== null;
 
       const isTracking =
         isKnownWrapper ||
         TRACKING_NAMES.has(name) ||
         (isAutoWrapper &&
-          fn &&
-          !isExternalFile(fn.getSourceFile().fileName));
+          resolvedFn &&
+          !isExternalFile(resolvedFn.getSourceFile().fileName));
 
-      if (!isTracking) return;
+      if (!isTracking) {
+        ts.forEachChild(node, visit);
+        return;
+      }
 
       if (!isKnownWrapper && isAutoWrapper && !TRACKING_NAMES.has(name)) {
         detectedFunctionWrappers.add(name);
       }
 
-      // paramMap
+      // paramMap (chain support)
       const paramMap = new Map(inheritedParamMap ?? []);
 
-      if (fn && ts.isFunctionLike(fn)) {
-        fn.parameters.forEach((param, i) => {
+      if (resolvedFn && ts.isFunctionLike(resolvedFn)) {
+        resolvedFn.parameters.forEach((param, i) => {
           const arg = node.arguments[i];
           if (!arg) return;
 
@@ -127,8 +155,8 @@ export function scanSource(
 
       let handled = false;
 
-      if (fn) {
-        const idx = findTrackParamIndex(fn);
+      if (resolvedFn) {
+        const idx = findTrackParamIndex(resolvedFn);
 
         if (idx !== null && node.arguments[idx]) {
           const res = resolveNodeValue(
@@ -145,7 +173,6 @@ export function scanSource(
         }
       }
 
-      // fallback
       if (!handled) {
         for (const arg of node.arguments) {
           const res = resolveNodeValue(arg, checker, paramMap);
@@ -156,9 +183,9 @@ export function scanSource(
         }
       }
 
-      // cross-file WITH paramMap
-      if (fn) {
-        const sf = fn.getSourceFile();
+      // cross-file with paramMap
+      if (resolvedFn) {
+        const sf = resolvedFn.getSourceFile();
 
         if (!visited.has(sf.fileName)) {
           const res = scanSource(
@@ -195,7 +222,10 @@ export function scanSource(
         symbol = checker.getAliasedSymbol(symbol);
       }
 
-      if (!symbol) return;
+      if (!symbol) {
+        ts.forEachChild(node, visit);
+        return;
+      }
 
       const tagName =
         ts.isPropertyAccessExpression(node.tagName)
@@ -209,6 +239,7 @@ export function scanSource(
 
         if (ts.isVariableDeclaration(decl) && decl.initializer) {
           const init = decl.initializer;
+
           if (
             ts.isArrowFunction(init) ||
             ts.isFunctionExpression(init)