@flisk/analyze-tracking 0.8.8 → 0.9.1

package/src/analyze/swift/providers.js

@@ -0,0 +1,51 @@
+/**
+ * Provider detection for Swift analytics SDKs
+ */
+
+const { normalizeChainPart, sliceRange } = require('./utils');
+
+function detectProvider(call, source) {
+  const method = call.name;
+  const chain = Array.isArray(call.calleeChain) ? call.calleeChain : [];
+  const recvText = call.receiver || null;
+  const recvBase = recvText ? recvText.split('.')[0] : null;
+  const base = call.baseIdentifier || recvBase || (chain.length ? normalizeChainPart(chain[0]).split('.')[0] : null);
+  const methodCand = method || (chain.length ? normalizeChainPart(chain[chain.length - 1]) : null);
+
+  if (base === 'dataLayer' && (methodCand === 'append' || methodCand === 'push')) return 'gtm';
+  if (base === 'Analytics' && methodCand === 'logEvent') return 'googleanalytics';
+  if (base === 'analytics' && methodCand === 'track') return 'segment';
+  if (base === 'Mixpanel' && methodCand === 'track') return 'mixpanel';
+  if (base === 'amplitude' && methodCand === 'track') return 'amplitude';
+  if (base === 'RSClient' && methodCand === 'track') return 'rudderstack';
+  if (base === 'MParticle' && methodCand === 'logEvent') return 'mparticle';
+  if (base === 'PostHogSDK' && methodCand === 'capture') return 'posthog';
+  if (base === 'PendoManager' && methodCand === 'track') return 'pendo';
+  if (base === 'Heap' && methodCand === 'track') return 'heap';
+
+  try {
+    const text = sliceRange(source, call.range || {});
+    const t = text.replace(/\s+/g, '');
+    if (/\bdataLayer\.(append|push)\(/.test(t)) return 'gtm';
+    if (/\bAnalytics\.logEvent\(/.test(t)) return 'googleanalytics';
+    if (/\banalytics\.track\(/.test(t)) return 'segment';
+    if (/\bMixpanel\.[A-Za-z0-9_]+\(\)\.track\(/.test(t) || /\bMixpanel\.track\(/.test(t)) return 'mixpanel';
+    if (/\bamplitude\.track\(/.test(t)) return 'amplitude';
+    if (/\bRSClient\.[A-Za-z0-9_?]+\(\)?(?:\?\.|\.)track\(/.test(t) || /\bRSClient\(\)\.track\(/.test(t)) return 'rudderstack';
+    if (/\bMParticle\.[A-Za-z0-9_]+\(\)\.logEvent\(/.test(t)) return 'mparticle';
+    if (/\bPostHogSDK\.[A-Za-z0-9_]+\.capture\(/.test(t)) return 'posthog';
+    if (/\bPendoManager\.[A-Za-z0-9_]+\(\)\.track\(/.test(t)) return 'pendo';
+    if (/\bHeap\.[A-Za-z0-9_]+\.track\(/.test(t)) return 'heap';
+  } catch (_) {}
+
+  try {
+    if (methodCand === 'append') {
+      const text = sliceRange(source, call.range || {});
+      if (text.includes('event:')) return 'gtm';
+    }
+  } catch (_) {}
+
+  return null;
+}
+
+module.exports = { detectProvider };

package/src/analyze/swift/runtime.js

@@ -0,0 +1,46 @@
+/**
+ * Swift runtime bridge for @flisk/swift-ast
+ * - Provides lazy ESM/CJS loading
+ * - Serializes WASI-backed calls to avoid double-start errors
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { pathToFileURL: pathToFileUrl } = require('url');
+
+let __swiftAst = null;
+async function getSwiftAst() {
+  if (__swiftAst) return __swiftAst;
+  try {
+    // Try CJS require first (when package exposes CJS entry)
+    // eslint-disable-next-line global-require
+    __swiftAst = require('@flisk/swift-ast');
+    return __swiftAst;
+  } catch (e) {
+    // Fallback to ESM dynamic import
+    try {
+      const m = await import('@flisk/swift-ast');
+      __swiftAst = m;
+      return __swiftAst;
+    } catch (_) {
+      // Final fallback: local workspace copy of swift-ast (for dev)
+      const localDist = path.resolve('/Users/sameenkarim/flisk/dev/swift-ast/dist/index.js');
+      if (fs.existsSync(localDist)) {
+        const m2 = await import(pathToFileUrl(localDist).href);
+        __swiftAst = m2;
+        return __swiftAst;
+      }
+      throw e;
+    }
+  }
+}
+
+// Serialize WASI-backed swift-ast operations
+let __swiftLock = Promise.resolve();
+function withSwift(callback) {
+  const p = __swiftLock.then(callback, callback);
+  __swiftLock = p.then(() => {}, () => {});
+  return p;
+}
+
+module.exports = { getSwiftAst, withSwift };

package/src/analyze/swift/utils.js

@@ -0,0 +1,75 @@
+/**
+ * Generic Swift analyzer utilities
+ * - String inference, key resolution, text slicing, and traversal helpers
+ */
+
+function normalizeChainPart(p) {
+  if (!p) return p;
+  return String(p).replace(/\s+/g, '').replace(/\(\)$/g, '');
+}
+
+function endsWithChain(chain, sigParts) {
+  if (sigParts.length > chain.length) return false;
+  for (let i = 1; i <= sigParts.length; i++) {
+    if (normalizeChainPart(chain[chain.length - i]) !== sigParts[sigParts.length - i]) return false;
+  }
+  return true;
+}
+
+function extractStringLiteral(text) {
+  const m = /^\s*"([\s\S]*?)"\s*$/.exec(text || '');
+  return m ? m[1] : null;
+}
+
+function isIdentifier(text) {
+  return /^[_A-Za-z][_A-Za-z0-9\.]*$/.test(text || '');
+}
+
+function inferValueTypeFromText(text) {
+  const t = (text || '').trim();
+  if (/^"/.test(t)) return { type: 'string' };
+  if (/^(true|false)$/i.test(t)) return { type: 'boolean' };
+  if (/^[0-9]+(\.[0-9]+)?$/.test(t)) return { type: 'number' };
+  if (/^\[/.test(t)) {
+    const inside = t.slice(1, -1).trim();
+    if (!inside) return { type: 'array', items: { type: 'any' } };
+    if (/^(\s*"[\s\S]*?"\s*,)*\s*"[\s\S]*?"\s*$/.test(inside)) return { type: 'array', items: { type: 'string' } };
+    if (/^(\s*[0-9]+(\.[0-9]+)?\s*,)*\s*[0-9]+(\.[0-9]+)?\s*$/.test(inside)) return { type: 'array', items: { type: 'number' } };
+    return { type: 'array', items: { type: 'any' } };
+  }
+  if (/^\{/.test(t) || /\)$/.test(t)) return { type: 'object' };
+  if (isIdentifier(t)) return { type: 'string' };
+  return { type: 'any' };
+}
+
+function splitTopLevel(s) {
+  const items = [];
+  let depthBr = 0, depthPr = 0; let cur = '';
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '[') depthBr++; else if (ch === ']') depthBr--;
+    else if (ch === '(') depthPr++; else if (ch === ')') depthPr--;
+    if (ch === ',' && depthBr === 0 && depthPr === 0) { items.push(cur); cur = ''; continue; }
+    cur += ch;
+  }
+  if (cur.trim()) items.push(cur);
+  return items;
+}
+
+function sliceRange(source, range) {
+  const s = range?.start?.offset || 0; const e = range?.end?.offset || s;
+  return source.slice(s, e);
+}
+
+function escapeRegExp(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+module.exports = {
+  normalizeChainPart,
+  endsWithChain,
+  extractStringLiteral,
+  isIdentifier,
+  inferValueTypeFromText,
+  splitTopLevel,
+  sliceRange,
+  escapeRegExp,
+};

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

@@ -9,16 +9,25 @@ const { ANALYTICS_PROVIDERS } = require('../constants');
 /**
  * Detects the analytics provider from a CallExpression node
  * @param {Object} node - TypeScript CallExpression node
- * @param {string} [customFunction] - Custom function name to detect
+ * @param {string|Object} [customFunctionOrConfig] - Custom function name string or custom config object
  * @returns {string} The detected analytics source or 'unknown'
  */
-function detectAnalyticsSource(node, customFunction) {
+function detectAnalyticsSource(node, customFunctionOrConfig) {
   if (!node.expression) {
     return 'unknown';
   }
 
   // Check for custom function first
-  if (customFunction && isCustomFunction(node, customFunction)) {
+  // Support both old string format and new config object format
+  const customConfig = typeof customFunctionOrConfig === 'object' ? customFunctionOrConfig : null;
+  const customFunction = typeof customFunctionOrConfig === 'string' ? customFunctionOrConfig : (customConfig?.functionName);
+
+  if (customConfig?.isMethodAsEvent) {
+    // Method-as-event pattern: match any method on the specified object
+    if (isMethodAsEventFunction(node, customConfig)) {
+      return 'custom';
+    }
+  } else if (customFunction && isCustomFunction(node, customFunction)) {
     return 'custom';
   }
 
@@ -37,6 +46,31 @@ function detectAnalyticsSource(node, customFunction) {
   return 'unknown';
 }
 
+/**
+ * Checks if the node matches a method-as-event custom function pattern
+ * @param {Object} node - TypeScript CallExpression node
+ * @param {Object} customConfig - Custom function configuration with isMethodAsEvent: true
+ * @returns {boolean}
+ */
+function isMethodAsEventFunction(node, customConfig) {
+  if (!customConfig?.isMethodAsEvent || !customConfig?.objectName) {
+    return false;
+  }
+
+  // Must be a PropertyAccessExpression: objectName.methodName(...)
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return false;
+  }
+
+  // The object part must match the configured objectName
+  const objectExpr = node.expression.expression;
+  if (!ts.isIdentifier(objectExpr)) {
+    return false;
+  }
+
+  return objectExpr.escapedText === customConfig.objectName;
+}
+
 /**
  * Checks if the node is a custom function call
  * @param {Object} node - TypeScript CallExpression node

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

@@ -76,10 +76,10 @@ function extractSnowplowEvent(node, checker, sourceFile) {
 
   // tracker.track(buildStructEvent({ action: 'event_name', ... }))
   const firstArg = node.arguments[0];
-  
+
   // Check if it's a direct buildStructEvent call
-  if (ts.isCallExpression(firstArg) && 
-      ts.isIdentifier(firstArg.expression) && 
+  if (ts.isCallExpression(firstArg) &&
+      ts.isIdentifier(firstArg.expression) &&
       firstArg.expression.escapedText === 'buildStructEvent' &&
       firstArg.arguments.length > 0) {
     const structEventArg = firstArg.arguments[0];
@@ -141,7 +141,7 @@ function extractGTMEvent(node, checker, sourceFile) {
 
   // dataLayer.push({ event: 'event_name', property1: 'value1', property2: 'value2' })
   const firstArg = node.arguments[0];
-  
+
   if (!ts.isObjectLiteralExpression(firstArg)) {
     return { eventName: null, propertiesNode: null };
   }
@@ -153,7 +153,7 @@ function extractGTMEvent(node, checker, sourceFile) {
   }
 
   const eventName = getStringValue(eventProperty.initializer, checker, sourceFile);
-  
+
   // Create a modified properties node without the 'event' property
   const modifiedProperties = firstArg.properties.filter(prop => {
     if (ts.isPropertyAssignment(prop) && prop.name) {
@@ -169,7 +169,7 @@ function extractGTMEvent(node, checker, sourceFile) {
 
   // Create a synthetic object literal with the filtered properties
   const modifiedPropertiesNode = ts.factory.createObjectLiteralExpression(modifiedProperties);
-  
+
   // Copy source positions for proper analysis
   if (firstArg.pos !== undefined) {
     modifiedPropertiesNode.pos = firstArg.pos;
@@ -192,10 +192,31 @@ function extractGTMEvent(node, checker, sourceFile) {
 function extractCustomEvent(node, checker, sourceFile, customConfig) {
   const args = node.arguments || [];
 
-  const eventArg = args[customConfig?.eventIndex ?? 0];
-  const propertiesArg = args[customConfig?.propertiesIndex ?? 1];
+  let eventName;
+  let propertiesArg;
+
+  if (customConfig?.isMethodAsEvent) {
+    // Method-as-event pattern: event name comes from the method name
+    if (ts.isPropertyAccessExpression(node.expression)) {
+      const methodName = node.expression.name;
+      if (methodName && ts.isIdentifier(methodName)) {
+        eventName = methodName.escapedText || methodName.text;
+      } else {
+        // Fallback: could not extract method name
+        eventName = null;
+      }
+    } else {
+      eventName = null;
+    }
 
-  const eventName = getStringValue(eventArg, checker, sourceFile);
+    // Properties are at the configured index (default 0)
+    propertiesArg = args[customConfig?.propertiesIndex ?? 0];
+  } else {
+    // Standard custom function pattern: event name comes from argument
+    const eventArg = args[customConfig?.eventIndex ?? 0];
+    propertiesArg = args[customConfig?.propertiesIndex ?? 1];
+    eventName = getStringValue(eventArg, checker, sourceFile);
+  }
 
   const extraArgs = {};
   if (customConfig && customConfig.extraParams) {
@@ -320,22 +341,22 @@ function processEventData(eventData, source, filePath, line, functionName, check
  */
 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;
 }
 
@@ -438,39 +459,39 @@ function resolveIdentifierToString(node, checker, sourceFile) {
     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) && 
+      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) && 
+      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;
@@ -485,7 +506,7 @@ function resolveIdentifierToString(node, checker, sourceFile) {
  */
 function findPropertyByKey(objectNode, key) {
   if (!objectNode.properties) return null;
-  
+
   return objectNode.properties.find(prop => {
     if (prop.name) {
       if (ts.isIdentifier(prop.name)) {
@@ -506,30 +527,37 @@ function findPropertyByKey(objectNode, key) {
  */
 function cleanupProperties(properties) {
   const cleaned = {};
-  
+
   for (const [key, value] of Object.entries(properties)) {
     if (value && typeof value === 'object') {
-      // Remove __unresolved marker
+      // Remove __unresolved marker from the value itself
       if (value.__unresolved) {
         delete value.__unresolved;
       }
-      
+
       // Recursively clean nested properties
       if (value.properties) {
         value.properties = cleanupProperties(value.properties);
       }
-      
-      // Clean array item properties
-      if (value.type === 'array' && value.items && value.items.properties) {
-        value.items.properties = cleanupProperties(value.items.properties);
+
+      // Clean array item properties and __unresolved markers
+      if (value.type === 'array' && value.items) {
+        // Remove __unresolved from items directly
+        if (value.items.__unresolved) {
+          delete value.items.__unresolved;
+        }
+        // Clean nested properties in items
+        if (value.items.properties) {
+          value.items.properties = cleanupProperties(value.items.properties);
+        }
       }
-      
+
       cleaned[key] = value;
     } else {
       cleaned[key] = value;
     }
   }
-  
+
   return cleaned;
 }