@flisk/analyze-tracking 0.8.8 → 0.9.1

package/README.md

@@ -39,6 +39,8 @@ npx @flisk/analyze-tracking /path/to/project [options]
 
 If you have your own in-house tracker or a wrapper function that calls other tracking libraries, you can specify the function signature with the `-c` or `--customFunction` option.
 
+#### Standard Custom Function Format
+
 Your function signature should be in the following format:
 ```js
 yourCustomTrackFunctionName(EVENT_NAME, PROPERTIES, customFieldOne, customFieldTwo)
@@ -57,11 +59,45 @@ yourCustomTrackFunctionName(userId, EVENT_NAME, PROPERTIES)
 
 If your function follows the standard format `yourCustomTrackFunctionName(EVENT_NAME, PROPERTIES)`, you can simply pass in `yourCustomTrackFunctionName` to `--customFunction` as a shorthand.
 
+#### Method-Name-as-Event Format
+
+For tracking patterns where the method name itself is the event name (e.g., `yourClass.yourEventName({...})`), use the special `EVENT_NAME` placeholder in the method position:
+
+```js
+yourClass.EVENT_NAME(PROPERTIES)
+```
+
+This pattern tells the analyzer that:
+- `yourClass` is the object name to match
+- The method name after the dot (e.g., `viewItemList`, `addToCart`) is the event name
+- `PROPERTIES` is the properties object (defaults to the first argument if not specified)
+
+**Example:**
+```typescript
+// Code in your project:
+yourClass.viewItemList({ items: [...] });
+yourClass.addToCart({ item: {...}, value: 100 });
+yourClass.purchase({ userId: '123', value: 100 });
+
+// Command:
+npx @flisk/analyze-tracking /path/to/project --customFunction "yourClass.EVENT_NAME(PROPERTIES)"
+```
+
+This will detect:
+- Event: `viewItemList` with properties from the first argument
+- Event: `addToCart` with properties from the first argument
+- Event: `purchase` with properties from the first argument
+
+_**Note:** This pattern is currently only supported for JavaScript and TypeScript code._
+
+#### Multiple Custom Functions
+
 You can also pass in multiple custom function signatures by passing in the `--customFunction` option multiple times or by passing in a space-separated list of function signatures.
 
 ```sh
 npx @flisk/analyze-tracking /path/to/project --customFunction "yourFunc1" --customFunction "yourFunc2(userId, EVENT_NAME, PROPERTIES)"
 npx @flisk/analyze-tracking /path/to/project -c "yourFunc1" "yourFunc2(userId, EVENT_NAME, PROPERTIES)"
+npx @flisk/analyze-tracking /path/to/project -c "yourClass.EVENT_NAME(PROPERTIES)" "customTrack(EVENT_NAME, PROPERTIES)"
 ```
 
 
@@ -95,25 +131,25 @@ Use this to understand where your events live in the code and how they're being
 Your LLM of choice is used for generating descriptions of events, properties, and implementations.
 
 See [schema.json](schema.json) for a JSON Schema of the output.
- 
+
 
 ## Supported tracking libraries & languages
 
-| Library | JavaScript/TypeScript | Python | Ruby | Go |
-|---------|:---------------------:|:------:|:----:|:--:|
-| Google Analytics   | ✅ | ❌ | ❌ | ❌ |
-| Google Tag Manager | ✅ | ❌ | ❌ | ❌ |
-| Segment            | ✅ | ✅ | ✅ | ✅ |
-| Mixpanel           | ✅ | ✅ | ✅ | ✅ |
-| Amplitude          | ✅ | ✅ | ❌ | ✅ |
-| Rudderstack        | ✅ | ✅ | ✳️ | ✳️ |
-| mParticle          | ✅ | ❌ | ❌ | ❌ |
-| PostHog            | ✅ | ✅ | ✅ | ✅ |
-| Pendo              | ✅ | ❌ | ❌ | ❌ |
-| Heap               | ✅ | ❌ | ❌ | ❌ |
-| Snowplow           | ✅ | ✅ | ✅ | ✅ |
-| Datadog RUM        | ✅ | ❌ | ❌ | ❌ |
-| Custom Function    | ✅ | ✅ | ✅ | ✅ |
+| Library | JavaScript/TypeScript | Python | Ruby | Go | Swift |
+|---------|:---------------------:|:------:|:----:|:--:|:--:|
+| Google Analytics   | ✅ | ❌ | ❌ | ❌ | ✅ |
+| Google Tag Manager | ✅ | ❌ | ❌ | ❌ | ✅ |
+| Segment            | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Mixpanel           | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Amplitude          | ✅ | ✅ | ❌ | ✅ | ✅ |
+| Rudderstack        | ✅ | ✅ | ✳️ | ✳️ | ✅ |
+| mParticle          | ✅ | ❌ | ❌ | ❌ | ✅ |
+| PostHog            | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Pendo              | ✅ | ❌ | ❌ | ❌ | ✅ |
+| Heap               | ✅ | ❌ | ❌ | ❌ | ✅ |
+| Snowplow           | ✅ | ✅ | ✅ | ✅ | ❌ |
+| Datadog RUM        | ✅ | ❌ | ❌ | ❌ | ❌ |
+| Custom Function    | ✅ | ✅ | ✅ | ✅ | ✅ |
 
 ✳️ Rudderstack's SDKs often use the same format as Segment, so Rudderstack events may be detected as Segment events.
 
@@ -129,6 +165,13 @@ See [schema.json](schema.json) for a JSON Schema of the output.
     '<property_name>': '<property_value>'
   });
   ```
