@eventra_dev/eventra-cli 0.1.29 → 0.1.31

package/dist/engine/scanner.js

@@ -7,10 +7,25 @@ exports.scanSource = scanSource;
 const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
-const exportResolver_1 = require("./exportResolver");
 const functionAnalyzer_1 = require("./functionAnalyzer");
+const exportResolver_1 = require("./exportResolver");
 const boundary_1 = require("./boundary");
-const trackingDetector_1 = require("./trackingDetector");
+// 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;
@@ -25,31 +40,104 @@ function isValidEvent(v) {
         !v.includes(" ") &&
         /^[a-zA-Z0-9._:-]+$/.test(v));
 }
-function resolveFunctionDeep(expr, checker) {
-    let fn = (0, callResolver_1.resolveFunctionFromCall)(expr, checker);
-    if (fn)
-        return fn;
-    let symbol = checker.getSymbolAtLocation(expr);
-    if (!symbol)
-        return null;
-    if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
-        symbol = checker.getAliasedSymbol(symbol);
+// 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, "*");
     }
-    const resolvedSymbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-    for (const decl of resolvedSymbol.getDeclarations() ?? []) {
-        if (typescript_1.default.isFunctionDeclaration(decl)) {
-            return decl;
+    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;
+            }
         }
-        if (typescript_1.default.isVariableDeclaration(decl) &&
-            decl.initializer &&
-            (typescript_1.default.isArrowFunction(decl.initializer) ||
-                typescript_1.default.isFunctionExpression(decl.initializer))) {
-            return decl.initializer;
+        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);
     }
-    return null;
+    if (fn.body)
+        visit(fn.body);
+    return result;
 }
-function scanSource(source, checker, config, visited = new Set(), depth = 0, inheritedParamMap) {
+// 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();
@@ -58,42 +146,107 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
     }
     visited.add(source.fileName);
     function visit(node) {
-        // CALL EXPRESSIONS
+        // 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 isTrackingByType = (0, trackingDetector_1.isTrackingCall)(node, checker);
-            const resolvedFn = resolveFunctionDeep(node.expression, checker);
-            const isAutoWrapper = resolvedFn && (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn) !== null;
-            let isTracking = isKnownWrapper ||
-                isTrackingByType ||
-                name.startsWith("$") ||
+            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" ||
+                isKnownWrapper ||
                 (isAutoWrapper &&
                     resolvedFn &&
-                    resolvedFn.getSourceFile &&
                     !(0, boundary_1.isExternalFile)(resolvedFn.getSourceFile().fileName));
-            if (!isTracking) {
-                if (typescript_1.default.isPropertyAccessExpression(node.expression) &&
-                    node.expression.name.text === "track") {
-                    isTracking = true;
-                }
-                else if (typescript_1.default.isIdentifier(node.expression) &&
-                    node.expression.text === "track") {
-                    isTracking = true;
-                }
-            }
             if (!isTracking) {
                 typescript_1.default.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 && typescript_1.default.isFunctionLike(resolvedFn)) {
                 resolvedFn.parameters.forEach((param, i) => {
@@ -105,23 +258,21 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
                     }
                 });
             }
-            // STRICT EVENT RESOLVE
             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 => {
+                    res.values.forEach((v) => {
                         if (isValidEvent(v))
                             events.add(v);
                     });
                 }
             }
-            // CROSS-FILE
             if (resolvedFn) {
-                const sf = resolvedFn.getSourceFile?.();
-                if (sf && !visited.has(sf.fileName)) {
-                    const res = scanSource(sf, checker, config, visited, depth + 1, paramMap);
-                    res.events.forEach(e => events.add(e));
+                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));
                 }
             }
         }

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,135 +5,132 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseUniversal = parseUniversal;
 const path_1 = __importDefault(require("path"));
