@eventra_dev/eventra-cli 0.1.30 → 0.1.31

package/README.md

@@ -170,7 +170,6 @@ eventra send
   "events": [],
   "wrappers": [],
   "functionWrappers": [],
-  "aliases": {},
   "sync": {
     "include": ["**/*.{ts,tsx,js,jsx,vue,svelte,astro}"],
     "exclude": ["node_modules", "dist", ".next", ".git"]

package/dist/engine/engine.js

@@ -14,6 +14,7 @@ const boundary_1 = require("./boundary");
 class EventraEngine {
     ts;
     graph;
+    wrapperCache = new Map();
     fileResults = new Map();
     fileHash = new Map();
     constructor(root) {
@@ -54,14 +55,15 @@ class EventraEngine {
         if (!source || !checker) {
             return this.empty();
         }
-        // обновляем graph
+        // update graph
         this.graph.update(file, source);
-        const res = (0, scanner_1.scanSource)(source, checker, config);
+        const res = (0, scanner_1.scanSource)(source, checker, config, new Set(), undefined, this.wrapperCache);
         this.fileResults.set(file, res);
         return res;
     }
     // UPDATE FILE (incremental)
     updateFile(file, content, config) {
+        this.wrapperCache.clear();
         file = this.normalize(file);
         const res = this.scanFile(file, content, config);
         const dependents = this.graph.getAllDependentsDeep(file);
@@ -89,7 +91,7 @@ class EventraEngine {
             if (!source || !checker)
                 continue;
             this.graph.update(abs, source);
-            const r = (0, scanner_1.scanSource)(source, checker, config);
+            const r = (0, scanner_1.scanSource)(source, checker, config, new Set(), undefined, this.wrapperCache);
             this.fileResults.set(abs, r);
         }
         return res;
@@ -104,6 +106,7 @@ class EventraEngine {
     }
     // REMOVE FILE
     removeFile(file, config) {
+        this.wrapperCache.clear();
         file = this.normalize(file);
         const dependents = this.graph.getAllDependentsDeep(file);
         this.ts.removeFile(file);
@@ -138,7 +141,7 @@ class EventraEngine {
                 wrappers: [],
                 functionWrappers: [],
                 sync: { include: [], exclude: [] },
-            });
+            }, new Set(), undefined, this.wrapperCache);
             this.fileResults.set(abs, r);
         }
     }

package/dist/engine/scanner.js

@@ -8,7 +8,24 @@ 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");
 const boundary_1 = require("./boundary");
+// 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 getCallName(expr) {
     if (typescript_1.default.isIdentifier(expr))
         return expr.text;
@@ -23,7 +40,104 @@ function isValidEvent(v) {
         !v.includes(" ") &&
         /^[a-zA-Z0-9._:-]+$/.test(v));
 }
