@eventra_dev/eventra-cli 0.1.29 → 0.1.30

package/dist/utils/universal.js

@@ -5,73 +5,62 @@ 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)
+// Remove comments
 function stripComments(input) {
     return input
         .replace(/<!--[\s\S]*?-->/g, "")
         .replace(/\/\*[\s\S]*?\*\//g, "")
         .replace(/\/\/.*$/gm, "");
 }
-// Extract JS expressions inside {}
-function extractJS(input) {
+// Basic filter
+function looksLikeTracking(code) {
+    return /track/i.test(code);
+}
+// HTML inline handlers (onclick="")
+function extractHTMLHandlers(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;
+    const matches = input.matchAll(/\bon\w+\s*=\s*["']([^"']+)["']/g);
+    for (const m of matches) {
+        if (looksLikeTracking(m[1])) {
+            result.push(m[1]);
         }
-        if (ch === '"' || ch === "'" || ch === "`") {
-            inString = ch;
-            i++;
-            continue;
+    }
+    return result;
+}
+// Vue handlers (@click / v-on)
+function extractVueHandlers(input) {
+    const result = [];
+    const matches = input.matchAll(/(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g);
+    for (const m of matches) {
+        if (looksLikeTracking(m[1])) {
+            result.push(m[1]);
         }
-        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)) {
-                    result.push(expr);
-                }
-                i = j;
-                continue;
-            }
+    }
+    return result;
+}
+// Svelte handlers (on:click)
+function extractSvelteHandlers(input) {
+    const result = [];
+    const matches = input.matchAll(/\bon:[\w]+\s*=\s*{([^}]+)}/g);
+    for (const m of matches) {
+        if (looksLikeTracking(m[1])) {
+            result.push(m[1]);
         }
-        i++;
     }
     return result;
 }
