@flisk/analyze-tracking 0.7.5 → 0.8.0

package/src/analyze/ruby/index.js

@@ -16,7 +16,7 @@ let parse = null;
  * @returns {Promise<Array>} Array of tracking events found in the file
  * @throws {Error} If the file cannot be read or parsed
  */
-async function analyzeRubyFile(filePath, customFunction) {
+async function analyzeRubyFile(filePath, customFunctionSignatures = null) {
   // Lazy load the Ruby Prism parser
   if (!parse) {
     const { loadPrism } = await import('@ruby/prism');
@@ -26,21 +26,28 @@ async function analyzeRubyFile(filePath, customFunction) {
   try {
     // Read the file content
     const code = fs.readFileSync(filePath, 'utf8');
-    
-    // Parse the Ruby code into an AST
+
+    // Parse the Ruby code into an AST once
     let ast;
     try {
       ast = await parse(code);
     } catch (parseError) {
       console.error(`Error parsing file ${filePath}:`, parseError.message);
-      return []; // Return empty events array if parsing fails
+      return [];
     }
 
-    // Create a visitor and analyze the AST
-    const visitor = new TrackingVisitor(code, filePath, customFunction);
+    // Single visitor pass covering all custom configs
+    const visitor = new TrackingVisitor(code, filePath, customFunctionSignatures || []);
     const events = await visitor.analyze(ast);
 
-    return events;
+    // Deduplicate events
+    const unique = new Map();
+    for (const evt of events) {
+      const key = `${evt.source}|${evt.eventName}|${evt.line}|${evt.functionName}`;
+      if (!unique.has(key)) unique.set(key, evt);
+    }
+
+    return Array.from(unique.values());
 
   } catch (fileError) {
     console.error(`Error reading or processing file ${filePath}:`, fileError.message);

package/src/analyze/ruby/visitor.js

@@ -8,10 +8,10 @@ const { extractEventName, extractProperties } = require('./extractors');
 const { findWrappingFunction, traverseNode, getLineNumber } = require('./traversal');
 
 class TrackingVisitor {
-  constructor(code, filePath, customFunction = null) {
+  constructor(code, filePath, customConfigs = []) {
     this.code = code;
     this.filePath = filePath;
-    this.customFunction = customFunction;
+    this.customConfigs = Array.isArray(customConfigs) ? customConfigs : [];
     this.events = [];
   }
 
@@ -22,10 +22,27 @@ class TrackingVisitor {
    */
   async processCallNode(node, ancestors) {
     try {
-      const source = detectSource(node, this.customFunction);
+      let matchedConfig = null;
+      let source = null;
+
+      // Try to match any custom config first
+      for (const cfg of this.customConfigs) {
+        if (!cfg) continue;
+        if (detectSource(node, cfg.functionName) === 'custom') {
+          matchedConfig = cfg;
+          source = 'custom';
+          break;
+        }
+      }
+
+      // If no custom match, attempt built-in providers
+      if (!source) {
+        source = detectSource(node, null);
+      }
+
       if (!source) return;
 
-      const eventName = extractEventName(node, source);
+      const eventName = extractEventName(node, source, matchedConfig);
       if (!eventName) return;
 
       const line = getLineNumber(this.code, node.location);
@@ -33,13 +50,13 @@ class TrackingVisitor {
       // For module-scoped custom functions, use the custom function name as the functionName
       // For simple custom functions, use the wrapping function name
       let functionName;
-      if (source === 'custom' && this.customFunction && this.customFunction.includes('.')) {
-        functionName = this.customFunction;
+      if (source === 'custom' && matchedConfig && matchedConfig.functionName.includes('.')) {
+        functionName = matchedConfig.functionName;
       } else {
         functionName = await findWrappingFunction(node, ancestors);
       }
       
-      const properties = await extractProperties(node, source);
+      const properties = await extractProperties(node, source, matchedConfig);
 
       this.events.push({
         eventName,

package/src/analyze/typescript/detectors/analytics-source.js

@@ -48,7 +48,10 @@ function isCustomFunction(node, customFunction) {
     ts.isPropertyAccessExpression(node.expression) ||
     ts.isCallExpression(node.expression) || // For chained calls like getTracker().track()
     ts.isElementAccessExpression(node.expression) || // For array/object access like trackers['analytics'].track()
-    (ts.isPropertyAccessExpression(node.expression?.expression) && ts.isThisExpression(node.expression.expression.expression)); // For class methods like this.analytics.track()
+    (node.expression?.expression && 
+     ts.isPropertyAccessExpression(node.expression.expression) && 
+     node.expression.expression.expression && 
+     ts.isThisExpression(node.expression.expression.expression)); // For class methods like this.analytics.track()
 
   return canBeCustomFunction && node.expression.getText() === customFunction;
 }

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

@@ -21,6 +21,7 @@ const EXTRACTION_STRATEGIES = {
   googleanalytics: extractGoogleAnalyticsEvent,
   snowplow: extractSnowplowEvent,
   mparticle: extractMparticleEvent,
+  custom: extractCustomEvent,
   default: extractDefaultEvent
 };
 
@@ -30,10 +31,14 @@ const EXTRACTION_STRATEGIES = {
  * @param {string} source - Analytics provider source
  * @param {Object} checker - TypeScript type checker
  * @param {Object} sourceFile - TypeScript source file
+ * @param {Object} customConfig - Custom configuration for custom extraction
  * @returns {EventData} Extracted event data
  */
-function extractEventData(node, source, checker, sourceFile) {
+function extractEventData(node, source, checker, sourceFile, customConfig) {
   const strategy = EXTRACTION_STRATEGIES[source] || EXTRACTION_STRATEGIES.default;
+  if (source === 'custom') {
+    return strategy(node, checker, sourceFile, customConfig);
+  }
   return strategy(node, checker, sourceFile);
 }
 
@@ -50,7 +55,7 @@ function extractGoogleAnalyticsEvent(node, checker, sourceFile) {
   }
 
   // gtag('event', 'event_name', { properties })
-  const eventName = getStringValue(node.arguments[1]);
+  const eventName = getStringValue(node.arguments[1], checker, sourceFile);
   const propertiesNode = node.arguments[2];
 
   return { eventName, propertiesNode };
@@ -79,7 +84,7 @@ function extractSnowplowEvent(node, checker, sourceFile) {
     const structEventArg = firstArg.arguments[0];
     if (ts.isObjectLiteralExpression(structEventArg)) {
       const actionProperty = findPropertyByKey(structEventArg, 'action');
-      const eventName = actionProperty ? getStringValue(actionProperty.initializer) : null;
+      const eventName = actionProperty ? getStringValue(actionProperty.initializer, checker, sourceFile) : null;
       return { eventName, propertiesNode: structEventArg };
     }
   }
@@ -93,7 +98,7 @@ function extractSnowplowEvent(node, checker, sourceFile) {
       const structEventArg = resolvedNode.arguments[0];
       if (ts.isObjectLiteralExpression(structEventArg)) {
         const actionProperty = findPropertyByKey(structEventArg, 'action');
-        const eventName = actionProperty ? getStringValue(actionProperty.initializer) : null;
+        const eventName = actionProperty ? getStringValue(actionProperty.initializer, checker, sourceFile) : null;
         return { eventName, propertiesNode: structEventArg };
       }
     }
@@ -115,12 +120,38 @@ function extractMparticleEvent(node, checker, sourceFile) {
   }
 
   // mParticle.logEvent('event_name', mParticle.EventType.Navigation, { properties })
-  const eventName = getStringValue(node.arguments[0]);
+  const eventName = getStringValue(node.arguments[0], checker, sourceFile);
   const propertiesNode = node.arguments[2];
 
   return { eventName, propertiesNode };
 }
 
+/**
+ * Custom extraction
+ * @param {Object} node - CallExpression node
+ * @param {Object} checker - TypeScript type checker
+ * @param {Object} sourceFile - TypeScript source file
+ * @param {Object} customConfig - Custom configuration for custom extraction
+ * @returns {EventData}
+ */
+function extractCustomEvent(node, checker, sourceFile, customConfig) {
+  const args = node.arguments || [];
+
+  const eventArg = args[customConfig?.eventIndex ?? 0];
+  const propertiesArg = args[customConfig?.propertiesIndex ?? 1];
+
+  const eventName = getStringValue(eventArg, checker, sourceFile);
+
+  const extraArgs = {};
+  if (customConfig && customConfig.extraParams) {
+    customConfig.extraParams.forEach(extra => {
+      extraArgs[extra.name] = args[extra.idx];
+    });
+  }
+
+  return { eventName, propertiesNode: propertiesArg, extraArgs };
+}
+
 /**
  * Default event extraction for standard providers
  * @param {Object} node - CallExpression node
@@ -134,7 +165,7 @@ function extractDefaultEvent(node, checker, sourceFile) {
   }
 
   // provider.track('event_name', { properties })
-  const eventName = getStringValue(node.arguments[0]);
+  const eventName = getStringValue(node.arguments[0], checker, sourceFile);
   const propertiesNode = node.arguments[1];
 
   return { eventName, propertiesNode };
@@ -149,9 +180,10 @@ function extractDefaultEvent(node, checker, sourceFile) {
  * @param {string} functionName - Containing function name
  * @param {Object} checker - TypeScript type checker
  * @param {Object} sourceFile - TypeScript source file
+ * @param {Object} customConfig - Custom configuration for custom extraction
  * @returns {Object|null} Processed event object or null
  */
-function processEventData(eventData, source, filePath, line, functionName, checker, sourceFile) {
+function processEventData(eventData, source, filePath, line, functionName, checker, sourceFile, customConfig) {
   const { eventName, propertiesNode } = eventData;
 
   if (!eventName || !propertiesNode) {
@@ -184,6 +216,37 @@ function processEventData(eventData, source, filePath, line, functionName, check
   // Clean up any unresolved type markers
   const cleanedProperties = cleanupProperties(properties);
 
+  // Handle custom extra params
+  if (source === 'custom' && customConfig && eventData.extraArgs) {
+    for (const [paramName, argNode] of Object.entries(eventData.extraArgs)) {
+      if (argNode && ts.isObjectLiteralExpression(argNode)) {
+        // Extract detailed properties from object literal expression
+        cleanedProperties[paramName] = {
+          type: 'object',
+          properties: extractProperties(checker, argNode)
+        };
+      } else if (argNode && ts.isIdentifier(argNode)) {
+        // Handle identifier references to objects
+        const resolvedNode = resolveIdentifierToInitializer(checker, argNode, sourceFile);
+        if (resolvedNode && ts.isObjectLiteralExpression(resolvedNode)) {
+          cleanedProperties[paramName] = {
+            type: 'object',
+            properties: extractProperties(checker, resolvedNode)
+          };
+        } else {
+          cleanedProperties[paramName] = {
+            type: inferNodeValueType(argNode)
+          };
+        }
+      } else {
+        // For non-object arguments, use simple type inference
+        cleanedProperties[paramName] = {
+          type: inferNodeValueType(argNode)
+        };
+      }
+    }
+  }
+
   return {
     eventName,
     source,
@@ -197,16 +260,121 @@ function processEventData(eventData, source, filePath, line, functionName, check
 /**
  * Gets string value from a TypeScript AST node
  * @param {Object} node - TypeScript AST node
+ * @param {Object} checker - TypeScript type checker
+ * @param {Object} sourceFile - TypeScript source file
  * @returns {string|null} String value or null
  */
-function getStringValue(node) {
+function getStringValue(node, checker, sourceFile) {
   if (!node) return null;
+  
+  // Handle string literals (existing behavior)
   if (ts.isStringLiteral(node)) {
     return node.text;
   }
+  
+  // Handle property access expressions like TRACKING_EVENTS.ECOMMERCE_PURCHASE
+  if (ts.isPropertyAccessExpression(node)) {
+    return resolvePropertyAccessToString(node, checker, sourceFile);
+  }
+  
+  // Handle identifiers that might reference constants
+  if (ts.isIdentifier(node)) {
+    return resolveIdentifierToString(node, checker, sourceFile);
+  }
+  
   return null;
 }
 
+/**
+ * Resolves a property access expression to its string value
+ * @param {Object} node - PropertyAccessExpression node
+ * @param {Object} checker - TypeScript type checker
+ * @param {Object} sourceFile - TypeScript source file
+ * @returns {string|null} String value or null
+ */
+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;
+    }
+    
+    // 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;
+      }
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Resolves an identifier to its string value
+ * @param {Object} node - Identifier node
+ * @param {Object} checker - TypeScript type checker
+ * @param {Object} sourceFile - TypeScript source file
+ * @returns {string|null} String value or null
+ */
+function resolveIdentifierToString(node, checker, sourceFile) {
+  try {
+    const symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) {
+      return null;
+    }
+    
+    // First try to resolve through value declaration
+    if (symbol.valueDeclaration) {
+      const declaration = symbol.valueDeclaration;
+      
+      // Handle variable declarations with string literal initializers
+      if (ts.isVariableDeclaration(declaration) && 
+          declaration.initializer &&
+          ts.isStringLiteral(declaration.initializer)) {
+        return declaration.initializer.text;
+      }
+      
+      // Handle const declarations with object literals containing string properties
+      if (ts.isVariableDeclaration(declaration) && 
+          declaration.initializer &&
+          ts.isObjectLiteralExpression(declaration.initializer)) {
+        // This case is handled by property access resolution
+        return null;
+      }
+    }
+    
+    // If value declaration doesn't exist or doesn't help, try type resolution
+    // This handles imported constants that are resolved through TypeScript's type system
+    const type = checker.getTypeOfSymbolAtLocation(symbol, node);
+    if (type && type.isStringLiteral && typeof type.isStringLiteral === 'function' && type.isStringLiteral()) {
+      return type.value;
+    }
+    
+    // Alternative approach for string literal types (different TypeScript versions)
+    if (type && type.flags && (type.flags & ts.TypeFlags.StringLiteral)) {
+      return type.value;
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
 /**
  * Finds a property by key in an ObjectLiteralExpression
  * @param {Object} objectNode - ObjectLiteralExpression node
@@ -263,6 +431,16 @@ function cleanupProperties(properties) {
   return cleaned;
 }
 
+function inferNodeValueType(node) {
+  if (!node) return 'any';
+  if (ts.isStringLiteral(node)) return 'string';
+  if (ts.isNumericLiteral(node)) return 'number';
+  if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) return 'boolean';
+  if (ts.isArrayLiteralExpression(node)) return 'array';
+  if (ts.isObjectLiteralExpression(node)) return 'object';
+  return 'any';
+}
+
 module.exports = {
   extractEventData,
   processEventData

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

@@ -34,6 +34,13 @@ function extractProperties(checker, node) {
   const properties = {};
 
   for (const prop of node.properties) {
+    // Handle spread assignments like {...object}
+    if (ts.isSpreadAssignment(prop)) {
+      const spreadProperties = extractSpreadProperties(checker, prop);
+      Object.assign(properties, spreadProperties);
+      continue;
+    }
+    
     const key = getPropertyKey(prop);
     if (!key) continue;
 
@@ -350,7 +357,7 @@ function resolveTypeSchema(checker, typeString) {
  * @returns {string|null} Literal type or null
  */
 function getLiteralType(node) {
-  if (!node) return null;
+  if (!node || typeof node.kind === 'undefined') return null;
   if (ts.isStringLiteral(node)) return 'string';
   if (ts.isNumericLiteral(node)) return 'number';
   if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) return 'boolean';
@@ -371,6 +378,51 @@ function isArrayType(typeString) {
          typeString.startsWith('readonly ');
 }
 
+/**
+ * Extracts properties from a spread assignment
+ * @param {Object} checker - TypeScript type checker
+ * @param {Object} spreadNode - SpreadAssignment node
+ * @returns {Object.<string, PropertySchema>}
+ */
+function extractSpreadProperties(checker, spreadNode) {
+  if (!spreadNode.expression) {
+    return {};
+  }
+  
+  // If the spread is an identifier, resolve it to its declaration
+  if (ts.isIdentifier(spreadNode.expression)) {
+    const symbol = checker.getSymbolAtLocation(spreadNode.expression);
+    if (symbol && symbol.declarations && symbol.declarations.length > 0) {
+      const declaration = symbol.declarations[0];
+      
+      // If it's a variable declaration with an object literal initializer
+      if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+        if (ts.isObjectLiteralExpression(declaration.initializer)) {
+          // Extract properties directly from the object literal
+          return extractProperties(checker, declaration.initializer);
+        }
+      }
+    }
+    
+    // Fallback to the original identifier schema extraction
+    const identifierSchema = extractIdentifierSchema(checker, spreadNode.expression);
+    return identifierSchema.properties || {};
+  }
+  
+  // If the spread is an object literal, extract its properties
+  if (ts.isObjectLiteralExpression(spreadNode.expression)) {
+    return extractProperties(checker, spreadNode.expression);
+  }
+  
+  // For other expressions, try to get the type and extract properties from it
+  try {
+    const spreadType = checker.getTypeAtLocation(spreadNode.expression);
+    return extractInterfaceProperties(checker, spreadType);
+  } catch (error) {
+    return {};
+  }
+}
+
 /**
  * Extracts properties from a TypeScript interface or type
  * @param {Object} checker - TypeScript type checker

package/src/analyze/typescript/index.js

@@ -9,16 +9,14 @@ const { getProgram, findTrackingEvents, ProgramError, SourceFileError } = requir
  * Analyzes a TypeScript file for analytics tracking calls
  * @param {string} filePath - Path to the TypeScript file to analyze
  * @param {Object} [program] - Optional existing TypeScript program to reuse
- * @param {string} [customFunction] - Optional custom function name to detect
+ * @param {string} [customFunctionSignature] - Optional custom function signature to detect
  * @returns {Array<Object>} Array of tracking events found in the file
  */
-function analyzeTsFile(filePath, program, customFunction) {
-  const events = [];
-
+function analyzeTsFile(filePath, program = null, customFunctionSignatures = null) {
   try {
-    // Get or create TypeScript program
+    // Get or create TypeScript program (only once)
     const tsProgram = getProgram(filePath, program);
-    
+
     // Get source file from program
     const sourceFile = tsProgram.getSourceFile(filePath);
     if (!sourceFile) {
@@ -28,9 +26,17 @@ function analyzeTsFile(filePath, program, customFunction) {
     // Get type checker
     const checker = tsProgram.getTypeChecker();
 
-    // Find and extract tracking events
-    const foundEvents = findTrackingEvents(sourceFile, checker, filePath, customFunction);
-    events.push(...foundEvents);
+    // Single-pass collection covering built-in + all custom configs
+    const events = findTrackingEvents(sourceFile, checker, filePath, customFunctionSignatures || []);
+
+    // Deduplicate events
+    const unique = new Map();
+    for (const evt of events) {
+      const key = `${evt.source}|${evt.eventName}|${evt.line}|${evt.functionName}`;
+      if (!unique.has(key)) unique.set(key, evt);
+    }
+
+    return Array.from(unique.values());
 
   } catch (error) {
     if (error instanceof ProgramError) {
@@ -42,7 +48,7 @@ function analyzeTsFile(filePath, program, customFunction) {
     }
   }
 
-  return events;
+  return [];
 }
 
 module.exports = { analyzeTsFile };

package/src/analyze/typescript/parser.js

@@ -65,32 +65,55 @@ function getProgram(filePath, existingProgram) {
  * @param {Object} sourceFile - TypeScript source file
  * @param {Object} checker - TypeScript type checker
  * @param {string} filePath - Path to the file being analyzed
- * @param {string} [customFunction] - Custom function name to detect
+ * @param {Array<Object>} [customConfigs] - Array of custom function configurations
  * @returns {Array<Object>} Array of found events
  */
-function findTrackingEvents(sourceFile, checker, filePath, customFunction) {
+function findTrackingEvents(sourceFile, checker, filePath, customConfigs = []) {
   const events = [];
 
   /**
-   * Visitor function for AST traversal
-   * @param {Object} node - Current AST node
+   * Helper to test if a CallExpression matches a custom function name.
+   * We simply rely on node.expression.getText() which preserves the fully qualified name.
    */
+  const matchesCustomFn = (callNode, fnName) => {
+    if (!fnName) return false;
+    try {
+      return callNode.expression && callNode.expression.getText() === fnName;
+    } catch {
+      return false;
+    }
+  };
+
   function visit(node) {
     try {
       if (ts.isCallExpression(node)) {
-        const event = extractTrackingEvent(node, sourceFile, checker, filePath, customFunction);
-        if (event) {
-          events.push(event);
+        let matchedCustom = null;
+
+        if (Array.isArray(customConfigs) && customConfigs.length > 0) {
+          for (const cfg of customConfigs) {
+            if (cfg && matchesCustomFn(node, cfg.functionName)) {
+              matchedCustom = cfg;
+              break;
+            }
+          }
         }
+
+        const event = extractTrackingEvent(
+          node,
+          sourceFile,
+          checker,
+          filePath,
+          matchedCustom /* may be null */
+        );
+        if (event) events.push(event);
       }
-      // Continue traversing the AST
+
       ts.forEachChild(node, visit);
     } catch (error) {
       console.error(`Error processing node in ${filePath}:`, error.message);
     }
   }
 
-  // Start traversal from the root
   ts.forEachChild(sourceFile, visit);
 
   return events;
@@ -102,25 +125,25 @@ function findTrackingEvents(sourceFile, checker, filePath, customFunction) {
  * @param {Object} sourceFile - TypeScript source file
  * @param {Object} checker - TypeScript type checker
  * @param {string} filePath - File path
- * @param {string} [customFunction] - Custom function name
+ * @param {Object} [customConfig] - Custom function configuration
  * @returns {Object|null} Extracted event or null
  */
-function extractTrackingEvent(node, sourceFile, checker, filePath, customFunction) {
+function extractTrackingEvent(node, sourceFile, checker, filePath, customConfig) {
   // Detect the analytics source
-  const source = detectAnalyticsSource(node, customFunction);
+  const source = detectAnalyticsSource(node, customConfig?.functionName);
   if (source === 'unknown') {
     return null;
   }
 
   // Extract event data based on the source
-  const eventData = extractEventData(node, source, checker, sourceFile);
+  const eventData = extractEventData(node, source, checker, sourceFile, customConfig);
 
   // Get location and context information
   const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
   const functionName = findWrappingFunction(node);
 
   // Process the event data into final format
-  return processEventData(eventData, source, filePath, line, functionName, checker, sourceFile);
+  return processEventData(eventData, source, filePath, line, functionName, checker, sourceFile, customConfig);
 }
 
 module.exports = {

package/src/analyze/typescript/utils/function-finder.js

@@ -110,6 +110,16 @@ function findParentFunctionName(node) {
     }
   }
 
+  // Property declaration in class: myFunc = () => {}
+  if (ts.isPropertyDeclaration(parent) && parent.name) {
+    if (ts.isIdentifier(parent.name)) {
+      return parent.name.escapedText;
+    }
+    if (ts.isStringLiteral(parent.name)) {
+      return parent.name.text;
+    }
+  }
+
   // Method property in object literal: { myFunc() {} }
   if (ts.isMethodDeclaration(parent) && parent.name) {
     return parent.name.escapedText;
@@ -117,6 +127,7 @@ function findParentFunctionName(node) {
 
   // Binary expression assignment: obj.myFunc = () => {}
   if (ts.isBinaryExpression(parent) &&
+    parent.operatorToken &&
     parent.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
     if (ts.isPropertyAccessExpression(parent.left)) {
       return parent.left.name.escapedText;

package/src/analyze/typescript/utils/type-resolver.js

@@ -144,7 +144,7 @@ function isCustomType(typeString) {
  * @returns {string} Basic type string
  */
 function getBasicTypeOfArrayElement(checker, element) {
-  if (!element) return 'any';
+  if (!element || typeof element.kind === 'undefined') return 'any';
   
   // Check for literal values first
   if (ts.isStringLiteral(element)) {