@eventra_dev/eventra-cli 0.1.32 → 0.1.34

package/dist/engine/scanner.js

@@ -7,23 +7,13 @@ exports.scanSource = scanSource;
 const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
-const functionAnalyzer_1 = require("./functionAnalyzer");
 const exportResolver_1 = require("./exportResolver");
-// UTILS
-function getJsxAttrName(name) {
-    if (typescript_1.default.isIdentifier(name))
-        return name.text;
-    if (typescript_1.default.isJsxNamespacedName(name))
-        return name.name.text;
-    return "";
-}
-function getJsxTagName(tag) {
-    if (typescript_1.default.isIdentifier(tag))
-        return tag.text;
-    if (typescript_1.default.isPropertyAccessExpression(tag)) {
-        return tag.name.text;
-    }
-    return "";
+function isValidEvent(v) {
+    return (v &&
+        v.length > 1 &&
+        v.length < 120 &&
+        !v.includes(" ") &&
+        /^[a-zA-Z0-9._:-]+$/.test(v));
 }
 function getCallName(expr) {
     if (typescript_1.default.isIdentifier(expr))
@@ -32,163 +22,123 @@ function getCallName(expr) {
         return expr.name.text;
     return "";
 }
-function isValidEvent(v) {
-    return (v &&
-        v.length > 1 &&
-        v.length < 100 &&
-        !v.includes(" ") &&
-        /^[a-zA-Z0-9._:-]+$/.test(v));
+function getJsxTagName(tag) {
+    if (typescript_1.default.isIdentifier(tag))
+        return tag.text;
+    if (typescript_1.default.isPropertyAccessExpression(tag))
+        return tag.name.text;
+    return tag.getText();
 }
-// COMPONENT ANALYSIS
-function getComponentPropsMap(fn) {
-    const map = new Map();
-    const firstParam = fn.parameters[0];
-    if (!firstParam)
-        return map;
-    // ({ event }) => ...
-    if (typescript_1.default.isObjectBindingPattern(firstParam.name)) {
-        for (const el of firstParam.name.elements) {
-            if (!typescript_1.default.isBindingElement(el))
-                continue;
-            const propName = el.propertyName?.getText() || el.name.getText();
-            map.set(el.name.getText(), propName);
+function getJsxAttrName(name) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text;
+    if (typescript_1.default.isJsxNamespacedName(name))
+        return name.name.text;
+    return "";
+}
+function scanSource(source, checker, config, visited = new Set(), inheritedParamMap, wrapperCache = new Map()) {
+    const events = new Set();
+    const detectedFunctionWrappers = new Set();
+    const detectedComponentWrappers = new Map();
+    if (visited.has(source.fileName)) {
+        return { events, detectedFunctionWrappers, detectedComponentWrappers };
+    }
+    visited.add(source.fileName);
+    function extractTrackCall(node, paramMap) {
+        const expr = node.expression;
+        if (typescript_1.default.isPropertyAccessExpression(expr) && expr.name.text === "track") {
+            const arg = node.arguments[0];
+            if (!arg)
+                return;
+            const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
+            for (const v of res.values) {
+                if (isValidEvent(v))
+                    events.add(v);
+            }
         }
     }
-    // (props) => props.event
-    if (typescript_1.default.isIdentifier(firstParam.name)) {
-        map.set(firstParam.name.text, "*");
+    function isWrapperFunction(fn) {
+        let found = false;
+        function walk(n) {
+            if (found)
+                return;
+            if (typescript_1.default.isCallExpression(n)) {
+                const expr = n.expression;
+                if (typescript_1.default.isPropertyAccessExpression(expr) && expr.name.text === "track") {
+                    found = true;
+                    return;
+                }
+            }
+            typescript_1.default.forEachChild(n, walk);
+        }
+        if (fn.body)
+            walk(fn.body);
+        return found;
     }
-    return map;
-}
-function findTrackedPropName(fn, checker) {
-    const propMap = getComponentPropsMap(fn);
-    let result = null;
-    function resolveIdentifierToProp(node) {
-        const mapped = propMap.get(node.text);
-        if (mapped && mapped !== "*")
-            return mapped;
-        const symbol = checker.getSymbolAtLocation(node);
-        if (!symbol)
+    function detectComponentWrapper(tag) {
+        const tagName = getJsxTagName(tag);
+        if (wrapperCache.has(tagName))
+            return wrapperCache.get(tagName);
+        let symbol = checker.getSymbolAtLocation(tag);
+        if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        if (!symbol) {
+            wrapperCache.set(tagName, null);
             return null;
+        }
+        symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
         for (const decl of symbol.getDeclarations() ?? []) {
-            // const e = props.event
-            if (typescript_1.default.isVariableDeclaration(decl) &&
-                decl.initializer &&
-                typescript_1.default.isPropertyAccessExpression(decl.initializer)) {
-                return decl.initializer.name.text;
-            }
-            // const e = event
+            let fn = null;
+            if (typescript_1.default.isFunctionDeclaration(decl))
+                fn = decl;
             if (typescript_1.default.isVariableDeclaration(decl) &&
                 decl.initializer &&
-                typescript_1.default.isIdentifier(decl.initializer)) {
-                const inner = propMap.get(decl.initializer.text);
-                if (inner)
-                    return inner;
-            }
-        }
-        return null;
-    }
-    function visit(node) {
-        if (result)
-            return;
-        if (typescript_1.default.isCallExpression(node)) {
-            const expr = node.expression;
-            const isTrack = (typescript_1.default.isIdentifier(expr) && expr.text === "track") ||
-                (typescript_1.default.isPropertyAccessExpression(expr) &&
-                    expr.name.text === "track");
-            if (!isTrack) {
-                typescript_1.default.forEachChild(node, visit);
-                return;
+                (typescript_1.default.isArrowFunction(decl.initializer) ||
+                    typescript_1.default.isFunctionExpression(decl.initializer))) {
+                fn = decl.initializer;
             }
-            for (const arg of node.arguments) {
-                // track(event)
-                if (typescript_1.default.isIdentifier(arg)) {
-                    const prop = resolveIdentifierToProp(arg);
-                    if (prop) {
-                        result = prop;
-                        return;
-                    }
-                }
-                // track(props.a.b.event)
-                if (typescript_1.default.isPropertyAccessExpression(arg)) {
-                    let current = arg;
-                    while (typescript_1.default.isPropertyAccessExpression(current)) {
-                        result = current.name.text;
-                        return;
-                    }
-                }
-                // track(fn())
-                if (typescript_1.default.isCallExpression(arg)) {
-                    const inner = (0, callResolver_1.resolveFunctionFromCall)(arg.expression, checker);
-                    if (inner?.body) {
-                        visit(inner.body);
-                        if (result)
+            if (!fn || !fn.body)
+                continue;
+            let prop = null;
+            function walk(n) {
+                if (prop)
+                    return;
+                if (typescript_1.default.isCallExpression(n)) {
+                    const expr = n.expression;
+                    if (typescript_1.default.isPropertyAccessExpression(expr) && expr.name.text === "track") {
+                        const arg = n.arguments[0];
+                        if (typescript_1.default.isPropertyAccessExpression(arg)) {
+                            prop = arg.name.text;
                             return;
+                        }
                     }
                 }
+                typescript_1.default.forEachChild(n, walk);
+            }
+            walk(fn.body);
+            wrapperCache.set(tagName, prop);
+            if (prop) {
+                detectedComponentWrappers.set(tagName, prop);
+                return prop;
             }
         }
-        typescript_1.default.forEachChild(node, visit);
-    }
-    if (fn.body)
-        visit(fn.body);
-    return result;
-}
-// MAIN SCANNER
-function scanSource(source, checker, config, visited = new Set(), inheritedParamMap, wrapperCache = new Map()) {
-    const events = new Set();
-    const detectedFunctionWrappers = new Set();
-    const detectedComponentWrappers = new Map();
-    if (visited.has(source.fileName) || visited.size > 200) {
-        return { events, detectedFunctionWrappers, detectedComponentWrappers };
+        wrapperCache.set(tagName, null);
+        return null;
     }
-    visited.add(source.fileName);
     function visit(node) {
-        // JSX WRAPPERS
+        // JSX
         if (typescript_1.default.isJsxSelfClosingElement(node) || typescript_1.default.isJsxOpeningElement(node)) {
             const tagName = getJsxTagName(node.tagName);
-            // skip html
             if (tagName[0] === tagName[0].toLowerCase()) {
                 typescript_1.default.forEachChild(node, visit);
                 return;
             }
             let wrapper = config.wrappers.find(w => w.name === tagName);
-            // AUTO DETECT
             if (!wrapper) {
-                if (wrapperCache.has(tagName)) {
-                    const cached = wrapperCache.get(tagName);
-                    if (cached)
-                        wrapper = { name: tagName, prop: cached };
-                }
-                else {
-                    let symbol = checker.getSymbolAtLocation(node.tagName);
-                    if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
-                        symbol = checker.getAliasedSymbol(symbol);
-                    }
-                    if (symbol) {
-                        symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-                        for (const decl of symbol.getDeclarations() ?? []) {
-                            let fn = null;
-                            if (typescript_1.default.isFunctionDeclaration(decl))
-                                fn = decl;
-                            if (typescript_1.default.isVariableDeclaration(decl) &&
-                                decl.initializer &&
-                                (typescript_1.default.isArrowFunction(decl.initializer) ||
-                                    typescript_1.default.isFunctionExpression(decl.initializer))) {
-                                fn = decl.initializer;
-                            }
-                            if (!fn)
-                                continue;
-                            const prop = findTrackedPropName(fn, checker);
-                            wrapperCache.set(tagName, prop ?? null);
-                            if (prop) {
-                                wrapper = { name: tagName, prop };
-                                detectedComponentWrappers.set(tagName, prop);
-                                break;
-                            }
-                        }
-                    }
-                }
+                const prop = detectComponentWrapper(node.tagName);
+                if (prop)
+                    wrapper = { name: tagName, prop };
             }
             if (wrapper) {
                 for (const attr of node.attributes.properties) {
@@ -200,15 +150,15 @@ function scanSource(source, checker, config, visited = new Set(), inheritedParam
                     if (!attr.initializer)
                         continue;
                     if (typescript_1.default.isStringLiteral(attr.initializer)) {
-                        const v = attr.initializer.text;
-                        if (isValidEvent(v))
-                            events.add(v);
+                        if (isValidEvent(attr.initializer.text)) {
+                            events.add(attr.initializer.text);
+                        }
                     }
                     if (typescript_1.default.isJsxExpression(attr.initializer)) {
                         const expr = attr.initializer.expression;
                         if (!expr)
                             continue;
-                        const res = (0, resolver_1.resolveNodeValue)(expr, checker, inheritedParamMap);
+                        const res = (0, resolver_1.resolveNodeValue)(expr, checker);
                         res.values.forEach(v => {
                             if (isValidEvent(v))
                                 events.add(v);
@@ -219,65 +169,37 @@ function scanSource(source, checker, config, visited = new Set(), inheritedParam
             typescript_1.default.forEachChild(node, visit);
             return;
         }
-        // FUNCTION CALLS
+        // CALL
         if (typescript_1.default.isCallExpression(node)) {
-            let trackParamIndex = null;
-            let isTracking = false;
-            const callName = getCallName(node.expression);
-            // direct .track()
-            if (typescript_1.default.isPropertyAccessExpression(node.expression) &&
-                node.expression.name.text === "track") {
-                isTracking = true;
-                trackParamIndex = 0;
-            }
-            // config wrapper
-            const manualWrapper = config.functionWrappers.find(w => w.name === callName);
-            if (manualWrapper) {
-                isTracking = true;
-                trackParamIndex = 0;
-            }
-            // resolve function → check body
             const resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-            if (resolvedFn) {
-                const idx = (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn);
-                if (idx !== null) {
-                    isTracking = true;
-                    trackParamIndex = idx;
-                    if (!manualWrapper && callName !== "track") {
-                        detectedFunctionWrappers.add(callName);
-                    }
-                }
-            }
-            if (!isTracking) {
-                typescript_1.default.forEachChild(node, visit);
-                return;
-            }
             const paramMap = new Map(inheritedParamMap ?? []);
-            if (resolvedFn && typescript_1.default.isFunctionLike(resolvedFn)) {
-                resolvedFn.parameters.forEach((param, i) => {
+            if (resolvedFn) {
+                resolvedFn.parameters.forEach((p, i) => {
                     const arg = node.arguments[i];
                     if (!arg)
                         return;
-                    if (typescript_1.default.isIdentifier(param.name)) {
-                        paramMap.set(param.name.text, arg);
+                    if (typescript_1.default.isIdentifier(p.name)) {
+                        paramMap.set(p.name.text, arg);
                     }
                 });
             }
-            if (trackParamIndex !== null && node.arguments[trackParamIndex]) {
-                const res = (0, resolver_1.resolveNodeValue)(node.arguments[trackParamIndex], checker, paramMap);
-                res.values.forEach(v => {
-                    if (isValidEvent(v))
-                        events.add(v);
-                });
-            }
-            // CROSS FILE
-            if (resolvedFn) {
-                const sf = resolvedFn.getSourceFile();
-                if (!visited.has(sf.fileName)) {
-                    const res = scanSource(sf, checker, config, visited, paramMap, wrapperCache);
-                    res.events.forEach(e => events.add(e));
+            // direct track
+            extractTrackCall(node, paramMap);
+            // wrapper
+            if (resolvedFn && isWrapperFunction(resolvedFn)) {
+                const name = getCallName(node.expression);
+                if (name && name !== "track") {
+                    detectedFunctionWrappers.add(name);
+                }
+                if (resolvedFn.body) {
+                    visit(resolvedFn.body);
                 }
             }
+            for (const arg of node.arguments) {
+                visit(arg);
+            }
+            visit(node.expression);
+            return;
         }
         typescript_1.default.forEachChild(node, visit);
     }

package/package.json

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

package/src/engine/callResolver.ts

@@ -1,200 +1,65 @@
 import ts from "typescript";
 
-// HELPERS
-function isFunctionLike(
-  node: ts.Node
-): node is ts.FunctionLikeDeclaration {
+function isFn(node: ts.Node): node is ts.FunctionLikeDeclaration {
   return (
     ts.isFunctionDeclaration(node) ||
     ts.isMethodDeclaration(node) ||
-    ts.isConstructorDeclaration(node) ||
     ts.isFunctionExpression(node) ||
     ts.isArrowFunction(node)
   );
 }
 
-// symbol → function
 function resolveFromSymbol(
   symbol: ts.Symbol,
   checker: ts.TypeChecker,
-  visited = new Set<ts.Symbol>(),
-  depth = 0
+  seen = new Set<ts.Symbol>()
 ): ts.FunctionLikeDeclaration | null {
-  if (!symbol) return null;
-  if (visited.has(symbol)) return null;
-  if (depth > 10) return null;
+  if (seen.has(symbol)) return null;
+  seen.add(symbol);
 
-  visited.add(symbol);
-
-  // Alias unwrap (import/export)
   if (symbol.flags & ts.SymbolFlags.Alias) {
-    try {
-      const aliased = checker.getAliasedSymbol(symbol);
-      return resolveFromSymbol(aliased, checker, visited, depth + 1);
-    } catch {}
+    return resolveFromSymbol(checker.getAliasedSymbol(symbol), checker, seen);
   }
 
-  // Declarations
-  const decls = symbol.getDeclarations() ?? [];
+  for (const d of symbol.getDeclarations() ?? []) {
+    if (isFn(d)) return d;
 
-  for (const decl of decls) {
-    /**
-     * direct function
-     */
-    if (isFunctionLike(decl)) {
-      return decl;
-    }
+    if (ts.isVariableDeclaration(d) && d.initializer) {
+      if (isFn(d.initializer)) return d.initializer;
 
-    // VARIABLE → FUNCTION const fn = () => {}
-    if (ts.isVariableDeclaration(decl) && decl.initializer) {
-      if (isFunctionLike(decl.initializer)) {
-        return decl.initializer;
+      const s = checker.getSymbolAtLocation(d.initializer);
+      if (s) {
+        const r = resolveFromSymbol(s, checker, seen);
+        if (r) return r;
       }
-
-      const innerSymbol = checker.getSymbolAtLocation(decl.initializer);
-      if (innerSymbol && innerSymbol !== symbol) {
-        const resolved = resolveFromSymbol(
-          innerSymbol,
-          checker,
-          visited,
-          depth + 1
-        );
-        if (resolved) return resolved;
-      }
-    }
-
-    // CLASS METHOD
-    if (ts.isMethodDeclaration(decl)) {
-      return decl;
-    }
-
-    // interface / type method
-    if (ts.isMethodSignature(decl)) {
-      const parent = decl.parent;
-
-      if (
-        ts.isInterfaceDeclaration(parent) ||
-        ts.isTypeLiteralNode(parent)
-      ) {
-        const type = checker.getTypeAtLocation(parent);
-        const props = type.getProperties();
-
-        for (const prop of props) {
-          const resolved = resolveFromSymbol(
-            prop,
-            checker,
-            visited,
-            depth + 1
-          );
-          if (resolved) return resolved;
-        }
-      }
-    }
-
-    // fallback recursion
-    const inner = checker.getSymbolAtLocation(decl);
-    if (inner && inner !== symbol) {
-      const resolved = resolveFromSymbol(
-        inner,
-        checker,
-        visited,
-        depth + 1
-      );
-      if (resolved) return resolved;
-    }
-  }
-
-  // Exports (re-export)
-  const exports = (symbol as any).exports;
-  if (exports) {
-    for (const exp of exports.values()) {
-      const resolved = resolveFromSymbol(
-        exp,
-        checker,
-        visited,
-        depth + 1
-      );
-      if (resolved) return resolved;
     }
   }
 
   return null;
 }
 
-// MAIN FUNCTION
 export function resolveFunctionFromCall(
   expr: ts.Expression,
   checker: ts.TypeChecker
 ): ts.FunctionLikeDeclaration | null {
-  // obj.method()
+  // foo.bar()
   if (ts.isPropertyAccessExpression(expr)) {
-    let symbol = checker.getSymbolAtLocation(expr.name);
-
-    if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
-      try {
-        symbol = checker.getAliasedSymbol(symbol);
-      } catch {}
-    }
-
-    if (symbol) {
-      const resolved = resolveFromSymbol(symbol, checker);
-      if (resolved) return resolved;
+    const s = checker.getSymbolAtLocation(expr.name);
+    if (s) {
+      const r = resolveFromSymbol(s, checker);
+      if (r) return r;
     }
   }
 
-  // obj["method"]()
-  if (ts.isElementAccessExpression(expr)) {
-    const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
-
-    if (symbol) {
-      const resolved = resolveFromSymbol(symbol, checker);
-      if (resolved) return resolved;
-    }
-  }
-
-  // Call signatures
+  // direct call
   const type = checker.getTypeAtLocation(expr);
-  const signatures = type.getCallSignatures();
-
-  for (const sig of signatures) {
-    const decl = sig.getDeclaration();
-    if (!decl) continue;
-
-    if (isFunctionLike(decl)) {
-      return decl;
-    }
-
-    if (ts.isMethodSignature(decl)) {
-      const symbol = checker.getSymbolAtLocation(decl.name);
-
-      if (symbol) {
-        const resolved = resolveFromSymbol(symbol, checker);
-        if (resolved) return resolved;
-      }
-    }
+  for (const sig of type.getCallSignatures()) {
+    const d = sig.getDeclaration();
+    if (d && isFn(d)) return d;
   }
 
-  // Identifier fallback
-  if (ts.isIdentifier(expr)) {
-    let symbol = checker.getSymbolAtLocation(expr);
-
-    if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
-      try {
-        symbol = checker.getAliasedSymbol(symbol);
-      } catch {}
-    }
-
-    if (symbol) {
-      const resolved = resolveFromSymbol(symbol, checker);
-      if (resolved) return resolved;
-    }
-  }
-
-  // LAST fallback
-  const symbol = checker.getSymbolAtLocation(expr);
-  if (symbol) {
-    return resolveFromSymbol(symbol, checker);
-  }
+  const s = checker.getSymbolAtLocation(expr);
+  if (s) return resolveFromSymbol(s, checker);
 
   return null;
 }