-// Strip comments (HTML + JS)
+// SAFE COMMENT STRIP
 function stripComments(input) {
     return input
         .replace(/<!--[\s\S]*?-->/g, "")
-        .replace(/\/\*[\s\S]*?\*\//g, "")
-        .replace(/\/\/.*$/gm, "");
+        .replace(/\/\*[\s\S]*?\*\//g, "");
 }
-// Extract JS expressions inside {}
-function extractJS(input) {
+// TRACK FILTER
+function looksLikeTracking(code) {
+    return /\btrack\w*\s*\(/.test(code);
+}
+// SAFE {} PARSER
+function extractBracedExpressions(input) {
     const result = [];
-    let i = 0;
-    const len = input.length;
-    let inString = null;
-    let escape = false;
-    while (i < len) {
-        const ch = input[i];
-        if (inString) {
-            if (escape)
-                escape = false;
-            else if (ch === "\\")
-                escape = true;
-            else if (ch === inString)
-                inString = null;
-            i++;
-            continue;
-        }
-        if (ch === '"' || ch === "'" || ch === "`") {
-            inString = ch;
-            i++;
-            continue;
+    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++;
         }
-        if (ch === "{") {
-            let depth = 1;
-            let j = i + 1;
-            while (j < len && depth > 0) {
-                if (input[j] === "{")
-                    depth++;
-                else if (input[j] === "}")
-                    depth--;
-                j++;
-            }
-            if (depth === 0) {
-                const expr = input.slice(i + 1, j - 1).trim();
-                if (expr && /[a-zA-Z0-9_$]\s*\(/.test(expr)) {
+        else if (char === "}") {
+            depth--;
+            if (depth === 0 && start !== -1) {
+                const expr = input.slice(start, i);
+                if (looksLikeTracking(expr)) {
                     result.push(expr);
                 }
-                i = j;
-                continue;
+                start = -1;
             }
         }
-        i++;
     }
     return result;
 }
-// Extract inline HTML handlers
-function extractInlineHandlers(input) {
+// HTML handlers
+function extractHTMLHandlers(input) {
+    const result = [];
+    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
+function extractVueHandlers(input) {
     const result = [];
-    const matches = input.matchAll(/\bon\w+\s*=\s*["']([^"']+)["']/g);
-    for (const m of matches) {
-        const code = m[1];
-        if (/[a-zA-Z0-9_$]\s*\(/.test(code)) {
-            result.push(code);
+    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;
 }
-// Extract dynamic imports
+// SVELTE handlers
+function extractSvelteHandlers(input) {
+    const result = [];
+    const regex = /\bon:[\w]+\s*=\s*{([^}]+)}/g;
+    for (const m of input.matchAll(regex)) {
+        if (looksLikeTracking(m[1])) {
+            result.push(m[1]);
+        }
+    }
+    return result;
+}
+// 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]);
+        }
+    }
+    const noScripts = input.replace(scriptRegex, "");
+    return { scripts, deps, noScripts };
+}
+// 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);
-        calls.push(`import("${mod}")`);
     }
-    return { deps, calls };
+    return deps;
 }
-// Filter only probable tracking-related code
-function isProbablyTracking(code) {
-    return /track|event|analytics/i.test(code);
-}
-// 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) {
-        const attrs = m[1];
-        if (/type=["']application\/json/.test(attrs))
-            continue;
-        if (m[2].trim()) {
-            parts.push(m[2]);
-        }
-    }
-    // REMOVE SCRIPTS → TEMPLATE PART
-    const noScripts = clean.replace(/<script[\s\S]*?<\/script>/g, "");
-    // INLINE HANDLERS
-    parts.push(...extractInlineHandlers(noScripts).filter(isProbablyTracking));
-    // DYNAMIC IMPORTS
-    const dyn = extractDynamicImports(clean, file);
-    deps.push(...dyn.deps);
-    parts.push(...dyn.calls.filter(isProbablyTracking));
-    // EXPRESSIONS
-    const extracted = extractJS(clean);
-    for (const e of extracted) {
-        if (isProbablyTracking(e)) {
-            parts.push(e + ";");
-        }
-    }
+    /* ---------- 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 / 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.29",
+  "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);