@eventra_dev/eventra-cli 0.1.29 → 0.1.31

package/src/engine/scanner.ts

@@ -1,11 +1,27 @@
 import ts from "typescript";
 import { resolveNodeValue } from "./resolver";
 import { resolveFunctionFromCall } from "./callResolver";
-import { resolveExportedSymbol } from "./exportResolver";
 import { findTrackParamIndex } from "./functionAnalyzer";
-import { EventraConfig } from "../types";
+import { resolveExportedSymbol } from "./exportResolver";
+import { EventraConfig, ScanResult } from "../types";
 import { isExternalFile } from "./boundary";
-import { isTrackingCall } from "./trackingDetector";
+
+// UTILS
+function getJsxAttrName(name: ts.JsxAttributeName): string {
+  if (ts.isIdentifier(name)) return name.text;
+  if (ts.isJsxNamespacedName(name)) return name.name.text;
+  return "";
+}
+
+function getJsxTagName(tag: ts.JsxTagNameExpression): string {
+  if (ts.isIdentifier(tag)) return tag.text;
+
+  if (ts.isPropertyAccessExpression(tag)) {
+    return tag.name.text;
+  }
+
+  return "";
+}
 
 function getCallName(expr: ts.Expression): string {
   if (ts.isIdentifier(expr)) return expr.text;
@@ -23,56 +39,144 @@ function isValidEvent(v: string) {
   );
 }
 