-// Extract inline HTML handlers
-function extractInlineHandlers(input) {
+// JSX / template { ... }
+function extractJSExpressions(input) {
     const result = [];
-    const matches = input.matchAll(/\bon\w+\s*=\s*["']([^"']+)["']/g);
+    const matches = input.matchAll(/\{([^}]+)\}/g);
     for (const m of matches) {
-        const code = m[1];
-        if (/[a-zA-Z0-9_$]\s*\(/.test(code)) {
-            result.push(code);
+        if (looksLikeTracking(m[1])) {
+            result.push(m[1]);
         }
     }
     return result;
 }
-// Extract dynamic imports
+// dynamic import()
 function extractDynamicImports(input, file) {
     const deps = [];
     const calls = [];
@@ -82,14 +71,12 @@ function extractDynamicImports(input, file) {
             ? path_1.default.resolve(process.cwd(), "." + mod)
             : path_1.default.resolve(path_1.default.dirname(file), mod);
         deps.push(resolved);
-        calls.push(`import("${mod}")`);
+        if (looksLikeTracking(mod)) {
+            calls.push(`import("${mod}")`);
+        }
     }
     return { deps, calls };
 }
-// Filter only probable tracking-related code
-function isProbablyTracking(code) {
-    return /track|event|analytics/i.test(code);
-}
 // UNIVERSAL PARSER
 function parseUniversal(content, file) {
     const parts = [];
@@ -112,28 +99,22 @@ function parseUniversal(content, file) {
     // 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
+    // TEMPLATE PART
     const noScripts = clean.replace(/<script[\s\S]*?<\/script>/g, "");
-    // INLINE HANDLERS
-    parts.push(...extractInlineHandlers(noScripts).filter(isProbablyTracking));
-    // DYNAMIC IMPORTS
+    // 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.filter(isProbablyTracking));
-    // EXPRESSIONS
-    const extracted = extractJS(clean);
-    for (const e of extracted) {
-        if (isProbablyTracking(e)) {
-            parts.push(e + ";");
-        }
-    }
+    parts.push(...dyn.calls);
     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.30",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {

package/src/engine/functionAnalyzer.ts

@@ -8,31 +8,13 @@ export function findTrackParamIndex(
   fn.parameters.forEach((p, i) => {
     if (ts.isIdentifier(p.name)) {
       paramIndex.set(p.name.text, i);
-
-      // default param: (name = "x")
-      if (p.initializer && ts.isStringLiteral(p.initializer)) {
-        if (i === 0) return 0;
-      }
     }
   });
 
   let result: number | null = null;
 
-  function unwrap(node: ts.Expression): ts.Expression {
-    // as / parentheses
-    while (
-      ts.isAsExpression(node) ||
-      ts.isParenthesizedExpression(node)
-      ) {
-      node = node.expression;
-    }
-    return node;
-  }
-
-  function checkArg(arg: ts.Expression) {
-    arg = unwrap(arg);
-
-    // identifier → param
+  function check(arg: ts.Expression): boolean {
+    // identifier
     if (ts.isIdentifier(arg)) {
       const idx = paramIndex.get(arg.text);
       if (idx !== undefined) {
@@ -41,13 +23,7 @@ export function findTrackParamIndex(
       }
     }
 
-    // string literal
-    if (ts.isStringLiteral(arg)) {
-      result = 0;
-      return true;
-    }
-
-    // template `${name}`
+    // template
     if (ts.isTemplateExpression(arg)) {
       for (const span of arg.templateSpans) {
         if (ts.isIdentifier(span.expression)) {
@@ -58,8 +34,6 @@ export function findTrackParamIndex(
           }
         }
       }
-      result = 0;
-      return true;
     }
 
     // object { event: name }
@@ -67,21 +41,14 @@ export function findTrackParamIndex(
       for (const prop of arg.properties) {
         if (!ts.isPropertyAssignment(prop)) continue;
 
-        const name = prop.name.getText();
+        const key = prop.name.getText();
 
-        if (["event", "name", "type"].includes(name)) {
-          return checkArg(prop.initializer);
+        if (["event", "name", "type"].includes(key)) {
+          return check(prop.initializer);
         }
       }
     }
 
-    // call: String(name)
-    if (ts.isCallExpression(arg)) {
-      for (const inner of arg.arguments) {
-        if (checkArg(inner)) return true;
-      }
-    }
-
     return false;
   }
 
@@ -89,24 +56,17 @@ export function findTrackParamIndex(
     if (result !== null) return;
 
     if (ts.isCallExpression(node)) {
-      let isTrackCall = false;
+      const expr = node.expression;
 
-      if (ts.isPropertyAccessExpression(node.expression)) {
-        if (node.expression.name.text === "track") {
-          isTrackCall = true;
-        }
-      }
+      const isTrack =
+        (ts.isIdentifier(expr) && expr.text === "track") ||
+        (ts.isPropertyAccessExpression(expr) &&
+          expr.name.text === "track");
 
-      if (ts.isIdentifier(node.expression)) {
-        if (node.expression.text === "track") {
-          isTrackCall = true;
-        }
-      }
+      if (!isTrack) return;
 
-      if (isTrackCall) {
-        for (const arg of node.arguments) {
-          if (checkArg(arg)) return;
-        }
+      for (const arg of node.arguments) {
+        if (check(arg)) return;
       }
     }
 

package/src/engine/resolver.ts

@@ -12,13 +12,12 @@ export function resolveNodeValue(
   paramMap?: Map<string, ts.Expression>,
   seen = new Set<ts.Node>()
 ): ResolveResult {
-
   if (seen.has(node)) {
     return { values: [], dynamic: true };
   }
   seen.add(node);
 
-  // PARAM MAPPING
+  // PARAM MAP (wrapper args)
   if (ts.isIdentifier(node) && paramMap?.has(node.text)) {
     return resolveNodeValue(
       paramMap.get(node.text)!,
@@ -33,37 +32,23 @@ export function resolveNodeValue(
     return { values: [node.text], dynamic: false };
   }
 
-  // ARRAY
-  if (ts.isArrayLiteralExpression(node)) {
-    const values: string[] = [];
-
-    for (const el of node.elements) {
-      const res = resolveNodeValue(el, checker, paramMap, seen);
-      if (res.values.length) {
-        values.push(...res.values);
-      }
-    }
-
-    return {
-      values: [...new Set(values)],
-      dynamic: true
-    };
-  }
-
   // TEMPLATE
   if (ts.isTemplateExpression(node)) {
     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) {
-        results = results.flatMap(r =>
-          res.values.map(v => r + v)
-        );
-      } else {
-        results = results.map(r => r + "*");
-      }
+      const res = resolveNodeValue(
+        span.expression,
+        checker,
+        paramMap,
+        seen
+      );
+
+      results = results.flatMap(r =>
+        res.values.length
+          ? res.values.map(v => r + v)
+          : [r + "*"]
+      );
 
       results = results.map(r => r + span.literal.text);
     }
@@ -71,7 +56,7 @@ export function resolveNodeValue(
     return { values: results, dynamic: true };
   }
 
-  // CONDITIONAL
+  // CONDITIONAL (a ? b : c)
   if (ts.isConditionalExpression(node)) {
     const a = resolveNodeValue(node.whenTrue, checker, paramMap, seen);
     const b = resolveNodeValue(node.whenFalse, checker, paramMap, seen);
@@ -82,12 +67,69 @@ export function resolveNodeValue(
     };
   }
 
+  // OBJECT → берём ВСЕ значения (без привязки к ключам)
+  if (ts.isObjectLiteralExpression(node)) {
+    const values: string[] = [];
+
+    for (const prop of node.properties) {
+      if (!ts.isPropertyAssignment(prop)) continue;
+
+      const res = resolveNodeValue(
+        prop.initializer,
+        checker,
+        paramMap,
+        seen
+      );
+
+      values.push(...res.values);
+    }
+
+    return {
+      values: [...new Set(values)],
+      dynamic: true,
+    };
+  }
+
+  // ARRAY
+  if (ts.isArrayLiteralExpression(node)) {
+    const values: string[] = [];
+
+    for (const el of node.elements) {
+      const res = resolveNodeValue(el, checker, paramMap, seen);
+      values.push(...res.values);
+    }
+
+    return {
+      values: [...new Set(values)],
+      dynamic: true,
+    };
+  }
+
+  // BINARY CONCAT
+  if (ts.isBinaryExpression(node)) {
+    if (node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      const left = resolveNodeValue(node.left, checker, paramMap, seen);
+      const right = resolveNodeValue(node.right, checker, paramMap, seen);
+
+      return {
+        values: left.values.flatMap(l =>
+          right.values.length
+            ? right.values.map(r => l + r)
+            : [l + "*"]
+        ),
+        dynamic: true,
+      };
+    }
+  }
+
   // IDENTIFIER
   if (ts.isIdentifier(node)) {
     let symbol = checker.getSymbolAtLocation(node);
     if (!symbol) return { values: [], dynamic: true };
 
-    // INLINE FIRST
+    symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
+
+    // const VAR = "click"
     for (const decl of symbol.getDeclarations() ?? []) {
       if (ts.isVariableDeclaration(decl) && decl.initializer) {
         return resolveNodeValue(
@@ -97,16 +139,8 @@ export function resolveNodeValue(
           seen
         );
       }
-    }
 
-    // unwrap export
-    symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
-
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-      symbol = checker.getAliasedSymbol(symbol);
-    }
-
-    for (const decl of symbol.getDeclarations() ?? []) {
+      // enum
       if (ts.isEnumMember(decl) && decl.initializer) {
         if (ts.isStringLiteral(decl.initializer)) {
           return {
@@ -117,37 +151,11 @@ export function resolveNodeValue(
       }
     }
 
-    const type = checker.getTypeAtLocation(node);
-
-    // UNION
-    if (type.isUnion()) {
-      const values: string[] = [];
-
-      for (const t of type.types) {
-        if (t.flags & ts.TypeFlags.StringLiteral) {
-          values.push((t as ts.StringLiteralType).value);
-        }
-      }
-
-      if (values.length) {
-        return { values, dynamic: false };
-      }
-    }
-
-    // STRING LITERAL TYPE
-    if (type.flags & ts.TypeFlags.StringLiteral) {
-      return {
-        values: [(type as ts.StringLiteralType).value],
-        dynamic: false
-      };
-    }
-
     return { values: [], dynamic: true };
   }
 
-  // PROPERTY ACCESS
+  // PROPERTY ACCESS (ENUM / CONST)
   if (ts.isPropertyAccessExpression(node)) {
-
     const symbol = checker.getSymbolAtLocation(node);
 
     if (symbol) {
@@ -169,130 +177,21 @@ export function resolveNodeValue(
       }
     }
 
-    const constantValue = checker.getConstantValue(node as any);
-    if (typeof constantValue === "string") {
-      return { values: [constantValue], dynamic: false };
-    }
-
-    const type = checker.getTypeAtLocation(node);
-
-    if (type.flags & ts.TypeFlags.StringLiteral) {
-      return {
-        values: [(type as ts.StringLiteralType).value],
-        dynamic: false,
-      };
-    }
-
-    // object literal resolve
-    if (ts.isIdentifier(node.expression)) {
-      const objSymbol = checker.getSymbolAtLocation(node.expression);
-
-      if (objSymbol) {
-        for (const decl of objSymbol.getDeclarations() ?? []) {
-          if (
-            ts.isVariableDeclaration(decl) &&
-            decl.initializer &&
-            ts.isObjectLiteralExpression(decl.initializer)
-          ) {
-            for (const prop of decl.initializer.properties) {
-              if (!ts.isPropertyAssignment(prop)) continue;
-
-              const name = prop.name.getText();
-
-              if (name === node.name.text) {
-                return resolveNodeValue(
-                  prop.initializer,
-                  checker,
-                  paramMap,
-                  seen
-                );
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // fallback
-    return resolveNodeValue(node.name, checker, paramMap, seen);
-  }
-
-  // ARRAY ACCESS
-  if (ts.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.values.length === 1) {
-      const i = Number(index.values[0]);
-
-      if (!Number.isNaN(i) && obj.values[i] !== undefined) {
-        return {
-          values: [obj.values[i]],
-          dynamic: false,
-        };
-      }
-    }
-
-    return obj.values.length
-      ? { values: obj.values, dynamic: true }
-      : { values: [], dynamic: true };
+    return { values: [], dynamic: true };
   }
 
-  // OBJECT
-  if (ts.isObjectLiteralExpression(node)) {
+  // CALL → unwrap args
+  if (ts.isCallExpression(node)) {
     const values: string[] = [];
 
-    for (const prop of node.properties) {
-      if (!ts.isPropertyAssignment(prop)) continue;
-
-      const name = prop.name.getText();
-
-      if (["event", "name", "type"].includes(name)) {
-        const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
-        values.push(...res.values);
-      }
-    }
-
-    return {
-      values: [...new Set(values)],
-      dynamic: true
-    };
-  }
-
-  // BINARY ("btn_" + name)
-  if (ts.isBinaryExpression(node)) {
-    if (node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
-      const left = resolveNodeValue(node.left, checker, paramMap, seen);
-      const right = resolveNodeValue(node.right, checker, paramMap, seen);
-
-      if (!left.values.length) {
-        return { values: [], dynamic: true };
-      }
-
-      return {
-        values: left.values.flatMap(l =>
-          right.values.length
-            ? right.values.map(r => l + r)
-            : [l + "*"]
-        ),
-        dynamic: true,
-      };
+    for (const arg of node.arguments) {
+      const res = resolveNodeValue(arg, checker, paramMap, seen);
+      values.push(...res.values);
     }
-  }
 
-  // CALL → dynamic
-  if (ts.isCallExpression(node)) {
-    return { values: [], dynamic: true };
+    return values.length
+      ? { values, dynamic: true }
+      : { values: [], dynamic: true };
   }
 
   return { values: [], dynamic: true };