+
+  **Swift**
+  ```swift
+  Analytics.logEvent("<event_name>", parameters: [
+    "<property_name>": "<property_value>"
+  ])
+  ```
 </details>
 
 <details>
@@ -147,6 +190,11 @@ See [schema.json](schema.json) for a JSON Schema of the output.
     '<property_name>': '<property_value>'
   });
   ```
+
+  **Swift**
+  ```swift
+  dataLayer.push(["event": "<event_name>", "<property_name>": "<property_value>"])
+  ```
 </details>
 
 <details>
@@ -185,6 +233,11 @@ See [schema.json](schema.json) for a JSON Schema of the output.
       Set("<property_name>", "<property_value>"),
   })
   ```
+
+  **Swift**
+  ```swift
+  analytics.track(name: "<event_name>", properties: TrackProperties("<property_name>": "<property_value>"))
+  ```
 </details>
 
 <details>
@@ -221,6 +274,13 @@ See [schema.json](schema.json) for a JSON Schema of the output.
     }),
   })
   ```
+
+  **Swift**
+  ```swift
+  Mixpanel.mainInstance().track(event: "<event_name>", properties: [
+    "<property_name>": "<property_value>"
+  ])
+  ```
 </details>
 
 <details>
@@ -256,6 +316,14 @@ See [schema.json](schema.json) for a JSON Schema of the output.
     },
   })
   ```
+
+  **Swift**
+  ```swift
+  amplitude.track(
+    eventType: "<event_name>",
+    eventProperties: ["<property_name>": "<property_value>"]
+  )
+  ```
 </details>
 
 <details>
@@ -295,6 +363,13 @@ See [schema.json](schema.json) for a JSON Schema of the output.
       Set("<property_name>", "<property_value>"),
   })
   ```
+
+  **Swift**
+  ```swift
+  RSClient.sharedInstance()?.track("<event_name>", properties: [
+    "<property_name>": "<property_value>"
+  ])
+  ```
 </details>
 
 <details>
@@ -306,6 +381,15 @@ See [schema.json](schema.json) for a JSON Schema of the output.
     '<property_name>': '<property_value>'
   });
   ```
+
+  **Swift**
+  ```swift
+  let event = MPEvent(name: "<event_name>", type: .other)
+  event.customAttributes = [
+    "<property_name>": "<property_value>"
+  ]
+  MParticle.sharedInstance().logEvent(event)
+  ```
 </details>
 
 <details>
@@ -353,6 +437,13 @@ See [schema.json](schema.json) for a JSON Schema of the output.
       Set("<property_name>", "<property_value>"),
   })
   ```
+
+  **Swift**
+  ```swift
+  PostHogSDK.shared.capture("<event_name>", properties: [
+    "<property_name>": "<property_value>"
+  ])
+  ```
 </details>
 
 <details>
@@ -372,7 +463,12 @@ See [schema.json](schema.json) for a JSON Schema of the output.
   })
   ```
 