-function resolveFunctionDeep(
-  expr: ts.Expression,
-  checker: ts.TypeChecker
-): ts.FunctionLikeDeclaration | null {
-  let fn = resolveFunctionFromCall(expr, checker);
-  if (fn) return fn;
+// COMPONENT ANALYSIS
+function getComponentPropsMap(
+  fn: ts.FunctionLikeDeclaration
+): Map<string, string> {
+  const map = new Map<string, string>();
+  const firstParam = fn.parameters[0];
+  if (!firstParam) return map;
 
-  let symbol = checker.getSymbolAtLocation(expr);
+  // ({ event }) => ...
+  if (ts.isObjectBindingPattern(firstParam.name)) {
+    for (const el of firstParam.name.elements) {
+      if (!ts.isBindingElement(el)) continue;
 
-  if (!symbol) return null;
+      const propName =
+        el.propertyName?.getText() || el.name.getText();
 
-  if (symbol.flags & ts.SymbolFlags.Alias) {
-    symbol = checker.getAliasedSymbol(symbol);
+      map.set(el.name.getText(), propName);
+    }
   }
 
-  const resolvedSymbol =
-    resolveExportedSymbol(symbol, checker) ?? symbol;
+  // (props) => props.event
+  if (ts.isIdentifier(firstParam.name)) {
+    map.set(firstParam.name.text, "*");
+  }
 
-  for (const decl of resolvedSymbol.getDeclarations() ?? []) {
-    if (ts.isFunctionDeclaration(decl)) {
-      return decl;
+  return map;
+}
+
+function findTrackedPropName(
+  fn: ts.FunctionLikeDeclaration,
+  checker: ts.TypeChecker
+): string | null {
+  const propMap = getComponentPropsMap(fn);
+  let result: string | null = null;
+
+  function resolveIdentifierToProp(
+    node: ts.Identifier
+  ): string | null {
+    const mapped = propMap.get(node.text);
+    if (mapped && mapped !== "*") return mapped;
+
+    const symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) return null;
+
+    for (const decl of symbol.getDeclarations() ?? []) {
+      // const e = props.event
+      if (
+        ts.isVariableDeclaration(decl) &&
+        decl.initializer &&
+        ts.isPropertyAccessExpression(decl.initializer)
+      ) {
+        return decl.initializer.name.text;
+      }
+
+      // const e = event
+      if (
+        ts.isVariableDeclaration(decl) &&
+        decl.initializer &&
+        ts.isIdentifier(decl.initializer)
+      ) {
+        const inner = propMap.get(decl.initializer.text);
+        if (inner) return inner;
+      }
     }
 
-    if (
-      ts.isVariableDeclaration(decl) &&
-      decl.initializer &&
-      (ts.isArrowFunction(decl.initializer) ||
-        ts.isFunctionExpression(decl.initializer))
-    ) {
-      return decl.initializer;
+    return null;
+  }
+
+  function visit(node: ts.Node) {
+    if (result) return;
+
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+
+      const isTrack =
+        (ts.isIdentifier(expr) && expr.text === "track") ||
+        (ts.isPropertyAccessExpression(expr) &&
+          expr.name.text === "track");
+
+      if (!isTrack) {
+        ts.forEachChild(node, visit);
+        return;
+      }
+
+      for (const arg of node.arguments) {
+        // track(event)
+        if (ts.isIdentifier(arg)) {
+          const prop = resolveIdentifierToProp(arg);
+          if (prop) {
+            result = prop;
+            return;
+          }
+        }
+
+        // track(props.a.b.event)
+        if (ts.isPropertyAccessExpression(arg)) {
+          let current = arg;
+
+          while (ts.isPropertyAccessExpression(current)) {
+            result = current.name.text;
+            return;
+          }
+        }
+
+        // track(fn())
+        if (ts.isCallExpression(arg)) {
+          const inner = resolveFunctionFromCall(
+            arg.expression,
+            checker
+          );
+
+          if (inner?.body) {
+            visit(inner.body);
+            if (result) return;
+          }
+        }
+      }
     }
+
+    ts.forEachChild(node, visit);
   }
 
-  return null;
-}
+  if (fn.body) visit(fn.body);
 
-export type ScanResult = {
-  events: Set<string>;
-  detectedFunctionWrappers: Set<string>;
-  detectedComponentWrappers: Map<string, string>;
-};
+  return result;
+}
 
+// MAIN SCANNER
 export function scanSource(
   source: ts.SourceFile,
   checker: ts.TypeChecker,
   config: EventraConfig,
   visited = new Set<string>(),
-  depth = 0,
-  inheritedParamMap?: Map<string, ts.Expression>
+  inheritedParamMap?: Map<string, ts.Expression>,
+  wrapperCache?: Map<string, string | null>
 ): ScanResult {
+  wrapperCache = wrapperCache ?? new Map();
+
   const events = new Set<string>();
   const detectedFunctionWrappers = new Set<string>();
   const detectedComponentWrappers = new Map<string, string>();
@@ -84,63 +188,149 @@ export function scanSource(
   visited.add(source.fileName);
 
   function visit(node: ts.Node) {
-    // CALL EXPRESSIONS
+    // JSX WRAPPERS
+    if (
+      ts.isJsxSelfClosingElement(node) ||
+      ts.isJsxOpeningElement(node)
+    ) {
+      const tagName = getJsxTagName(node.tagName);
+
+      // skip html
+      if (!tagName || tagName[0] === tagName[0].toLowerCase()) {
+        ts.forEachChild(node, visit);
+        return;
+      }
+
+      let wrapper = config.wrappers.find(
+        (w) => w.name === tagName
+      );
+
+      if (!wrapper) {
+        let symbol = checker.getSymbolAtLocation(node.tagName);
+
+        let cacheKey = tagName;
+
+        if (symbol) {
+          if (symbol.flags & ts.SymbolFlags.Alias) {
+            symbol = checker.getAliasedSymbol(symbol);
+          }
+
+          symbol =
+            resolveExportedSymbol(symbol, checker) ?? symbol;
+
+          cacheKey = checker.getFullyQualifiedName(symbol);
+        }
+
+        if (wrapperCache?.has(cacheKey)) {
+          const cached = wrapperCache.get(cacheKey);
+          if (cached) {
+            wrapper = { name: tagName, prop: cached };
+          }
+        } else if (symbol) {
+          let detected: string | null = null;
+
+          for (const decl of symbol.getDeclarations() ?? []) {
+            let fn: ts.FunctionLikeDeclaration | null = null;
+
+            if (ts.isFunctionDeclaration(decl)) fn = decl;
+
+            if (
+              ts.isVariableDeclaration(decl) &&
+              decl.initializer &&
+              (ts.isArrowFunction(decl.initializer) ||
+                ts.isFunctionExpression(decl.initializer))
+            ) {
+              fn = decl.initializer;
+            }
+
+            if (!fn) continue;
+
+            const prop = findTrackedPropName(fn, checker);
+
+            if (prop) {
+              detected = prop;
+              break;
+            }
+          }
+
+          wrapperCache?.set(cacheKey, detected);
+
+          if (detected) {
+            wrapper = { name: tagName, prop: detected };
+            detectedComponentWrappers.set(tagName, detected);
+          }
+        }
+      }
+
+      if (wrapper) {
+        for (const attr of node.attributes.properties) {
+          if (!ts.isJsxAttribute(attr)) continue;
+
+          const name = getJsxAttrName(attr.name);
+          if (name !== wrapper.prop) continue;
+          if (!attr.initializer) continue;
+
+          if (ts.isStringLiteral(attr.initializer)) {
+            if (isValidEvent(attr.initializer.text)) {
+              events.add(attr.initializer.text);
+            }
+          }
+
+          if (ts.isJsxExpression(attr.initializer)) {
+            const expr = attr.initializer.expression;
+            if (!expr) continue;
+
+            const res = resolveNodeValue(
+              expr,
+              checker,
+              inheritedParamMap
+            );
+
+            res.values.forEach((v) => {
+              if (isValidEvent(v)) events.add(v);
+            });
+          }
+        }
+      }
+
+      ts.forEachChild(node, visit);
+      return;
+    }
+
+    // FUNCTION TRACKING
     if (ts.isCallExpression(node)) {
       const name = getCallName(node.expression);
 
       const isKnownWrapper = config.functionWrappers.some(
-        w => w.name === name
+        (w) => w.name === name
       );
 
-      const isTrackingByType = isTrackingCall(node, checker);
-
-      const resolvedFn = resolveFunctionDeep(
+      const resolvedFn = resolveFunctionFromCall(
         node.expression,
         checker
       );
 
       const isAutoWrapper =
-        resolvedFn && findTrackParamIndex(resolvedFn) !== null;
+        !!resolvedFn && findTrackParamIndex(resolvedFn) !== null;
 
-      let isTracking =
+      const isTracking =
+        name === "track" ||
         isKnownWrapper ||
-        isTrackingByType ||
-        name.startsWith("$") ||
         (isAutoWrapper &&
           resolvedFn &&
-          resolvedFn.getSourceFile &&
-          !isExternalFile(resolvedFn.getSourceFile().fileName));
-
-      if (!isTracking) {
-        if (
-          ts.isPropertyAccessExpression(node.expression) &&
-          node.expression.name.text === "track"
-        ) {
-          isTracking = true;
-        } else if (
-          ts.isIdentifier(node.expression) &&
-          node.expression.text === "track"
-        ) {
-          isTracking = true;
-        }
-      }
+          !isExternalFile(
+            resolvedFn.getSourceFile().fileName
+          ));
 
       if (!isTracking) {
         ts.forEachChild(node, visit);
         return;
       }
 
-      // DETECT WRAPPER
-      if (
-        !isKnownWrapper &&
-        isAutoWrapper &&
-        !isTrackingByType &&
-        !name.startsWith("track")
-      ) {
+      if (!isKnownWrapper && isAutoWrapper && name !== "track") {
         detectedFunctionWrappers.add(name);
       }
 
-      // PARAM MAP
       const paramMap = new Map(inheritedParamMap ?? []);
 
       if (resolvedFn && ts.isFunctionLike(resolvedFn)) {
@@ -154,7 +344,6 @@ export function scanSource(
         });
       }
 
-      // STRICT EVENT RESOLVE
       if (resolvedFn) {
         const idx = findTrackParamIndex(resolvedFn);
 
@@ -165,27 +354,26 @@ export function scanSource(
             paramMap
           );
 
-          res.values.forEach(v => {
+          res.values.forEach((v) => {
             if (isValidEvent(v)) events.add(v);
           });
         }
       }
 
-      // CROSS-FILE
       if (resolvedFn) {
-        const sf = resolvedFn.getSourceFile?.();
+        const sf = resolvedFn.getSourceFile();
 
-        if (sf && !visited.has(sf.fileName)) {
+        if (!visited.has(sf.fileName)) {
           const res = scanSource(
             sf,
             checker,
             config,
             visited,
-            depth + 1,
-            paramMap
+            paramMap,
+            wrapperCache
           );
 
-          res.events.forEach(e => events.add(e));
+          res.events.forEach((e) => events.add(e));
         }
       }
     }

package/src/types.ts

@@ -1,5 +1,11 @@
 export type ScanMode = "strict" | "hybrid" | "discovery";
 
+export type ScanResult = {
+  events: Set<string>;
+  detectedFunctionWrappers: Set<string>;
+  detectedComponentWrappers: Map<string, string>;
+};
+
 export type ParseResult = {
   code: string;
   deps: string[];
@@ -22,7 +28,6 @@ export type EventraConfig = {
   mode?: ScanMode;
   wrappers: ComponentWrapper[];
   functionWrappers: FunctionWrapper[];
-  aliases?: Record<string, string>;
   sync: {
     include: string[];
     exclude: string[];

package/src/utils/config.ts

@@ -13,7 +13,6 @@ export function normalizeConfig(
     endpoint: config.endpoint ?? "",
     wrappers: config.wrappers ?? [],
     functionWrappers: config.functionWrappers ?? [],
-    aliases: config.aliases ?? {},
     sync: config.sync ?? {
       include: [
         "**/*.{ts,tsx,js,jsx,vue,svelte,astro}"

package/src/utils/processFile.ts

@@ -1,10 +1,10 @@
 import { parseUniversal } from "./universal";
 
 export function processFile(file: string, content: string) {
-  const { code, deps } = parseUniversal(content, file);
+  const parsed = parseUniversal(content, file);
 
   return {
-    content: code || "",
-    deps: [...new Set(deps.filter(Boolean))],
+    content: parsed.code || "",
+    deps: [...new Set(parsed.deps.filter(Boolean))],
   };
 }