@eventra_dev/eventra-cli 0.1.25 → 0.1.26

package/dist/engine/languageService.js

@@ -12,20 +12,27 @@ class TSService {
     files = new Map();
     fileNames = new Set();
     service;
-    compilerOptions = {};
-    baseUrl = "";
-    paths = {};
+    compilerOptions;
+    baseUrl;
+    paths;
+    usage = new Map();
+    tick = 0;
+    MAX_FILES = 2000;
     constructor(root) {
         this.root = root;
         const configPath = typescript_1.default.findConfigFile(root, typescript_1.default.sys.fileExists, "tsconfig.json");
         let compilerOptions = {
             allowJs: true,
-            jsx: typescript_1.default.JsxEmit.Preserve,
+            jsx: typescript_1.default.JsxEmit.React,
+            jsxImportSource: "react",
             moduleResolution: typescript_1.default.ModuleResolutionKind.Node16,
             target: typescript_1.default.ScriptTarget.ESNext,
             esModuleInterop: true,
             allowSyntheticDefaultImports: true,
+            skipLibCheck: true,
         };
+        let baseUrl = root;
+        let paths = {};
         if (configPath) {
             const configFile = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
             const parsed = typescript_1.default.parseJsonConfigFileContent(configFile.config, typescript_1.default.sys, root);
@@ -33,46 +40,104 @@ class TSService {
                 ...compilerOptions,
                 ...parsed.options,
             };
-            this.paths = parsed.options.paths || {};
-            this.baseUrl = parsed.options.baseUrl
+            paths = parsed.options.paths || {};
+            baseUrl = parsed.options.baseUrl
                 ? path_1.default.resolve(root, parsed.options.baseUrl)
                 : root;
         }
-        else {
-            this.baseUrl = root;
-        }
         this.compilerOptions = compilerOptions;
+        this.baseUrl = baseUrl;
+        this.paths = paths;
         const host = {
-            getScriptFileNames: () => {
-                return [...new Set(this.fileNames)].sort((a, b) => a.localeCompare(b));
+            getScriptFileNames: () => Array.from(this.fileNames),
+            getScriptVersion: (file) => {
+                file = this.normalize(file);
+                return this.files.get(file)?.version.toString() ?? "0";
             },
-            getScriptVersion: (file) => this.files.get(file)?.version.toString() ?? "0",
             getScriptSnapshot: (file) => {
+                file = this.normalize(file);
                 const f = this.files.get(file);
                 if (f) {
+                    this.touch(file);
                     return typescript_1.default.ScriptSnapshot.fromString(f.content);
                 }
-                if (fs_1.default.existsSync(file)) {
-                    return typescript_1.default.ScriptSnapshot.fromString(fs_1.default.readFileSync(file, "utf-8"));
+                try {
+                    if (fs_1.default.existsSync(file)) {
+                        const content = fs_1.default.readFileSync(file, "utf-8");
+                        this.files.set(file, {
+                            content,
+                            version: 1,
+                        });
+                        this.fileNames.add(file);
+                        this.touch(file);
+                        this.evictIfNeeded();
+                        return typescript_1.default.ScriptSnapshot.fromString(content);
+                    }
                 }
-                return undefined;
+                catch { }
+                // fallback
+                return typescript_1.default.ScriptSnapshot.fromString("");
             },
             getCurrentDirectory: () => this.root,
             getCompilationSettings: () => this.compilerOptions,
             getDefaultLibFileName: (opts) => typescript_1.default.getDefaultLibFilePath(opts),
-            readFile: typescript_1.default.sys.readFile,
             fileExists: typescript_1.default.sys.fileExists,
+            readFile: typescript_1.default.sys.readFile,
             readDirectory: typescript_1.default.sys.readDirectory,
         };
         this.service = typescript_1.default.createLanguageService(host);
     }
+    // INTERNAL
+    normalize(file) {
+        return path_1.default.resolve(file).replace(/\\/g, "/");
+    }
+    touch(file) {
+        this.tick++;
+        this.usage.set(file, this.tick);
+    }
+    evictIfNeeded() {
+        if (this.fileNames.size <= this.MAX_FILES)
+            return;
+        let oldestFile = null;
+        let oldestTick = Infinity;
+        for (const f of this.fileNames) {
+            const t = this.usage.get(f) ?? 0;
+            if (t < oldestTick) {
+                oldestTick = t;
+                oldestFile = f;
+            }
+        }
+        if (oldestFile) {
+            this.files.delete(oldestFile);
+            this.fileNames.delete(oldestFile);
+            this.usage.delete(oldestFile);
+        }
+    }
+    ensureProgram() {
+        try {
+            this.service.getProgram();
+        }
+        catch { }
+    }
+    // PUBLIC API
     updateFile(file, content) {
+        file = this.normalize(file);
         const prev = this.files.get(file);
         this.files.set(file, {
             content,
             version: prev ? prev.version + 1 : 1,
         });
         this.fileNames.add(file);
+        this.touch(file);
+        this.evictIfNeeded();
+        this.ensureProgram();
+    }
+    removeFile(file) {
+        file = this.normalize(file);
+        this.files.delete(file);
+        this.fileNames.delete(file);
+        this.usage.delete(file);
+        this.ensureProgram();
     }
     getProgram() {
         return this.service.getProgram();
@@ -81,15 +146,13 @@ class TSService {
         return this.getProgram()?.getTypeChecker();
     }
     getSourceFile(file) {
+        file = this.normalize(file);
         return this.getProgram()?.getSourceFile(file);
     }
     getFileContent(file) {
+        file = this.normalize(file);
         return this.files.get(file)?.content;
     }
-    removeFile(file) {
-        this.files.delete(file);
-        this.fileNames.delete(file);
-    }
     getModuleResolutionConfig() {
         return {
             baseUrl: this.baseUrl,

package/dist/engine/resolver.js

@@ -11,7 +11,7 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         return { values: [], dynamic: true };
     }
     seen.add(node);
-    // param mapping
+    // PARAM MAPPING
     if (typescript_1.default.isIdentifier(node) && paramMap?.has(node.text)) {
         return resolveNodeValue(paramMap.get(node.text), checker, paramMap, seen);
     }
@@ -28,11 +28,14 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 values.push(...res.values);
             }
         }
-        return { values, dynamic: true };
+        return {
+            values: [...new Set(values)],
+            dynamic: true
+        };
     }
     // TEMPLATE
     if (typescript_1.default.isTemplateExpression(node)) {
-        let results = [node.head.text];
+        let results = node.head.text ? [node.head.text] : [""];
         for (const span of node.templateSpans) {
             const res = resolveNodeValue(span.expression, checker, paramMap, seen);
             if (res.values.length) {
@@ -59,16 +62,18 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         let symbol = checker.getSymbolAtLocation(node);
         if (!symbol)
             return { values: [], dynamic: true };
+        // INLINE FIRST
+        for (const decl of symbol.getDeclarations() ?? []) {
+            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
+            }
+        }
         // unwrap export
         symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
         if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
             symbol = checker.getAliasedSymbol(symbol);
         }
-        // inline variable
         for (const decl of symbol.getDeclarations() ?? []) {
-            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
-                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
-            }
             if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
                 if (typescript_1.default.isStringLiteral(decl.initializer)) {
                     return {
@@ -78,12 +83,12 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
-        // UNION TYPES
         const type = checker.getTypeAtLocation(node);
+        // UNION
         if (type.isUnion()) {
             const values = [];
             for (const t of type.types) {
-                if (t.isStringLiteral?.()) {
+                if (t.flags & typescript_1.default.TypeFlags.StringLiteral) {
                     values.push(t.value);
                 }
             }
@@ -91,13 +96,16 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 return { values, dynamic: false };
             }
         }
-        // TYPE FALLBACK (as const)
-        if (type.isStringLiteral?.()) {
-            return { values: [type.value], dynamic: false };
+        // STRING LITERAL TYPE
+        if (type.flags & typescript_1.default.TypeFlags.StringLiteral) {
+            return {
+                values: [type.value],
+                dynamic: false
+            };
         }
         return { values: [], dynamic: true };
     }
-    // PROPERTY ACCESS (obj.a.b)
+    // PROPERTY ACCESS
     if (typescript_1.default.isPropertyAccessExpression(node)) {
         const symbol = checker.getSymbolAtLocation(node);
         if (symbol) {
@@ -116,14 +124,12 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
-        // constant enum / readonly
         const constantValue = checker.getConstantValue(node);
         if (typeof constantValue === "string") {
             return { values: [constantValue], dynamic: false };
         }
-        // type fallback
         const type = checker.getTypeAtLocation(node);
-        if (type.isStringLiteral?.()) {
+        if (type.flags & typescript_1.default.TypeFlags.StringLiteral) {
             return {
                 values: [type.value],
                 dynamic: false,
@@ -149,16 +155,16 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
-        return { values: [], dynamic: true };
+        // fallback
+        return resolveNodeValue(node.name, checker, paramMap, seen);
     }
-    // ARRAY ACCESS (arr[0])
+    // ARRAY ACCESS
     if (typescript_1.default.isElementAccessExpression(node)) {
         const obj = resolveNodeValue(node.expression, checker, paramMap, seen);
         if (!node.argumentExpression) {
             return { values: obj.values, dynamic: true };
         }
         const index = resolveNodeValue(node.argumentExpression, checker, paramMap, seen);
-        // if index known
         if (index.values.length === 1) {
             const i = Number(index.values[0]);
             if (!Number.isNaN(i) && obj.values[i] !== undefined) {
@@ -168,7 +174,6 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 };
             }
         }
-        // fallback → dynamic
         return obj.values.length
             ? { values: obj.values, dynamic: true }
             : { values: [], dynamic: true };
@@ -185,7 +190,10 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 values.push(...res.values);
             }
         }
-        return { values, dynamic: true };
+        return {
+            values: [...new Set(values)],
+            dynamic: true
+        };
     }
     // BINARY ("btn_" + name)
     if (typescript_1.default.isBinaryExpression(node)) {

package/dist/engine/scanner.js

@@ -10,7 +10,7 @@ const callResolver_1 = require("./callResolver");
 const exportResolver_1 = require("./exportResolver");
 const functionAnalyzer_1 = require("./functionAnalyzer");
 const boundary_1 = require("./boundary");
-const TRACKING_NAMES = new Set(["track", "event", "capture", "send"]);
+const trackingDetector_1 = require("./trackingDetector");
 function getCallName(expr) {
     if (typescript_1.default.isIdentifier(expr))
         return expr.text;
@@ -25,6 +25,16 @@ function getJsxAttrName(name) {
         return name.name.text;
     return null;
 }
+// unwrap
+function unwrap(expr) {
+    while (typescript_1.default.isAsExpression(expr) ||
+        typescript_1.default.isParenthesizedExpression(expr) ||
+        typescript_1.default.isTypeAssertionExpression(expr) ||
+        typescript_1.default.isNonNullExpression(expr)) {
+        expr = expr.expression;
+    }
+    return expr;
+}
 function isValidEvent(v) {
     return (v &&
         v.length > 1 &&
@@ -32,70 +42,75 @@ function isValidEvent(v) {
         !v.includes(" ") &&
         /^[a-zA-Z0-9._:-]+$/.test(v));
 }
-function isPropUsedInTracking(fn, prop) {
+function isPropUsedInTracking(fn, checker, prop) {
     let found = false;
     function visit(node) {
         if (typescript_1.default.isCallExpression(node)) {
-            const name = getCallName(node.expression);
-            if (!TRACKING_NAMES.has(name)) {
+            if (!(0, trackingDetector_1.isTrackingCall)(node, checker)) {
                 typescript_1.default.forEachChild(node, visit);
                 return;
             }
             for (const arg of node.arguments) {
-                if ((typescript_1.default.isIdentifier(arg) && arg.text === prop) ||
-                    (typescript_1.default.isPropertyAccessExpression(arg) &&
-                        arg.name.text === prop)) {
+                const a = unwrap(arg);
+                if ((typescript_1.default.isIdentifier(a) && a.text === prop) ||
+                    (typescript_1.default.isPropertyAccessExpression(a) &&
+                        a.name.text === prop)) {
                     found = true;
                 }
             }
         }
         typescript_1.default.forEachChild(node, visit);
     }
-    visit(fn);
+    if (fn.body) {
+        visit(fn.body);
+    }
     return found;
 }
 function scanSource(source, checker, config, visited = new Set(), depth = 0, inheritedParamMap) {
     const events = new Set();
     const detectedFunctionWrappers = new Set();
     const detectedComponentWrappers = new Map();
-    if (depth > 5 || visited.has(source.fileName)) {
+    if (visited.has(source.fileName) ||
+        depth > 10 ||
+        visited.size > 200) {
         return { events, detectedFunctionWrappers, detectedComponentWrappers };
     }
     visited.add(source.fileName);
     function visit(node) {
         // CALL EXPRESSIONS
         if (typescript_1.default.isCallExpression(node)) {
-            const name = getCallName(node.expression);
+            const expr = unwrap(node.expression);
+            const name = getCallName(expr);
             const isKnownWrapper = config.functionWrappers.some(w => w.name === name);
-            let resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-            // fallback: tracker.track(...)
-            if (!resolvedFn && typescript_1.default.isPropertyAccessExpression(node.expression)) {
-                const symbol = checker.getSymbolAtLocation(node.expression.name);
-                if (symbol) {
-                    const decls = symbol.getDeclarations();
-                    if (decls?.length) {
-                        const d = decls[0];
-                        if (typescript_1.default.isMethodDeclaration(d) ||
-                            typescript_1.default.isFunctionDeclaration(d) ||
-                            typescript_1.default.isFunctionExpression(d) ||
-                            typescript_1.default.isArrowFunction(d)) {
-                            resolvedFn = d;
-                        }
-                    }
-                }
-            }
+            const isTrackingByType = (0, trackingDetector_1.isTrackingCall)(node, checker);
+            let resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(expr, checker);
             const isAutoWrapper = resolvedFn && (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn) !== null;
-            const isTracking = isKnownWrapper ||
-                TRACKING_NAMES.has(name) ||
-                name.startsWith("$") || // NUXT FIX
+            let isTracking = isKnownWrapper ||
+                isTrackingByType ||
+                name.startsWith("$") ||
                 (isAutoWrapper &&
                     resolvedFn &&
                     !(0, boundary_1.isExternalFile)(resolvedFn.getSourceFile().fileName));
+            // fallback
+            if (!isTracking) {
+                if (typescript_1.default.isPropertyAccessExpression(expr) &&
+                    expr.name.text === "track") {
+                    isTracking = true;
+                }
+                else if (typescript_1.default.isIdentifier(expr) &&
+                    expr.text === "track") {
+                    isTracking = true;
+                }
+            }
             if (!isTracking) {
                 typescript_1.default.forEachChild(node, visit);
                 return;
             }
-            if (!isKnownWrapper && isAutoWrapper && !TRACKING_NAMES.has(name)) {
+            // detect wrapper
+            if (!isKnownWrapper &&
+                isAutoWrapper &&
+                !isTrackingByType &&
+                !name.startsWith("track")) {
                 detectedFunctionWrappers.add(name);
             }
             const paramMap = new Map(inheritedParamMap ?? []);
@@ -114,26 +129,22 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
             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);
-                    if (res && res.values.length) {
-                        res.values.forEach(v => {
-                            if (isValidEvent(v))
-                                events.add(v);
-                        });
-                    }
+                    const res = (0, resolver_1.resolveNodeValue)(unwrap(node.arguments[idx]), checker, paramMap);
+                    res.values.forEach(v => {
+                        if (isValidEvent(v))
+                            events.add(v);
+                    });
                     handled = true;
                 }
             }
             // FALLBACK
             if (!handled) {
                 for (const arg of node.arguments) {
-                    const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
-                    if (res && res.values.length) {
-                        res.values.forEach(v => {
-                            if (isValidEvent(v))
-                                events.add(v);
-                        });
-                    }
+                    const res = (0, resolver_1.resolveNodeValue)(unwrap(arg), checker, paramMap);
+                    res.values.forEach(v => {
+                        if (isValidEvent(v))
+                            events.add(v);
+                    });
                 }
             }
             // CROSS FILE
@@ -183,7 +194,7 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
                     continue;
                 for (const el of param.name.elements) {
                     const prop = el.name.getText();
-                    const isEvent = isPropUsedInTracking(fn, prop) ||
+                    const isEvent = isPropUsedInTracking(fn, checker, prop) ||
                         config.wrappers.some(w => w.name === tagName && w.prop === prop);
                     if (!isEvent)
                         continue;

package/dist/engine/trackingDetector.js

@@ -0,0 +1,68 @@
+"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 isStringLike(type) {
+    return ((type.flags & typescript_1.default.TypeFlags.StringLike) !== 0 ||
+        (type.flags & typescript_1.default.TypeFlags.StringLiteral) !== 0);
+}
+function hasTrackLikeSignature(type, checker) {
+    const sigs = type.getCallSignatures();
+    for (const sig of sigs) {
+        const params = sig.getParameters();
+        if (!params.length)
+            continue;
+        const t = checker.getTypeOfSymbolAtLocation(params[0], params[0].valueDeclaration);
+        if (isStringLike(t)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isEventraLikeType(type, checker) {
+    const props = type.getProperties();
+    for (const prop of props) {
+        const decl = prop.valueDeclaration ?? prop.declarations?.[0];
+        if (!decl)
+            continue;
+        const t = checker.getTypeOfSymbolAtLocation(prop, decl);
+        if (hasTrackLikeSignature(t, checker)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isTrackingCall(node, checker) {
+    const expr = node.expression;
+    // fn(...)
+    if (typescript_1.default.isIdentifier(expr)) {
+        const type = checker.getTypeAtLocation(expr);
+        if (hasTrackLikeSignature(type, checker)) {
+            return true;
+        }
+    }
+    // obj.method(...)
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        const objType = checker.getTypeAtLocation(expr.expression);
+        // объект похож на tracker
+        if (isEventraLikeType(objType, checker)) {
+            return true;
+        }
+        // fallback
+        const methodType = checker.getTypeAtLocation(expr.name);
+        if (hasTrackLikeSignature(methodType, checker)) {
+            return true;
+        }
+    }
+    // obj["track"](...)
+    if (typescript_1.default.isElementAccessExpression(expr)) {
+        const objType = checker.getTypeAtLocation(expr.expression);
+        if (isEventraLikeType(objType, checker)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/utils/processFile.js

@@ -1,20 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFile = processFile;
-const path_1 = __importDefault(require("path"));
 const universal_1 = require("./universal");
 function processFile(file, content) {
     const { code, deps } = (0, universal_1.parseUniversal)(content, file);
-    const ext = path_1.default.extname(file);
-    const virtualFile = /\.(vue|svelte|astro|html)$/i.test(file)
-        ? file.replace(ext, "") + ".tsx"
-        : file;
     return {
         content: code || "",
-        virtualFile,
         deps: [...new Set(deps.filter(Boolean))],
     };
 }