@flisk/analyze-tracking 0.8.0 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flisk/analyze-tracking",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Analyzes tracking code in a project and generates data schemas",
   "main": "src/index.js",
   "bin": {

package/src/analyze/index.js

@@ -4,7 +4,7 @@
  */
 
 const path = require('path');
-const ts = require('typescript');
+
 const { parseCustomFunctionSignature } = require('./utils/customFunctionParser');
 const { getAllFiles } = require('../utils/fileProcessor');
 const { analyzeJsFile } = require('./javascript');
@@ -19,11 +19,6 @@ async function analyzeDirectory(dirPath, customFunctions) {
   const customFunctionSignatures = (customFunctions && customFunctions?.length > 0) ? customFunctions.map(parseCustomFunctionSignature) : null;
 
   const files = getAllFiles(dirPath);
-  const tsFiles = files.filter(file => /\.(tsx?)$/.test(file));
-  const tsProgram = ts.createProgram(tsFiles, {
-    target: ts.ScriptTarget.ESNext,
-    module: ts.ModuleKind.CommonJS,
-  });
 
   for (const file of files) {
     let events = [];
@@ -37,7 +32,8 @@ async function analyzeDirectory(dirPath, customFunctions) {
     if (isJsFile) {
       events = analyzeJsFile(file, customFunctionSignatures);
     } else if (isTsFile) {
-      events = analyzeTsFile(file, tsProgram, customFunctionSignatures);
+      // Pass null program so analyzeTsFile will create a per-file program using the file's nearest tsconfig.json
+      events = analyzeTsFile(file, null, customFunctionSignatures);
     } else if (isPythonFile) {
       events = await analyzePythonFile(file, customFunctionSignatures);
     } else if (isRubyFile) {

package/src/analyze/javascript/extractors/event-extractor.js

@@ -28,29 +28,31 @@ const EXTRACTION_STRATEGIES = {
  * Extracts event information from a CallExpression node
  * @param {Object} node - AST CallExpression node
  * @param {string} source - Analytics provider source
+ * @param {Object} constantMap - Collected constant map
  * @param {Object} customConfig - Parsed custom function configuration
  * @returns {EventData} Extracted event data
  */
-function extractEventData(node, source, customConfig) {
+function extractEventData(node, source, constantMap = {}, customConfig) {
   const strategy = EXTRACTION_STRATEGIES[source] || EXTRACTION_STRATEGIES.default;
   if (source === 'custom') {
-    return strategy(node, customConfig);
+    return strategy(node, constantMap, customConfig);
   }
-  return strategy(node);
+  return strategy(node, constantMap);
 }
 
 /**
  * Extracts Google Analytics event data
  * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
  * @returns {EventData}
  */
-function extractGoogleAnalyticsEvent(node) {
+function extractGoogleAnalyticsEvent(node, constantMap) {
   if (!node.arguments || node.arguments.length < 3) {
     return { eventName: null, propertiesNode: null };
   }
 
   // gtag('event', 'event_name', { properties })
-  const eventName = getStringValue(node.arguments[1]);
+  const eventName = getStringValue(node.arguments[1], constantMap);
   const propertiesNode = node.arguments[2];
 
   return { eventName, propertiesNode };
@@ -59,9 +61,10 @@ function extractGoogleAnalyticsEvent(node) {
 /**
  * Extracts Snowplow event data
  * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
  * @returns {EventData}
  */
-function extractSnowplowEvent(node) {
+function extractSnowplowEvent(node, constantMap) {
   if (!node.arguments || node.arguments.length === 0) {
     return { eventName: null, propertiesNode: null };
   }
@@ -75,7 +78,7 @@ function extractSnowplowEvent(node) {
     
     if (structEventArg.type === NODE_TYPES.OBJECT_EXPRESSION) {
       const actionProperty = findPropertyByKey(structEventArg, 'action');
-      const eventName = actionProperty ? getStringValue(actionProperty.value) : null;
+      const eventName = actionProperty ? getStringValue(actionProperty.value, constantMap) : null;
       
       return { eventName, propertiesNode: structEventArg };
     }
@@ -87,15 +90,16 @@ function extractSnowplowEvent(node) {
 /**
  * Extracts mParticle event data
  * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
  * @returns {EventData}
  */
-function extractMparticleEvent(node) {
+function extractMparticleEvent(node, constantMap) {
   if (!node.arguments || node.arguments.length < 3) {
     return { eventName: null, propertiesNode: null };
   }
 
   // mParticle.logEvent('event_name', mParticle.EventType.Navigation, { properties })
-  const eventName = getStringValue(node.arguments[0]);
+  const eventName = getStringValue(node.arguments[0], constantMap);
   const propertiesNode = node.arguments[2];
 
   return { eventName, propertiesNode };
@@ -104,15 +108,16 @@ function extractMparticleEvent(node) {
 /**
  * Default event extraction for standard providers
  * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
  * @returns {EventData}
  */
-function extractDefaultEvent(node) {
+function extractDefaultEvent(node, constantMap) {
   if (!node.arguments || node.arguments.length < 2) {
     return { eventName: null, propertiesNode: null };
   }
 
   // provider.track('event_name', { properties })
-  const eventName = getStringValue(node.arguments[0]);
+  const eventName = getStringValue(node.arguments[0], constantMap);
   const propertiesNode = node.arguments[1];
 
   return { eventName, propertiesNode };
@@ -121,16 +126,17 @@ function extractDefaultEvent(node) {
 /**
  * Extracts Custom function event data according to signature
  * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
  * @param {Object} customConfig - Parsed custom function configuration
  * @returns {EventData & {extraArgs:Object}} event data plus extra args map
  */
-function extractCustomEvent(node, customConfig) {
+function extractCustomEvent(node, constantMap, customConfig) {
   const args = node.arguments || [];
 
   const eventArg = args[customConfig?.eventIndex ?? 0];
   const propertiesArg = args[customConfig?.propertiesIndex ?? 1];
 
-  const eventName = getStringValue(eventArg);
+  const eventName = getStringValue(eventArg, constantMap);
 
   const extraArgs = {};
   if (customConfig && customConfig.extraParams) {
@@ -197,13 +203,17 @@ function processEventData(eventData, source, filePath, line, functionName, custo
 /**
  * Gets string value from an AST node
  * @param {Object} node - AST node
+ * @param {Object} constantMap - Collected constant map
  * @returns {string|null} String value or null
  */
-function getStringValue(node) {
+function getStringValue(node, constantMap = {}) {
   if (!node) return null;
   if (node.type === NODE_TYPES.LITERAL && typeof node.value === 'string') {
     return node.value;
   }
+  if (node.type === NODE_TYPES.MEMBER_EXPRESSION) {
+    return resolveMemberExpressionToString(node, constantMap);
+  }
   return null;
 }
 
@@ -240,6 +250,26 @@ function inferNodeValueType(node) {
   }
 }
 
+// Helper to resolve MemberExpression (CONST.KEY) to string using collected constant map
+function resolveMemberExpressionToString(node, constantMap) {
+  if (!node || node.type !== NODE_TYPES.MEMBER_EXPRESSION) return null;
+  if (node.computed) return null; // Only support dot notation
+
+  const object = node.object;
+  const property = node.property;
+
+  if (object.type !== NODE_TYPES.IDENTIFIER) return null;
+  if (property.type !== NODE_TYPES.IDENTIFIER) return null;
+
+  const objName = object.name;
+  const propName = property.name;
+
+  if (constantMap && constantMap[objName] && typeof constantMap[objName][propName] === 'string') {
+    return constantMap[objName][propName];
+  }
+  return null;
+}
+
 module.exports = {
   extractEventData,
   processEventData

package/src/analyze/javascript/parser.js

@@ -120,6 +120,57 @@ function nodeMatchesCustomFunction(node, fnName) {
   return false;
 }
 
+// -----------------------------------------------------------------------------
+// Utility – collect constants defined as plain objects or Object.freeze({...})
+// -----------------------------------------------------------------------------
+function collectConstantStringMap(ast) {
+  const map = {};
+
+  walk.simple(ast, {
+    VariableDeclaration(node) {
+      // Only consider const declarations
+      if (node.kind !== 'const') return;
+      node.declarations.forEach(decl => {
+        if (decl.id.type !== NODE_TYPES.IDENTIFIER || !decl.init) return;
+        const name = decl.id.name;
+        let objLiteral = null;
+
+        if (decl.init.type === NODE_TYPES.OBJECT_EXPRESSION) {
+          objLiteral = decl.init;
+        } else if (decl.init.type === NODE_TYPES.CALL_EXPRESSION) {
+          // Check for Object.freeze({...})
+          const callee = decl.init.callee;
+          if (
+            callee &&
+            callee.type === NODE_TYPES.MEMBER_EXPRESSION &&
+            callee.object.type === NODE_TYPES.IDENTIFIER &&
+            callee.object.name === 'Object' &&
+            callee.property.type === NODE_TYPES.IDENTIFIER &&
+            callee.property.name === 'freeze' &&
+            decl.init.arguments.length > 0 &&
+            decl.init.arguments[0].type === NODE_TYPES.OBJECT_EXPRESSION
+          ) {
+            objLiteral = decl.init.arguments[0];
+          }
+        }
+
+        if (objLiteral) {
+          map[name] = {};
+          objLiteral.properties.forEach(prop => {
+            if (!prop.key || !prop.value) return;
+            const keyName = prop.key.name || prop.key.value;
+            if (prop.value.type === NODE_TYPES.LITERAL && typeof prop.value.value === 'string') {
+              map[name][keyName] = prop.value.value;
+            }
+          });
+        }
+      });
+    }
+  });
+
+  return map;
+}
+
 /**
  * Walk the AST once and find tracking events for built-in providers plus any number of custom
  * function configurations. This avoids the previous O(n * customConfigs) behaviour.
@@ -132,6 +183,9 @@ function nodeMatchesCustomFunction(node, fnName) {
 function findTrackingEvents(ast, filePath, customConfigs = []) {
   const events = [];
 
+  // Collect constant mappings once per file
+  const constantMap = collectConstantStringMap(ast);
+
   walk.ancestor(ast, {
     [NODE_TYPES.CALL_EXPRESSION]: (node, ancestors) => {
       try {
@@ -148,12 +202,10 @@ function findTrackingEvents(ast, filePath, customConfigs = []) {
         }
 
         if (matchedCustomConfig) {
-          // Force source to 'custom' and use matched config
-          const event = extractTrackingEvent(node, ancestors, filePath, matchedCustomConfig);
+          const event = extractTrackingEvent(node, ancestors, filePath, constantMap, matchedCustomConfig);
           if (event) events.push(event);
         } else {
-          // Let built-in detector figure out source (pass undefined customFunction)
-          const event = extractTrackingEvent(node, ancestors, filePath, null);
+          const event = extractTrackingEvent(node, ancestors, filePath, constantMap, null);
           if (event) events.push(event);
         }
       } catch (error) {
@@ -170,24 +222,18 @@ function findTrackingEvents(ast, filePath, customConfigs = []) {
  * @param {Object} node - CallExpression node
  * @param {Array<Object>} ancestors - Ancestor nodes
  * @param {string} filePath - File path
+ * @param {Object} constantMap - Constant string map
  * @param {Object} [customConfig] - Custom function configuration object
  * @returns {Object|null} Extracted event or null
  */
-function extractTrackingEvent(node, ancestors, filePath, customConfig) {
-  // Detect the analytics source
+function extractTrackingEvent(node, ancestors, filePath, constantMap, customConfig) {
   const source = detectAnalyticsSource(node, customConfig?.functionName);
   if (source === 'unknown') {
     return null;
   }
-
-  // Extract event data based on the source
-  const eventData = extractEventData(node, source, customConfig);
-
-  // Get location and context information
+  const eventData = extractEventData(node, source, constantMap, customConfig);
   const line = node.loc.start.line;
   const functionName = findWrappingFunction(node, ancestors);
-
-  // Process the event data into final format
   return processEventData(eventData, source, filePath, line, functionName, customConfig);
 }
 

package/src/analyze/ruby/extractors.js

@@ -4,15 +4,17 @@
  */
 
 const { getValueType } = require('./types');
+const prismPromise = import('@ruby/prism');
 
 /**
  * Extracts the event name from a tracking call based on the source
  * @param {Object} node - The AST CallNode
  * @param {string} source - The detected analytics source
  * @param {Object} customConfig - Custom configuration for custom functions
+ * @param {Object} constantMap - Map of constants to resolve constant paths
  * @returns {string|null} - The extracted event name or null
  */
-function extractEventName(node, source, customConfig = null) {
+async function extractEventName(node, source, customConfig = null, constantMap = {}) {
   if (source === 'segment' || source === 'rudderstack') {
     // Both Segment and Rudderstack use the same format
     const params = node.arguments_?.arguments_?.[0]?.elements;
@@ -62,8 +64,33 @@ function extractEventName(node, source, customConfig = null) {
     }
 
     const eventArg = args[customConfig.eventIndex];
-    if (eventArg?.unescaped?.value) {
-      return eventArg.unescaped.value;
+    if (eventArg) {
+      // String literal
+      if (eventArg.unescaped?.value) {
+        return eventArg.unescaped.value;
+      }
+
+      // Constant references
+      const { ConstantReadNode, ConstantPathNode } = await prismPromise;
+      const buildConstPath = (n) => {
+        if (!n) return '';
+        if (n instanceof ConstantReadNode) return n.name;
+        if (n instanceof ConstantPathNode) {
+          const parent = buildConstPath(n.parent);
+          return parent ? `${parent}::${n.name}` : n.name;
+        }
+        return '';
+      };
+
+      if (eventArg instanceof ConstantReadNode) {
+        const name = eventArg.name;
+        // Try to resolve with current constant map, else return name
+        return constantMap[name] || name;
+      }
+      if (eventArg instanceof ConstantPathNode) {
+        const pathStr = buildConstPath(eventArg);
+        return constantMap[pathStr] || pathStr;
+      }
     }
     return null;
   }
@@ -79,7 +106,7 @@ function extractEventName(node, source, customConfig = null) {
  * @returns {Object|null} - The extracted properties or null
  */
 async function extractProperties(node, source, customConfig = null) {
-  const { HashNode, ArrayNode } = await import('@ruby/prism');
+  const { HashNode, ArrayNode } = await prismPromise;
 
   if (source === 'segment' || source === 'rudderstack') {
     // Both Segment and Rudderstack use the same format
@@ -235,7 +262,7 @@ async function extractProperties(node, source, customConfig = null) {
  * @returns {Object} - The extracted properties
  */
 async function extractHashProperties(hashNode) {
-  const { AssocNode, HashNode, ArrayNode } = await import('@ruby/prism');
+  const { AssocNode, HashNode, ArrayNode } = await prismPromise;
   const properties = {};
   
   for (const element of hashNode.elements) {
@@ -278,7 +305,7 @@ async function extractHashProperties(hashNode) {
  * @returns {Object} - Type information for array items
  */
 async function extractArrayItemProperties(arrayNode) {
-  const { HashNode } = await import('@ruby/prism');
+  const { HashNode } = await prismPromise;
 
   if (arrayNode.elements.length === 0) {
     return { type: 'any' };

package/src/analyze/ruby/index.js

@@ -4,11 +4,162 @@
  */
 
 const fs = require('fs');
+const path = require('path');
 const TrackingVisitor = require('./visitor');
 
 // Lazy-loaded parse function from Ruby Prism
 let parse = null;
 
+/**
+ * Extracts the string literal value from an AST node, ignoring a trailing `.freeze` call.
+ * Supports:
+ *   - StringNode
+ *   - CallNode with receiver StringNode and method `freeze`
+ *
+ * @param {import('@ruby/prism').PrismNode} node
+ * @returns {string|null}
+ */
+async function extractStringLiteral(node) {
+  if (!node) return null;
+
+  const {
+    StringNode,
+    CallNode
+  } = await import('@ruby/prism');
+
+  if (node instanceof StringNode) {
+    return node.unescaped?.value ?? null;
+  }
+
+  // Handle "_Section".freeze pattern
+  if (node instanceof CallNode && node.name === 'freeze' && node.receiver) {
+    return extractStringLiteral(node.receiver);
+  }
+
+  return null;
+}
+
+/**
+ * Recursively traverses an AST to collect constant assignments and build a map
+ * of fully-qualified constant names (e.g. "TelemetryHelper::FINISHED_SECTION")
+ * to their string literal values.
+ *
+ * @param {import('@ruby/prism').PrismNode} node - current AST node
+ * @param {string[]} namespaceStack - stack of module/class names
+ * @param {Object} constantMap - accumulator map of constant path -> string value
+ */
+async function collectConstants(node, namespaceStack, constantMap) {
+  if (!node) return;
+
+  const {
+    ModuleNode,
+    ClassNode,
+    StatementsNode,
+    ConstantWriteNode,
+    ConstantPathWriteNode,
+    ConstantPathNode
+  } = await import('@ruby/prism');
+
+  // Helper to build constant path from ConstantPathNode
+  const buildConstPath = (pathNode) => {
+    if (!pathNode) return '';
+    if (pathNode.type === 'ConstantReadNode') {
+      return pathNode.name;
+    }
+    if (pathNode.type === 'ConstantPathNode') {
+      const parent = buildConstPath(pathNode.parent);
+      return parent ? `${parent}::${pathNode.name}` : pathNode.name;
+    }
+    return '';
+  };
+
+  // Process constant assignments
+  if (node instanceof ConstantWriteNode) {
+    const fullName = [...namespaceStack, node.name].join('::');
+    const literal = await extractStringLiteral(node.value);
+    if (literal !== null) {
+      constantMap[fullName] = literal;
+    }
+  } else if (node instanceof ConstantPathWriteNode) {
+    const fullName = buildConstPath(node.target);
+    const literal = await extractStringLiteral(node.value);
+    if (fullName && literal !== null) {
+      constantMap[fullName] = literal;
+    }
+  }
+
+  // Recurse into children depending on node type
+  if (node instanceof ModuleNode || node instanceof ClassNode) {
+    // Enter namespace
+    const name = node.constantPath?.name || node.name; // ModuleNode has constantPath
+    const childNamespaceStack = name ? [...namespaceStack, name] : namespaceStack;
+
+    if (node.body) {
+      await collectConstants(node.body, childNamespaceStack, constantMap);
+    }
+    return;
+  }
+
+  // Generic traversal for other nodes
+  if (node instanceof StatementsNode) {
+    for (const child of node.body) {
+      await collectConstants(child, namespaceStack, constantMap);
+    }
+    return;
+  }
+
+  // Fallback: iterate over enumerable properties to find nested nodes
+  for (const key of Object.keys(node)) {
+    const val = node[key];
+    if (!val) continue;
+
+    const traverseChild = async (child) => {
+      if (child && typeof child === 'object' && (child.location || child.constructor?.name?.endsWith('Node'))) {
+        await collectConstants(child, namespaceStack, constantMap);
+      }
+    };
+
+    if (Array.isArray(val)) {
+      for (const c of val) {
+        await traverseChild(c);
+      }
+    } else {
+      await traverseChild(val);
+    }
+  }
+}
+
+/**
+ * Builds a map of constant names to their literal string values for all .rb
+ * files in the given directory. This is a best-effort resolver intended for
+ * test fixtures and small projects and is not a fully-fledged Ruby constant
+ * resolver.
+ *
+ * @param {string} directory
+ * @returns {Promise<Object<string,string>>}
+ */
+async function buildConstantMapForDirectory(directory) {
+  const constantMap = {};
+
+  if (!fs.existsSync(directory)) return constantMap;
+
+  const files = fs.readdirSync(directory).filter(f => f.endsWith('.rb'));
+
+  for (const file of files) {
+    const fullPath = path.join(directory, file);
+    try {
+      const content = fs.readFileSync(fullPath, 'utf8');
+      const ast = await parse(content);
+      await collectConstants(ast.value, [], constantMap);
+    } catch (err) {
+      // Ignore parse errors for unrelated files
+      continue;
+    }
+  }
+
+  return constantMap;
+}
+
 /**
  * Analyzes a Ruby file for analytics tracking calls
  * @param {string} filePath - Path to the Ruby file to analyze
@@ -27,6 +178,10 @@ async function analyzeRubyFile(filePath, customFunctionSignatures = null) {
     // Read the file content
     const code = fs.readFileSync(filePath, 'utf8');
 
+    // Build constant map for current directory (sibling .rb files)
+    const currentDir = path.dirname(filePath);
+    const constantMap = await buildConstantMapForDirectory(currentDir);
+
     // Parse the Ruby code into an AST once
     let ast;
     try {
@@ -36,8 +191,8 @@ async function analyzeRubyFile(filePath, customFunctionSignatures = null) {
       return [];
     }
 
-    // Single visitor pass covering all custom configs
-    const visitor = new TrackingVisitor(code, filePath, customFunctionSignatures || []);
+    // Single visitor pass covering all custom configs, with constant map for resolution
+    const visitor = new TrackingVisitor(code, filePath, customFunctionSignatures || [], constantMap);
     const events = await visitor.analyze(ast);
 
     // Deduplicate events

package/src/analyze/ruby/traversal.js

@@ -46,7 +46,9 @@ async function traverseNode(node, nodeVisitor, ancestors = []) {
     AssocNode, 
     ClassNode, 
     ModuleNode,
-    CallNode
+    CallNode,
+    CaseNode,
+    WhenNode
   } = await import('@ruby/prism');
 
   if (!node) return;
@@ -89,7 +91,8 @@ async function traverseNode(node, nodeVisitor, ancestors = []) {
       await traverseNode(node.body, nodeVisitor, ancestors);
     }
   } else if (node instanceof ArgumentsNode) {
-    for (const arg of node.arguments) {
+    const argsList = node.arguments || [];
+    for (const arg of argsList) {
       await traverseNode(arg, nodeVisitor, ancestors);
     }
   } else if (node instanceof HashNode) {
@@ -99,6 +102,55 @@ async function traverseNode(node, nodeVisitor, ancestors = []) {
   } else if (node instanceof AssocNode) {
     await traverseNode(node.key, nodeVisitor, ancestors);
     await traverseNode(node.value, nodeVisitor, ancestors);
+  } else if (node instanceof CaseNode) {
+    // Traverse through each 'when' clause and the optional else clause
+    const whenClauses = node.whens || node.conditions || node.when_bodies || [];
+    for (const when of whenClauses) {
+      await traverseNode(when, nodeVisitor, ancestors);
+    }
+    if (node.else_) {
+      await traverseNode(node.else_, nodeVisitor, ancestors);
+    } else if (node.elseBody) {
+      await traverseNode(node.elseBody, nodeVisitor, ancestors);
+    }
+  } else if (node instanceof WhenNode) {
+    // Handle a single when clause: traverse its condition(s) and body
+    if (Array.isArray(node.conditions)) {
+      for (const cond of node.conditions) {
+        await traverseNode(cond, nodeVisitor, ancestors);
+      }
+    } else if (node.conditions) {
+      await traverseNode(node.conditions, nodeVisitor, ancestors);
+    }
+    if (node.statements) {
+      await traverseNode(node.statements, nodeVisitor, ancestors);
+    }
+    if (node.next) {
+      await traverseNode(node.next, nodeVisitor, ancestors);
+    }
+  } else {
+    // Generic fallback: iterate over enumerable properties to find nested nodes
+    for (const key of Object.keys(node)) {
+      const val = node[key];
+      if (!val) continue;
+
+      const visitChild = async (child) => {
+        if (child && typeof child === 'object') {
+          // crude check: Prism nodes have a `location` field
+          if (child.location || child.type || child.constructor?.name?.endsWith('Node')) {
+            await traverseNode(child, nodeVisitor, ancestors);
+          }
+        }
+      };
+
+      if (Array.isArray(val)) {
+        for (const c of val) {
+          await visitChild(c);
+        }
+      } else {
+        await visitChild(val);
+      }
+    }
   }
 
   ancestors.pop();

package/src/analyze/ruby/visitor.js

@@ -8,10 +8,11 @@ const { extractEventName, extractProperties } = require('./extractors');
 const { findWrappingFunction, traverseNode, getLineNumber } = require('./traversal');
 
 class TrackingVisitor {
-  constructor(code, filePath, customConfigs = []) {
+  constructor(code, filePath, customConfigs = [], constantMap = {}) {
     this.code = code;
     this.filePath = filePath;
     this.customConfigs = Array.isArray(customConfigs) ? customConfigs : [];
+    this.constantMap = constantMap || {};
     this.events = [];
   }
 
@@ -42,7 +43,7 @@ class TrackingVisitor {
 
       if (!source) return;
 
-      const eventName = extractEventName(node, source, matchedConfig);
+      const eventName = await extractEventName(node, source, matchedConfig, this.constantMap);
       if (!eventName) return;
 
       const line = getLineNumber(this.code, node.location);

package/src/analyze/typescript/extractors/event-extractor.js

@@ -296,27 +296,75 @@ function resolvePropertyAccessToString(node, checker, sourceFile) {
   try {
     // Get the symbol for the property access
     const symbol = checker.getSymbolAtLocation(node);
-    if (!symbol || !symbol.valueDeclaration) {
-      return null;
-    }
-    
-    // Check if it's a property assignment with a string initializer
-    if (ts.isPropertyAssignment(symbol.valueDeclaration) && 
-        symbol.valueDeclaration.initializer &&
-        ts.isStringLiteral(symbol.valueDeclaration.initializer)) {
-      return symbol.valueDeclaration.initializer.text;
+    if (symbol && symbol.valueDeclaration) {
+      // Check if it's a property assignment with a string initializer
+      if (ts.isPropertyAssignment(symbol.valueDeclaration) &&
+          symbol.valueDeclaration.initializer &&
+          ts.isStringLiteral(symbol.valueDeclaration.initializer)) {
+        return symbol.valueDeclaration.initializer.text;
+      }
+
+      // Check if it's a variable declaration property (string literal type)
+      if (ts.isPropertySignature(symbol.valueDeclaration) ||
+          ts.isMethodSignature(symbol.valueDeclaration)) {
+        const type = checker.getTypeAtLocation(node);
+        if (type && type.isStringLiteral && type.isStringLiteral()) {
+          return type.value;
+        }
+      }
     }
-    
-    // Check if it's a variable declaration property
-    if (ts.isPropertySignature(symbol.valueDeclaration) ||
-        ts.isMethodSignature(symbol.valueDeclaration)) {
-      // Try to get the type and see if it's a string literal type
-      const type = checker.getTypeAtLocation(node);
-      if (type.isStringLiteral && type.isStringLiteral()) {
-        return type.value;
+
+    // ---------------------------------------------------------------------
+    // Fallback – manually resolve patterns like:
+    //   const CONST = { KEY: 'value' };
+    //   const CONST = Object.freeze({ KEY: 'value' });
+    // And later used as CONST.KEY
+    // ---------------------------------------------------------------------
+    if (ts.isIdentifier(node.expression)) {
+      const objIdentifier = node.expression;
+      const initializer = resolveIdentifierToInitializer(checker, objIdentifier, sourceFile);
+      if (initializer) {
+        let objectLiteral = null;
+
+        // Handle direct object literal initializers
+        if (ts.isObjectLiteralExpression(initializer)) {
+          objectLiteral = initializer;
+        }
+        // Handle Object.freeze({ ... }) pattern
+        else if (ts.isCallExpression(initializer)) {
+          const callee = initializer.expression;
+          if (
+            ts.isPropertyAccessExpression(callee) &&
+            ts.isIdentifier(callee.expression) &&
+            callee.expression.escapedText === 'Object' &&
+            callee.name.escapedText === 'freeze' &&
+            initializer.arguments.length > 0 &&
+            ts.isObjectLiteralExpression(initializer.arguments[0])
+          ) {
+            objectLiteral = initializer.arguments[0];
+          }
+        }
+
+        if (objectLiteral) {
+          const propNode = findPropertyByKey(objectLiteral, node.name.escapedText || node.name.text);
+          if (propNode && propNode.initializer && ts.isStringLiteral(propNode.initializer)) {
+            return propNode.initializer.text;
+          }
+        }
       }
     }
-    
+
+    // Final fallback – use type information at location (works for imported Object.freeze constants)
+    try {
+      const t = checker.getTypeAtLocation(node);
+      if (t && t.isStringLiteral && typeof t.isStringLiteral === 'function' && t.isStringLiteral()) {
+        return t.value;
+      }
+      if (t && t.flags && (t.flags & ts.TypeFlags.StringLiteral)) {
+        return t.value;
+      }
+    } catch (_) {/* ignore */}
+
     return null;
   } catch (error) {
     return null;

package/src/analyze/typescript/parser.js

@@ -7,6 +7,7 @@ const ts = require('typescript');
 const { detectAnalyticsSource } = require('./detectors');
 const { extractEventData, processEventData } = require('./extractors');
 const { findWrappingFunction } = require('./utils/function-finder');
+const path = require('path');
 
 /**
  * Error thrown when TypeScript program cannot be created
@@ -44,16 +45,37 @@ function getProgram(filePath, existingProgram) {
   }
 
   try {
-    // Create a minimal program for single file analysis
-    const options = {
+    // Try to locate a tsconfig.json nearest to the file to inherit compiler options (important for path aliases)
+    const searchPath = path.dirname(filePath);
+    const configPath = ts.findConfigFile(searchPath, ts.sys.fileExists, 'tsconfig.json');
+
+    let compilerOptions = {
       target: ts.ScriptTarget.Latest,
       module: ts.ModuleKind.CommonJS,
       allowJs: true,
       checkJs: false,
-      noEmit: true
+      noEmit: true,
+      jsx: ts.JsxEmit.Preserve
     };
+    let rootNames = [filePath];
+
+    if (configPath) {
+      // Read and parse the tsconfig.json
+      const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
+      if (!readResult.error && readResult.config) {
+        const parseResult = ts.parseJsonConfigFileContent(
+          readResult.config,
+          ts.sys,
+          path.dirname(configPath)
+        );
+        if (!parseResult.errors || parseResult.errors.length === 0) {
+          compilerOptions = { ...compilerOptions, ...parseResult.options };
+          rootNames = parseResult.fileNames.length > 0 ? parseResult.fileNames : rootNames;
+        }
+      }
+    }
 
-    const program = ts.createProgram([filePath], options);
+    const program = ts.createProgram(rootNames, compilerOptions);
     return program;
   } catch (error) {
     throw new ProgramError(filePath, error);