-function scanSource(source, checker, config, visited = new Set(), inheritedParamMap) {
+// 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);
+        }
+    }
+    // (props) => props.event
+    if (typescript_1.default.isIdentifier(firstParam.name)) {
+        map.set(firstParam.name.text, "*");
+    }
+    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)
+            return null;
+        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
+            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;
+            }
+            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)
+                            return;
+                    }
+                }
+            }
+        }
+        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) {
+    wrapperCache = wrapperCache ?? new Map();
     const events = new Set();
     const detectedFunctionWrappers = new Set();
     const detectedComponentWrappers = new Map();
@@ -32,9 +146,93 @@ function scanSource(source, checker, config, visited = new Set(), inheritedParam
     }
     visited.add(source.fileName);
     function visit(node) {
+        // JSX WRAPPERS
+        if (typescript_1.default.isJsxSelfClosingElement(node) ||
+            typescript_1.default.isJsxOpeningElement(node)) {
+            const tagName = getJsxTagName(node.tagName);
+            // skip html
+            if (!tagName || tagName[0] === tagName[0].toLowerCase()) {
+                typescript_1.default.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 & typescript_1.default.SymbolFlags.Alias) {
+                        symbol = checker.getAliasedSymbol(symbol);
+                    }
+                    symbol =
+                        (0, exportResolver_1.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 = null;
+                    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);
+                        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 (!typescript_1.default.isJsxAttribute(attr))
+                        continue;
+                    const name = getJsxAttrName(attr.name);
+                    if (name !== wrapper.prop)
+                        continue;
+                    if (!attr.initializer)
+                        continue;
+                    if (typescript_1.default.isStringLiteral(attr.initializer)) {
+                        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);
+                        res.values.forEach((v) => {
+                            if (isValidEvent(v))
+                                events.add(v);
+                        });
+                    }
+                }
+            }
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // FUNCTION TRACKING
         if (typescript_1.default.isCallExpression(node)) {
             const name = getCallName(node.expression);
-            const isKnownWrapper = config.functionWrappers.some(w => w.name === name);
+            const isKnownWrapper = config.functionWrappers.some((w) => w.name === name);
             const resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
             const isAutoWrapper = !!resolvedFn && (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn) !== null;
             const isTracking = name === "track" ||
@@ -46,7 +244,6 @@ function scanSource(source, checker, config, visited = new Set(), inheritedParam
                 typescript_1.default.forEachChild(node, visit);
                 return;
             }
-            // авто-детект wrapper
             if (!isKnownWrapper && isAutoWrapper && name !== "track") {
                 detectedFunctionWrappers.add(name);
             }
@@ -61,24 +258,21 @@ function scanSource(source, checker, config, visited = new Set(), inheritedParam
                     }
                 });
             }
-            // ✅ ТОЛЬКО правильный аргумент
             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);
-                    for (const v of res.values) {
-                        if (isValidEvent(v)) {
+                    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);
-                    res.events.forEach(e => events.add(e));
+                    const res = scanSource(sf, checker, config, visited, paramMap, wrapperCache);
+                    res.events.forEach((e) => events.add(e));
                 }
             }
         }

package/dist/utils/config.js

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

package/dist/utils/processFile.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFile = processFile;
 const universal_1 = require("./universal");
 function processFile(file, content) {
-    const { code, deps } = (0, universal_1.parseUniversal)(content, file);
+    const parsed = (0, universal_1.parseUniversal)(content, file);
     return {
-        content: code || "",
-        deps: [...new Set(deps.filter(Boolean))],
+        content: parsed.code || "",
+        deps: [...new Set(parsed.deps.filter(Boolean))],
     };
 }

package/dist/utils/universal.js

@@ -5,116 +5,132 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseUniversal = parseUniversal;
 const path_1 = __importDefault(require("path"));
