@flisk/analyze-tracking 0.8.7 → 0.9.0

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

@@ -44,16 +44,53 @@ function detectAnalyticsSource(node, customFunction) {
  * @returns {boolean}
  */
 function isCustomFunction(node, customFunction) {
-  const canBeCustomFunction = ts.isIdentifier(node.expression) ||
-    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()
-    (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;
+  if (!customFunction || !node || !node.expression) return false;
+
+  // Normalize signature parts by stripping trailing parentheses from each part
+  const parts = customFunction.split('.').map(p => p.replace(/\(\s*\)$/, ''));
+
+  return matchesExpressionChain(node.expression, parts);
+}
+
+/**
+ * Recursively verify that a CallExpression/PropertyAccessExpression chain matches the expected parts.
+ * Supports patterns like getTracker().track, this.props.customTrackFunction6, tracker.track
+ */
+function matchesExpressionChain(expr, parts) {
+  let current = expr;
+  let idx = parts.length - 1;
+
+  while (current && idx >= 0) {
+    const expected = parts[idx];
+
+    if (ts.isPropertyAccessExpression(current)) {
+      const name = current.name?.escapedText;
+      if (name !== expected) return false;
+      current = current.expression;
+      idx -= 1;
+      continue;
+    }
+
+    if (ts.isCallExpression(current)) {
+      // Step into the callee (e.g., getTracker() -> getTracker)
+      current = current.expression;
+      continue;
+    }
+
+    if (ts.isIdentifier(current)) {
+      return idx === 0 && current.escapedText === expected;
+    }
+
+    // Handle `this` without relying on ts.isThisExpression for compatibility across TS versions
+    if (current.kind === ts.SyntaxKind.ThisKeyword || current.kind === ts.SyntaxKind.ThisExpression) {
+      return idx === 0 && expected === 'this';
+    }
+
+    // Unsupported expression kind for our matcher
+    return false;
+  }
+
+  return false;
 }
 
 /**

package/src/analyze/utils/customFunctionParser.js

@@ -4,15 +4,27 @@ function parseCustomFunctionSignature(signature) {
     return null;
   }
 
-  // Match function name and optional parameter list
-  // Supports names with module prefix like Module.func
-  const match = signature.match(/^\s*([A-Za-z0-9_.]+)\s*(?:\(([^)]*)\))?\s*$/);
-  if (!match) {
-    return null;
-  }
+  const trimmed = signature.trim();
 
-  const functionName = match[1].trim();
-  const paramsPart = match[2];
+  // Two cases:
+  // 1) Full signature with params at the end (e.g., Module.track(EVENT_NAME, PROPERTIES)) → parse params
+  // 2) Name-only (including chains with internal calls, e.g., getService().track) → no params
+  let functionName;
+  let paramsPart = null;
+
+  if (/\)\s*$/.test(trimmed)) {
+    // Looks like it ends with a parameter list – extract the final (...) only
+    const lastOpenIdx = trimmed.lastIndexOf('(');
+    const lastCloseIdx = trimmed.lastIndexOf(')');
+    if (lastOpenIdx === -1 || lastCloseIdx < lastOpenIdx) {
+      return null;
+    }
+    functionName = trimmed.slice(0, lastOpenIdx).trim();
+    paramsPart = trimmed.slice(lastOpenIdx + 1, lastCloseIdx);
+  } else {
+    // No trailing params – treat the whole string as the function name
+    functionName = trimmed;
+  }
 
   // Default legacy behaviour: EVENT_NAME, PROPERTIES
   if (!paramsPart) {