-
+  **Swift**
+  ```swift
+  PendoManager.shared().track("<event_name>", properties: [
+    "<property_name>": "<property_value>"
+  ])
+  ```
 </details>
 
 <details>
@@ -392,7 +488,12 @@ See [schema.json](schema.json) for a JSON Schema of the output.
   })
   ```
 
-
+  **Swift**
+  ```swift
+  Heap.shared.track("<event_name>", properties: [
+    "<property_name>": "<property_value>"
+  ])
+  ```
 </details>
 
 <details>
@@ -403,7 +504,7 @@ See [schema.json](schema.json) for a JSON Schema of the output.
   datadogRum.addAction('<event_name>', {
     '<property_name>': '<property_value>'
   });
-  
+
   // Or via window
   window.DD_RUM.addAction('<event_name>', {
     '<property_name>': '<property_value>'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flisk/analyze-tracking",
-  "version": "0.8.8",
+  "version": "0.9.1",
   "description": "Analyzes tracking code in a project and generates data schemas",
   "main": "src/index.js",
   "bin": {
@@ -13,6 +13,7 @@
     "test:python": "node --experimental-vm-modules --test tests/analyzePython.test.js",
     "test:ruby": "node --experimental-vm-modules --test tests/analyzeRuby.test.js",
     "test:go": "node --test tests/analyzeGo.test.js",
+    "test:swift": "node --test tests/analyzeSwift.test.js",
     "test:cli": "node --test tests/cli.test.js",
     "test:schema": "node --test tests/schema.test.js",
     "test:generateDescriptions": "node --test tests/generateDescriptions.test.js",
@@ -34,6 +35,7 @@
   },
   "homepage": "https://github.com/fliskdata/analyze-tracking#readme",
   "dependencies": {
+    "@flisk/swift-ast": "^0.1.3",
     "@langchain/core": "^0.3.56",
     "@langchain/google-vertexai": "^0.2.9",
     "@langchain/openai": "^0.5.10",
@@ -52,9 +54,9 @@
     "zod": "^3.24.4"
   },
   "devDependencies": {
+    "@types/react": "^19.1.6",
     "ajv": "^8.17.1",
     "lodash": "^4.17.21",
-    "react": "^19.1.0",
-    "@types/react": "^19.1.6"
+    "react": "^19.1.0"
   }
 }

package/schema.json

@@ -142,6 +142,16 @@
         "items": {
           "$ref": "#/definitions/property",
           "description": "Schema for array items when type is 'array'"
+        },
+        "values": {
+          "type": "array",
+          "items": {
+            "oneOf": [
+              { "type": "string" },
+              { "type": "number" }
+            ]
+          },
+          "description": "Possible values when type is 'enum'"
         }
       },
       "required": [

package/src/analyze/index.js

@@ -13,12 +13,13 @@ const { analyzeTsFiles } = require('./typescript');
 const { analyzePythonFile } = require('./python');
 const { analyzeRubyFile, prebuildConstantMaps } = require('./ruby');
 const { analyzeGoFile } = require('./go');
+const { analyzeSwiftFile } = require('./swift');
 
 /**
  * Analyzes a single file for analytics tracking calls
- * 
+ *
  * Note: typescript files are handled separately by analyzeTsFiles, which is a batch processor
- * 
+ *
  * @param {string} file - Path to the file to analyze
  * @param {Array<string>} customFunctionSignatures - Custom function signatures to detect
  * @returns {Promise<Array<Object>>} Array of events found in the file
@@ -28,19 +29,20 @@ async function analyzeFile(file, customFunctionSignatures) {
   if (/\.py$/.test(file))   return analyzePythonFile(file, customFunctionSignatures)
   if (/\.rb$/.test(file))   return analyzeRubyFile(file, customFunctionSignatures)
   if (/\.go$/.test(file))   return analyzeGoFile(file, customFunctionSignatures)
+  if (/\.swift$/.test(file)) return analyzeSwiftFile(file, customFunctionSignatures)
   return []
 }
 
 /**
  * Adds an event to the events collection, merging properties if event already exists
- * 
+ *
  * @param {Object} allEvents - Collection of all events
  * @param {Object} event - Event to add
  * @param {string} baseDir - Base directory for relative path calculation
  */
 function addEventToCollection(allEvents, event, baseDir) {
   const relativeFilePath = path.relative(baseDir, event.filePath);
-  
+
   const implementation = {
     path: relativeFilePath,
     line: event.line,
@@ -64,12 +66,12 @@ function addEventToCollection(allEvents, event, baseDir) {
 
 /**
  * Processes all files that are not TypeScript files in parallel
- * 
+ *
  * Checks the system's file descriptor limit and uses 80% of it to avoid running out of file descriptors
  * Creates a promise pool and launches one analysis for each file in parallel
  * When a slot frees up, the next file is launched
  * Waits for the remaining work to complete
- * 
+ *
  * @param {Array<string>} files - Array of file paths
  * @param {Object} allEvents - Collection to add events to
  * @param {string} baseDir - Base directory for relative paths
@@ -121,10 +123,10 @@ async function processFiles(files, allEvents, baseDir, customFunctionSignatures)
 
 /**
  * Analyze a directory recursively for analytics tracking calls
- * 
+ *
  * This function scans all supported files in a directory tree and identifies analytics tracking calls,
  * handling different file types appropriately.
- * 
+ *
  * @param {string} dirPath - Path to the directory to analyze
  * @param {Array<string>} [customFunctions=null] - Array of custom tracking function signatures to detect
  * @returns {Promise<Object>} Object mapping event names to their tracking implementations
@@ -132,17 +134,22 @@ async function processFiles(files, allEvents, baseDir, customFunctionSignatures)
 async function analyzeDirectory(dirPath, customFunctions) {
   const allEvents = {};
 
-  const customFunctionSignatures = (customFunctions?.length > 0) 
-    ? customFunctions.map(parseCustomFunctionSignature) 
-    : null;
+  let customFunctionSignatures = null;
+  if (Array.isArray(customFunctions) && customFunctions.length > 0) {
+    customFunctionSignatures = customFunctions.map(cf => {
+      if (cf && typeof cf === 'object' && cf.functionName) return cf;
+      if (typeof cf === 'string') return parseCustomFunctionSignature(cf);
+      return null;
+    }).filter(Boolean);
+  }
 
   const files = getAllFiles(dirPath);
-  
+
   // Separate TypeScript files from others for optimized processing
   const tsFiles = [];
   const nonTsFiles = [];
   const rubyFiles = [];
-  
+
   for (const file of files) {
     const isTsFile = /\.(tsx?)$/.test(file);
     if (isTsFile) {

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

@@ -8,16 +8,25 @@ const { ANALYTICS_PROVIDERS, NODE_TYPES } = require('../constants');
 /**
  * Detects the analytics provider from a CallExpression node
  * @param {Object} node - AST 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.callee) {
     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';
   }
 
@@ -36,6 +45,31 @@ function detectAnalyticsSource(node, customFunction) {
   return 'unknown';
 }
 
+/**
+ * Checks if the node matches a method-as-event custom function pattern
+ * @param {Object} node - AST 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 MemberExpression: objectName.methodName(...)
+  if (node.callee.type !== NODE_TYPES.MEMBER_EXPRESSION) {
+    return false;
+  }
+
+  // The object part must match the configured objectName
+  const objectNode = node.callee.object;
+  if (objectNode.type !== NODE_TYPES.IDENTIFIER) {
+    return false;
+  }
+
+  return objectNode.name === customConfig.objectName;
+}
+
 /**
  * Checks if the node is a custom function call
  * @param {Object} node - AST CallExpression node
@@ -122,7 +156,7 @@ function detectFunctionBasedProvider(node) {
   }
 
   const functionName = node.callee.name;
-  
+
   for (const provider of Object.values(ANALYTICS_PROVIDERS)) {
     if (provider.type === 'function' && provider.functionName === functionName) {
       return provider.name;

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

@@ -72,15 +72,15 @@ function extractSnowplowEvent(node, constantMap) {
 
   // tracker.track(buildStructEvent({ action: 'event_name', ... }))
   const firstArg = node.arguments[0];
-  
-  if (firstArg.type === NODE_TYPES.CALL_EXPRESSION && 
+
+  if (firstArg.type === NODE_TYPES.CALL_EXPRESSION &&
       firstArg.arguments.length > 0) {
     const structEventArg = firstArg.arguments[0];
-    
+
     if (structEventArg.type === NODE_TYPES.OBJECT_EXPRESSION) {
       const actionProperty = findPropertyByKey(structEventArg, 'action');
       const eventName = actionProperty ? getStringValue(actionProperty.value, constantMap) : null;
-      
+
       return { eventName, propertiesNode: structEventArg };
     }
   }
@@ -119,7 +119,7 @@ function extractGTMEvent(node, constantMap) {
 
   // dataLayer.push({ event: 'event_name', property1: 'value1', property2: 'value2' })
   const firstArg = node.arguments[0];
-  
+
   if (firstArg.type !== NODE_TYPES.OBJECT_EXPRESSION) {
     return { eventName: null, propertiesNode: null };
   }
@@ -131,11 +131,11 @@ function extractGTMEvent(node, constantMap) {
   }
 
   const eventName = getStringValue(eventProperty.value, constantMap);
-  
+
   // Create a modified properties node without the 'event' property
   const modifiedPropertiesNode = {
     ...firstArg,
-    properties: firstArg.properties.filter(prop => 
+    properties: firstArg.properties.filter(prop =>
       prop.key && (prop.key.name !== 'event' && prop.key.value !== 'event')
     )
   };
@@ -171,10 +171,27 @@ function extractDefaultEvent(node, constantMap) {
 function extractCustomEvent(node, constantMap, 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 (node.callee.type === NODE_TYPES.MEMBER_EXPRESSION &&
+        node.callee.property.type === NODE_TYPES.IDENTIFIER) {
+      eventName = node.callee.property.name;
+    } else {
+      // Fallback: could not extract method name
+      eventName = null;
+    }
 
-  const eventName = getStringValue(eventArg, constantMap);
+    // 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, constantMap);
+  }
 
   const extraArgs = {};
   if (customConfig && customConfig.extraParams) {
@@ -274,8 +291,8 @@ function getStringValue(node, constantMap = {}) {
  */
 function findPropertyByKey(objectNode, key) {
   if (!objectNode.properties) return null;
-  
-  return objectNode.properties.find(prop => 
+
+  return objectNode.properties.find(prop =>
     prop.key && (prop.key.name === key || prop.key.value === key)
   );
 }

package/src/analyze/javascript/parser.js

@@ -53,7 +53,7 @@ class ParseError extends Error {
  */
 function parseFile(filePath) {
   let code;
-  
+
   try {
     code = fs.readFileSync(filePath, 'utf8');
   } catch (error) {
@@ -72,16 +72,33 @@ function parseFile(filePath) {
 // ---------------------------------------------
 
 /**
- * Determines whether a CallExpression node matches the provided custom function name.
- * Supports both simple identifiers (e.g. myTrack) and dot-separated members (e.g. Custom.track).
+ * Determines whether a CallExpression node matches the provided custom function configuration.
+ * Supports both simple identifiers (e.g. myTrack), dot-separated members (e.g. Custom.track),
+ * and method-as-event patterns (e.g. eventCalls.EVENT_NAME).
  * The logic mirrors isCustomFunction from detectors/analytics-source.js but is kept local to avoid
  * circular dependencies.
  * @param {Object} node  – CallExpression AST node
- * @param {string} fnName – Custom function name (could include dots)
+ * @param {Object} customConfig – Custom function configuration object
  * @returns {boolean}
  */
-function nodeMatchesCustomFunction(node, fnName) {
-  if (!fnName || !node.callee) return false;
+function nodeMatchesCustomFunction(node, customConfig) {
+  if (!customConfig || !node.callee) return false;
+
+  // Handle method-as-event pattern
+  if (customConfig.isMethodAsEvent && customConfig.objectName) {
+    if (node.callee.type !== NODE_TYPES.MEMBER_EXPRESSION) {
+      return false;
+    }
+    const objectNode = node.callee.object;
+    if (objectNode.type !== NODE_TYPES.IDENTIFIER) {
+      return false;
+    }
+    return objectNode.name === customConfig.objectName;
+  }
+
+  // Handle standard custom function patterns
+  const fnName = customConfig.functionName;
+  if (!fnName) return false;
 
   // Support chained calls in function name by stripping trailing parens from each segment
   const parts = fnName.split('.').map(p => p.replace(/\(\s*\)$/, ''));
@@ -204,7 +221,7 @@ function findTrackingEvents(ast, filePath, customConfigs = []) {
         // Attempt to match any custom function first to avoid mis-classifying built-in providers
         if (Array.isArray(customConfigs) && customConfigs.length > 0) {
           for (const cfg of customConfigs) {
-            if (cfg && nodeMatchesCustomFunction(node, cfg.functionName)) {
+            if (cfg && nodeMatchesCustomFunction(node, cfg)) {
               matchedCustomConfig = cfg;
               break;
             }
@@ -237,7 +254,8 @@ function findTrackingEvents(ast, filePath, customConfigs = []) {
  * @returns {Object|null} Extracted event or null
  */
 function extractTrackingEvent(node, ancestors, filePath, constantMap, customConfig) {
-  const source = detectAnalyticsSource(node, customConfig?.functionName);
+  // Pass the full customConfig object (not just functionName) to support method-as-event patterns
+  const source = detectAnalyticsSource(node, customConfig || null);
   if (source === 'unknown') {
     return null;
   }

package/src/analyze/swift/constants.js

@@ -0,0 +1,61 @@
+/**
+ * Constants and helper-return collectors for Swift fixtures
+ * - Scans directory for top-level lets and enum/struct static lets
+ * - Extracts simple function returns for dict/array builders
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function buildCrossFileConstMap(dir) {
+  const map = {};
+  try {
+    const entries = fs.readdirSync(dir).filter(f => f.endsWith('.swift'));
+    for (const f of entries) {
+      const fp = path.join(dir, f);
+      const content = fs.readFileSync(fp, 'utf8');
+      // Top-level: let NAME = "..."
+      for (const m of content.matchAll(/\blet\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*"([\s\S]*?)"/g)) {
+        map[m[1]] = m[2];
+      }
+      // Enum/struct blocks: capture namespace and all static lets inside
+      let idx = 0;
+      while (idx < content.length) {
+        const head = content.slice(idx);
+        const mm = /\b(enum|struct)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{/m.exec(head);
+        if (!mm) break;
+        const ns = mm[2];
+        const blockStart = idx + mm.index + mm[0].length - 1; // position at '{'
+        // Find matching closing brace
+        let depth = 0; let end = -1;
+        for (let i = blockStart; i < content.length; i++) {
+          const ch = content[i];
+          if (ch === '{') depth++;
+          else if (ch === '}') { depth--; if (depth === 0) { end = i; break; } }
+        }
+        if (end === -1) break;
+        const block = content.slice(blockStart + 1, end);
+        for (const sm of block.matchAll(/\bstatic\s+let\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*"([\s\S]*?)"/g)) {
+          const key = sm[1];
+          const val = sm[2];
+          map[`${ns}.${key}`] = val;
+        }
+        idx = end + 1;
+      }
+      // Capture very simple helper returns
+      // func makeAddress() -> [String: Any] { return [ ... ] }
+      for (const m of content.matchAll(/func\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(\)\s*->\s*\[[^\]]+\][^{]*\{[\s\S]*?return\s*(\[[\s\S]*?\])[\s\S]*?\}/g)) {
+        map.__dictFuncs = map.__dictFuncs || {};
+        map.__dictFuncs[m[1]] = { kind: 'dict', text: m[2] };
+      }
+      // func makeProducts() -> [[String: Any]] { return [ ... ] } (array)
+      for (const m of content.matchAll(/func\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(\)\s*->\s*\[\[[^\]]+\]\][^{]*\{[\s\S]*?return\s*(\[[\s\S]*?\])[\s\S]*?\}/g)) {
+        map.__dictFuncs = map.__dictFuncs || {};
+        map.__dictFuncs[m[1]] = { kind: 'array', text: m[2] };
+      }
+    }
+  } catch (_) {}
+  return map;
+}
+
+module.exports = { buildCrossFileConstMap };