@eventra_dev/eventra-cli 0.1.29 → 0.1.31

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 };