-// Remove comments
+// SAFE COMMENT STRIP
 function stripComments(input) {
     return input
         .replace(/<!--[\s\S]*?-->/g, "")
-        .replace(/\/\*[\s\S]*?\*\//g, "")
-        .replace(/\/\/.*$/gm, "");
+        .replace(/\/\*[\s\S]*?\*\//g, "");
 }
-// Basic filter
+// TRACK FILTER
 function looksLikeTracking(code) {
-    return /track/i.test(code);
+    return /\btrack\w*\s*\(/.test(code);
 }
-// HTML inline handlers (onclick="")
+// SAFE {} PARSER
+function extractBracedExpressions(input) {
+    const result = [];
+    let depth = 0;
+    let start = -1;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        if (char === "{") {
+            if (depth === 0)
+                start = i + 1;
+            depth++;
+        }
+        else if (char === "}") {
+            depth--;
+            if (depth === 0 && start !== -1) {
+                const expr = input.slice(start, i);
+                if (looksLikeTracking(expr)) {
+                    result.push(expr);
+                }
+                start = -1;
+            }
+        }
+    }
+    return result;
+}
+// HTML handlers
 function extractHTMLHandlers(input) {
     const result = [];
-    const matches = input.matchAll(/\bon\w+\s*=\s*["']([^"']+)["']/g);
-    for (const m of matches) {
+    const regex = /\bon\w+\s*=\s*["']([^"']+)["']/g;
+    for (const m of input.matchAll(regex)) {
         if (looksLikeTracking(m[1])) {
             result.push(m[1]);
         }
     }
     return result;
 }
-// Vue handlers (@click / v-on)
+// VUE handlers
 function extractVueHandlers(input) {
     const result = [];
-    const matches = input.matchAll(/(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g);
-    for (const m of matches) {
+    const regex = /(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g;
+    for (const m of input.matchAll(regex)) {
         if (looksLikeTracking(m[1])) {
             result.push(m[1]);
         }
     }
     return result;
 }
-// Svelte handlers (on:click)
+// SVELTE handlers
 function extractSvelteHandlers(input) {
     const result = [];
-    const matches = input.matchAll(/\bon:[\w]+\s*=\s*{([^}]+)}/g);
-    for (const m of matches) {
+    const regex = /\bon:[\w]+\s*=\s*{([^}]+)}/g;
+    for (const m of input.matchAll(regex)) {
         if (looksLikeTracking(m[1])) {
             result.push(m[1]);
         }
     }
     return result;
 }
-// JSX / template { ... }
-function extractJSExpressions(input) {
-    const result = [];
-    const matches = input.matchAll(/\{([^}]+)\}/g);
-    for (const m of matches) {
-        if (looksLikeTracking(m[1])) {
-            result.push(m[1]);
+// SCRIPT EXTRACTION
+function extractScripts(input, file) {
+    const scripts = [];
+    const deps = [];
+    // src scripts
+    const srcRegex = /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g;
+    for (const m of input.matchAll(srcRegex)) {
+        const src = m[1];
+        const resolved = src.startsWith("/")
+            ? path_1.default.resolve(process.cwd(), "." + src)
+            : path_1.default.resolve(path_1.default.dirname(file), src);
+        deps.push(resolved);
+    }
+    // inline scripts
+    const scriptRegex = /<script\b[^>]*>([\s\S]*?)<\/script>/g;
+    for (const m of input.matchAll(scriptRegex)) {
+        if (m[1]?.trim()) {
+            scripts.push(m[1]);
         }
     }
-    return result;
+    const noScripts = input.replace(scriptRegex, "");
+    return { scripts, deps, noScripts };
 }
-// dynamic import()
+// DYNAMIC IMPORTS
 function extractDynamicImports(input, file) {
     const deps = [];
-    const calls = [];
-    const matches = input.matchAll(/import\(\s*["'](.+?)["']\s*\)/g);
-    for (const m of matches) {
+    const regex = /import\(\s*["'](.+?)["']\s*\)/g;
+    for (const m of input.matchAll(regex)) {
         const mod = m[1];
         const resolved = mod.startsWith("/")
             ? path_1.default.resolve(process.cwd(), "." + mod)
             : path_1.default.resolve(path_1.default.dirname(file), mod);
         deps.push(resolved);
-        if (looksLikeTracking(mod)) {
-            calls.push(`import("${mod}")`);
-        }
     }
-    return { deps, calls };
+    return deps;
 }
-// UNIVERSAL PARSER
+// MAIN
 function parseUniversal(content, file) {
     const parts = [];
     const deps = [];
     const clean = stripComments(content);
-    // ASTRO FRONTMATTER
+    /* ---------- ASTRO FRONTMATTER ---------- */
     const fm = clean.match(/^---([\s\S]*?)---/);
     if (fm?.[1]) {
         parts.push(fm[1]);
     }
-    // <script src="">
-    const scriptSrc = clean.matchAll(/<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g);
-    for (const s of scriptSrc) {
-        const src = s[1];
-        const resolved = src.startsWith("/")
-            ? path_1.default.resolve(process.cwd(), "." + src)
-            : path_1.default.resolve(path_1.default.dirname(file), src);
-        deps.push(resolved);
-    }
-    // INLINE <script>
-    const scripts = clean.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script>/g);
-    for (const m of scripts) {
-        if (m[2].trim()) {
-            parts.push(m[2]);
-        }
-    }
-    // TEMPLATE PART
-    const noScripts = clean.replace(/<script[\s\S]*?<\/script>/g, "");
-    // handlers
+    /* ---------- SCRIPTS ---------- */
+    const { scripts, deps: scriptDeps, noScripts } = extractScripts(clean, file);
+    parts.push(...scripts);
+    deps.push(...scriptDeps);
+    /* ---------- HANDLERS ---------- */
     parts.push(...extractHTMLHandlers(noScripts));
     parts.push(...extractVueHandlers(noScripts));
     parts.push(...extractSvelteHandlers(noScripts));
-    // JSX / Astro / Vue expressions
-    parts.push(...extractJSExpressions(clean));
-    // dynamic imports
-    const dyn = extractDynamicImports(clean, file);
-    deps.push(...dyn.deps);
-    parts.push(...dyn.calls);
+    /* ---------- JSX / TEMPLATE ---------- */
+    parts.push(...extractBracedExpressions(clean));
+    /* ---------- IMPORTS ---------- */
+    deps.push(...extractDynamicImports(clean, file));
     return {
         code: [...new Set(parts)].join("\n"),
         deps: [...new Set(deps.filter(Boolean))],

package/package.json

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

package/src/engine/engine.ts

@@ -2,16 +2,16 @@ import path from "path";
 import fs from "fs";
 
 import { TSService } from "./languageService";
-import { ScanResult, scanSource } from "./scanner";
+import { scanSource } from "./scanner";
 import { DependencyGraph } from "./graph";
 import { hash } from "./hash";
-import { EventraConfig } from "../types";
+import {EventraConfig, ScanResult} from "../types";
 import { isExternalFile } from "./boundary";
 
 export class EventraEngine {
   private ts: TSService;
   private graph: DependencyGraph;
-
+  private wrapperCache = new Map<string, string | null>();
   private fileResults = new Map<string, ScanResult>();
   private fileHash = new Map<string, string>();
 
@@ -71,10 +71,17 @@ export class EventraEngine {
       return this.empty();
     }
 
-    // обновляем graph
+    // update graph
     this.graph.update(file, source);
 
-    const res = scanSource(source, checker, config);
+    const res = scanSource(
+      source,
+      checker,
+      config,
+      new Set(),
+      undefined,
+      this.wrapperCache
+    );
     this.fileResults.set(file, res);
 
     return res;
@@ -86,6 +93,7 @@ export class EventraEngine {
     content: string,
     config: EventraConfig
   ) {
+    this.wrapperCache.clear();
     file = this.normalize(file);
 
     const res = this.scanFile(file, content, config);
@@ -124,7 +132,14 @@ export class EventraEngine {
 
       this.graph.update(abs, source);
 
-      const r = scanSource(source, checker, config);
+      const r = scanSource(
+        source,
+        checker,
+        config,
+        new Set(),
+        undefined,
+        this.wrapperCache
+      );
       this.fileResults.set(abs, r);
     }
 
@@ -144,6 +159,7 @@ export class EventraEngine {
 
   // REMOVE FILE
   removeFile(file: string, config?: EventraConfig) {
+    this.wrapperCache.clear();
     file = this.normalize(file);
 
     const dependents = this.graph.getAllDependentsDeep(file);
@@ -191,7 +207,10 @@ export class EventraEngine {
           wrappers: [],
           functionWrappers: [],
           sync: { include: [], exclude: [] },
-        }
+        },
+        new Set(),
+        undefined,
+        this.wrapperCache
       );
 
       this.fileResults.set(abs, r);

package/src/engine/scanner.ts

@@ -2,9 +2,27 @@ import ts from "typescript";
 import { resolveNodeValue } from "./resolver";
 import { resolveFunctionFromCall } from "./callResolver";
 import { findTrackParamIndex } from "./functionAnalyzer";
-import { EventraConfig } from "../types";
+import { resolveExportedSymbol } from "./exportResolver";
+import { EventraConfig, ScanResult } from "../types";
 import { isExternalFile } from "./boundary";
 
+// 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;
   if (ts.isPropertyAccessExpression(expr)) return expr.name.text;
@@ -21,19 +39,144 @@ function isValidEvent(v: string) {
   );
 }
 
-export type ScanResult = {
-  events: Set<string>;
-  detectedFunctionWrappers: Set<string>;
-  detectedComponentWrappers: Map<string, string>;
-};
+// 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;
+
+  // ({ event }) => ...
+  if (ts.isObjectBindingPattern(firstParam.name)) {
+    for (const el of firstParam.name.elements) {
+      if (!ts.isBindingElement(el)) continue;
+
+      const propName =
+        el.propertyName?.getText() || el.name.getText();
+
+      map.set(el.name.getText(), propName);
+    }
+  }
 
+  // (props) => props.event
+  if (ts.isIdentifier(firstParam.name)) {
+    map.set(firstParam.name.text, "*");
+  }
+
+  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;
+      }
+    }
+
+    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);
+  }
+
+  if (fn.body) visit(fn.body);
+
+  return result;
+}
+
+// MAIN SCANNER
 export function scanSource(
   source: ts.SourceFile,
   checker: ts.TypeChecker,
   config: EventraConfig,
   visited = new Set<string>(),
-  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>();
@@ -45,14 +188,127 @@ export function scanSource(
   visited.add(source.fileName);
 
   function visit(node: ts.Node) {
+    // 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 resolvedFn = resolveFunctionFromCall(node.expression, checker);
+      const resolvedFn = resolveFunctionFromCall(
+        node.expression,
+        checker
+      );
 
       const isAutoWrapper =
         !!resolvedFn && findTrackParamIndex(resolvedFn) !== null;
@@ -62,14 +318,15 @@ export function scanSource(
         isKnownWrapper ||
         (isAutoWrapper &&
           resolvedFn &&
-          !isExternalFile(resolvedFn.getSourceFile().fileName));
+          !isExternalFile(
+            resolvedFn.getSourceFile().fileName
+          ));
 
       if (!isTracking) {
         ts.forEachChild(node, visit);
         return;
       }
 
-      // авто-детект wrapper
       if (!isKnownWrapper && isAutoWrapper && name !== "track") {
         detectedFunctionWrappers.add(name);
       }
@@ -87,7 +344,6 @@ export function scanSource(
         });
       }
 
-      // ✅ ТОЛЬКО правильный аргумент
       if (resolvedFn) {
         const idx = findTrackParamIndex(resolvedFn);
 
@@ -98,15 +354,12 @@ export function scanSource(
             paramMap
           );
 
-          for (const v of res.values) {
-            if (isValidEvent(v)) {
-              events.add(v);
-            }
-          }
+          res.values.forEach((v) => {
+            if (isValidEvent(v)) events.add(v);
+          });
         }
       }
 
-      // CROSS FILE
       if (resolvedFn) {
         const sf = resolvedFn.getSourceFile();
 
@@ -116,10 +369,11 @@ export function scanSource(
             checker,
             config,
             visited,
-            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))],
   };
 }

package/src/utils/universal.ts

@@ -1,28 +1,53 @@
 import path from "path";
 import { ParseResult } from "../types";
 
-// Remove comments
+// SAFE COMMENT STRIP
 function stripComments(input: string): string {
   return input
     .replace(/<!--[\s\S]*?-->/g, "")
-    .replace(/\/\*[\s\S]*?\*\//g, "")
-    .replace(/\/\/.*$/gm, "");
+    .replace(/\/\*[\s\S]*?\*\//g, "");
 }
 
-// Basic filter
+// TRACK FILTER
 function looksLikeTracking(code: string) {
-  return /track/i.test(code);
+  return /\btrack\w*\s*\(/.test(code);
 }
 
-// HTML inline handlers (onclick="")
+// SAFE {} PARSER
+function extractBracedExpressions(input: string): string[] {
+  const result: string[] = [];
+
+  let depth = 0;
+  let start = -1;
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+
+    if (char === "{") {
+      if (depth === 0) start = i + 1;
+      depth++;
+    } else if (char === "}") {
+      depth--;
+      if (depth === 0 && start !== -1) {
+        const expr = input.slice(start, i);
+        if (looksLikeTracking(expr)) {
+          result.push(expr);
+        }
+        start = -1;
+      }
+    }
+  }
+
+  return result;
+}
+
+// HTML handlers
 function extractHTMLHandlers(input: string): string[] {
   const result: string[] = [];
 
-  const matches = input.matchAll(
-    /\bon\w+\s*=\s*["']([^"']+)["']/g
-  );
+  const regex = /\bon\w+\s*=\s*["']([^"']+)["']/g;
 
-  for (const m of matches) {
+  for (const m of input.matchAll(regex)) {
     if (looksLikeTracking(m[1])) {
       result.push(m[1]);
     }
@@ -31,15 +56,13 @@ function extractHTMLHandlers(input: string): string[] {
   return result;
 }
 
-// Vue handlers (@click / v-on)
+// VUE handlers
 function extractVueHandlers(input: string): string[] {
   const result: string[] = [];
 
-  const matches = input.matchAll(
-    /(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g
-  );
+  const regex = /(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g;
 
-  for (const m of matches) {
+  for (const m of input.matchAll(regex)) {
     if (looksLikeTracking(m[1])) {
       result.push(m[1]);
     }
@@ -48,15 +71,13 @@ function extractVueHandlers(input: string): string[] {
   return result;
 }
 
-// Svelte handlers (on:click)
+// SVELTE handlers
 function extractSvelteHandlers(input: string): string[] {
   const result: string[] = [];
 
-  const matches = input.matchAll(
-    /\bon:[\w]+\s*=\s*{([^}]+)}/g
-  );
+  const regex = /\bon:[\w]+\s*=\s*{([^}]+)}/g;
 
-  for (const m of matches) {
+  for (const m of input.matchAll(regex)) {
     if (looksLikeTracking(m[1])) {
       result.push(m[1]);
     }
@@ -65,34 +86,47 @@ function extractSvelteHandlers(input: string): string[] {
   return result;
 }
 
-// JSX / template { ... }
-function extractJSExpressions(input: string): string[] {
-  const result: string[] = [];
+// SCRIPT EXTRACTION
+function extractScripts(input: string, file: string) {
+  const scripts: string[] = [];
+  const deps: string[] = [];
 
-  const matches = input.matchAll(/\{([^}]+)\}/g);
+  // src scripts
+  const srcRegex =
+    /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g;
 
-  for (const m of matches) {
-    if (looksLikeTracking(m[1])) {
-      result.push(m[1]);
+  for (const m of input.matchAll(srcRegex)) {
+    const src = m[1];
+
+    const resolved = src.startsWith("/")
+      ? path.resolve(process.cwd(), "." + src)
+      : path.resolve(path.dirname(file), src);
+
+    deps.push(resolved);
+  }
+
+  // inline scripts
+  const scriptRegex =
+    /<script\b[^>]*>([\s\S]*?)<\/script>/g;
+
+  for (const m of input.matchAll(scriptRegex)) {
+    if (m[1]?.trim()) {
+      scripts.push(m[1]);
     }
   }
 
-  return result;
+  const noScripts = input.replace(scriptRegex, "");
+
+  return { scripts, deps, noScripts };
 }
 
-// dynamic import()
-function extractDynamicImports(
-  input: string,
-  file: string
-): { deps: string[]; calls: string[] } {
+// DYNAMIC IMPORTS
+function extractDynamicImports(input: string, file: string) {
   const deps: string[] = [];
-  const calls: string[] = [];
 
-  const matches = input.matchAll(
-    /import\(\s*["'](.+?)["']\s*\)/g
-  );
+  const regex = /import\(\s*["'](.+?)["']\s*\)/g;
 
-  for (const m of matches) {
+  for (const m of input.matchAll(regex)) {
     const mod = m[1];
 
     const resolved = mod.startsWith("/")
@@ -100,16 +134,12 @@ function extractDynamicImports(
       : path.resolve(path.dirname(file), mod);
 
     deps.push(resolved);
-
-    if (looksLikeTracking(mod)) {
-      calls.push(`import("${mod}")`);
-    }
   }
 
-  return { deps, calls };
+  return deps;
 }
 
-// UNIVERSAL PARSER
+// MAIN
 export function parseUniversal(
   content: string,
   file: string
@@ -119,56 +149,29 @@ export function parseUniversal(
 
   const clean = stripComments(content);
 
-  // ASTRO FRONTMATTER
+  /* ---------- ASTRO FRONTMATTER ---------- */
   const fm = clean.match(/^---([\s\S]*?)---/);
   if (fm?.[1]) {
     parts.push(fm[1]);
   }
 
-  // <script src="">
-  const scriptSrc = clean.matchAll(
-    /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g
-  );
-
-  for (const s of scriptSrc) {
-    const src = s[1];
-
-    const resolved = src.startsWith("/")
-      ? path.resolve(process.cwd(), "." + src)
-      : path.resolve(path.dirname(file), src);
-
-    deps.push(resolved);
-  }
-
-  // INLINE <script>
-  const scripts = clean.matchAll(
-    /<script\b([^>]*)>([\s\S]*?)<\/script>/g
-  );
-
-  for (const m of scripts) {
-    if (m[2].trim()) {
-      parts.push(m[2]);
-    }
-  }
+  /* ---------- SCRIPTS ---------- */
+  const { scripts, deps: scriptDeps, noScripts } =
+    extractScripts(clean, file);
 
-  // TEMPLATE PART
-  const noScripts = clean.replace(
-    /<script[\s\S]*?<\/script>/g,
-    ""
-  );
+  parts.push(...scripts);
+  deps.push(...scriptDeps);
 
-  // handlers
+  /* ---------- HANDLERS ---------- */
   parts.push(...extractHTMLHandlers(noScripts));
   parts.push(...extractVueHandlers(noScripts));
   parts.push(...extractSvelteHandlers(noScripts));
 
-  // JSX / Astro / Vue expressions
-  parts.push(...extractJSExpressions(clean));
+  /* ---------- JSX / TEMPLATE ---------- */
+  parts.push(...extractBracedExpressions(clean));
 
-  // dynamic imports
-  const dyn = extractDynamicImports(clean, file);
-  deps.push(...dyn.deps);
-  parts.push(...dyn.calls);
+  /* ---------- IMPORTS ---------- */
+  deps.push(...extractDynamicImports(clean, file));
 
   return {
     code: [...new Set(parts)].join("\n"),

package/tests/run.ts

@@ -40,7 +40,6 @@ function ensureTestConfig(dir: string) {
     events: [],
     wrappers: [],
     functionWrappers: [],
-    aliases: {},
     sync: {
       include: [
         "**/*.{ts,tsx,js,jsx,vue,svelte,astro}"

package/dist/engine/trackingDetector.js

@@ -1,17 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTrackingCall = isTrackingCall;
-const typescript_1 = __importDefault(require("typescript"));
-function isTrackingCall(node) {
-    const expr = node.expression;
-    if (typescript_1.default.isIdentifier(expr)) {
-        return expr.text === "track";
-    }
-    if (typescript_1.default.isPropertyAccessExpression(expr)) {
-        return expr.name.text === "track";
-    }
-    return false;
-}

package/src/engine/trackingDetector.ts

@@ -1,17 +0,0 @@
-import ts from "typescript";
-
-export function isTrackingCall(
-  node: ts.CallExpression
-): boolean {
-  const expr = node.expression;
-
-  if (ts.isIdentifier(expr)) {
-    return expr.text === "track";
-  }
-
-  if (ts.isPropertyAccessExpression(expr)) {
-    return expr.name.text === "track";
-  }
-
-  return false;
-}