@eventra_dev/eventra-cli 0.0.7 → 0.0.9

package/dist/commands/sync.js

@@ -8,6 +8,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const ts_morph_1 = require("ts-morph");
 const promises_1 = __importDefault(require("fs/promises"));
+const inquirer_1 = __importDefault(require("inquirer"));
 const config_1 = require("../utils/config");
 const router_1 = require("../utils/parsers/router");
 const vue_1 = require("../utils/parsers/vue");
@@ -25,16 +26,10 @@ async function sync() {
     console.log(chalk_1.default.blue("Scanning project..."));
     const project = new ts_morph_1.Project();
     const events = new Set();
+    const aliases = config.aliases ?? {};
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude
     });
-    const functionWrappers = (config.functionWrappers ?? []).map((w) => ({
-        name: w.name,
-        path: w.event
-            ? `0.${w.event}`
-            : "0"
-    }));
-    const componentWrappers = config.wrappers ?? [];
     for (const file of files) {
         const parser = (0, router_1.detectParser)(file);
         let content = await promises_1.default.readFile(file, "utf-8");
@@ -48,10 +43,40 @@ async function sync() {
             ? file
             : file + ".tsx";
         const source = project.createSourceFile(virtualFile, content, { overwrite: true });
-        (0, track_1.scanTrack)(source).forEach((e) => events.add(e));
-        (0, function_wrappers_1.scanFunctionWrappers)(source, functionWrappers).forEach((e) => events.add(e));
-        (0, component_wrappers_1.scanComponentWrappers)(source, componentWrappers).forEach((e) => events.add(e));
+        const found = [
+            ...(0, track_1.scanTrack)(source),
+            ...(0, function_wrappers_1.scanFunctionWrappers)(source, config.functionWrappers ?? []),
+            ...(0, component_wrappers_1.scanComponentWrappers)(source, config.wrappers ?? [])
+        ];
+        for (const event of found) {
+            const { value, dynamic } = event;
+            // alias exists
+            if (aliases[value]) {
+                events.add(aliases[value]);
+                continue;
+            }
+            // dynamic event
+            if (dynamic) {
+                console.log(chalk_1.default.yellow("\nDynamic event detected:"));
+                console.log(chalk_1.default.gray(value));
+                const { name } = await inquirer_1.default.prompt([
+                    {
+                        type: "input",
+                        name: "name",
+                        message: "Enter event name:",
+                        validate: (v) => v
+                            ? true
+                            : "Required"
+                    }
+                ]);
+                aliases[value] = name;
+                events.add(name);
+                continue;
+            }
+            events.add(value);
+        }
     }
+    config.aliases = aliases;
     const list = [...events].sort();
     config.events = list;
     await (0, config_1.saveConfig)(config);

package/dist/utils/extract.js

@@ -1,44 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractEvent = extractEvent;
+exports.extractExpression = extractExpression;
 const ts_morph_1 = require("ts-morph");
-function extractEvent(call, path) {
-    const parts = path.split(".");
-    let node = call.getArguments()[Number(parts[0])];
-    if (!node)
-        return null;
-    node = unwrap(node);
-    for (let i = 1; i < parts.length; i++) {
-        if (!ts_morph_1.Node.isObjectLiteralExpression(node)) {
-            return null;
-        }
-        const obj = node;
-        const prop = obj.getProperty(parts[i]);
-        if (!prop)
-            return null;
-        if (!ts_morph_1.Node.isPropertyAssignment(prop)) {
-            return null;
-        }
-        const initializer = prop.getInitializer();
-        if (!initializer)
-            return null;
-        node = unwrap(initializer);
+function extractExpression(expr) {
+    // "event"
+    if (ts_morph_1.Node.isStringLiteral(expr)) {
+        return {
+            values: [expr.getLiteralText()],
+            dynamic: false
+        };
     }
-    if (ts_morph_1.Node.isStringLiteral(node)) {
-        return node.getLiteralText();
-    }
-    if (node.getKind() ===
+    // `event`
+    if (expr.getKind() ===
         ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
-        return node
-            .getText()
-            .replace(/`/g, "");
+        return {
+            values: [
+                expr
+                    .getText()
+                    .replace(/`/g, "")
+            ],
+            dynamic: false
+        };
     }
-    return null;
-}
-function unwrap(node) {
-    let current = node;
-    while (ts_morph_1.Node.isParenthesizedExpression(current)) {
-        current = current.getExpression();
+    // identifier
+    if (ts_morph_1.Node.isIdentifier(expr)) {
+        return {
+            values: [expr.getText()],
+            dynamic: true
+        };
+    }
+    // property access (ROUTES.ACCOUNT)
+    if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
+        return {
+            values: [expr.getText()],
+            dynamic: true
+        };
     }
-    return current;
+    // ternary
+    if (ts_morph_1.Node.isConditionalExpression(expr)) {
+        const values = [];
+        const whenTrue = extractExpression(expr.getWhenTrue());
+        const whenFalse = extractExpression(expr.getWhenFalse());
+        if (whenTrue)
+            values.push(...whenTrue.values);
+        if (whenFalse)
+            values.push(...whenFalse.values);
+        return {
+            values,
+            dynamic: true
+        };
+    }
+    // template
+    if (ts_morph_1.Node.isTemplateExpression(expr)) {
+        return {
+            values: [expr.getText()],
+            dynamic: true
+        };
+    }
+    // call
+    if (ts_morph_1.Node.isCallExpression(expr)) {
+        return {
+            values: [
+                expr
+                    .getExpression()
+                    .getText()
+            ],
+            dynamic: true
+        };
+    }
+    return null;
 }

package/dist/utils/scanners/component-wrappers.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanComponentWrappers = scanComponentWrappers;
 const ts_morph_1 = require("ts-morph");
+const extract_1 = require("../extract");
 function scanComponentWrappers(source, wrappers) {
     const events = new Set();
     const elements = [
@@ -32,21 +33,25 @@ function scanComponentWrappers(source, wrappers) {
                 const init = attrNode.getInitializer();
                 if (!init)
                     continue;
-                if (init.getKind() ===
-                    ts_morph_1.SyntaxKind.StringLiteral) {
-                    const value = init.asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral);
-                    events.add(value.getLiteralText());
+                // string
+                if (ts_morph_1.Node.isStringLiteral(init)) {
+                    events.add({
+                        value: init.getLiteralText(),
+                        dynamic: false
+                    });
                 }
-                if (init.getKind() ===
-                    ts_morph_1.SyntaxKind.JsxExpression) {
-                    const expr = init
-                        .asKindOrThrow(ts_morph_1.SyntaxKind.JsxExpression)
-                        .getExpression();
-                    if (expr?.getKind() ===
-                        ts_morph_1.SyntaxKind.StringLiteral) {
-                        const value = expr.asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral);
-                        events.add(value.getLiteralText());
-                    }
+                // jsx expression
+                if (ts_morph_1.Node.isJsxExpression(init)) {
+                    const expr = init.getExpression();
+                    if (!expr)
+                        continue;
+                    const result = (0, extract_1.extractExpression)(expr);
+                    if (!result)
+                        continue;
+                    result.values.forEach((value) => events.add({
+                        value,
+                        dynamic: result.dynamic
+                    }));
                 }
             }
         }

package/dist/utils/scanners/function-wrappers.js

@@ -13,20 +13,19 @@ function scanFunctionWrappers(source, wrappers) {
         for (const wrapper of wrappers) {
             if (wrapper.name !== name)
                 continue;
-            const event = extractEventFromArgs(call, wrapper.event);
-            if (event)
-                events.add(event);
+            const results = extractEventFromArgs(call, wrapper.event);
+            if (!results)
+                continue;
+            results.forEach((r) => events.add(r));
         }
     }
     return events;
 }
 function getFunctionName(call) {
     const expression = call.getExpression();
-    // trackFeature()
     if (ts_morph_1.Node.isIdentifier(expression)) {
         return expression.getText();
     }
-    // analytics.trackFeature()
     if (ts_morph_1.Node.isPropertyAccessExpression(expression)) {
         return getDeepName(expression);
     }
@@ -45,27 +44,42 @@ function getDeepName(node) {
 }
 function extractEventFromArgs(call, event) {
     const args = call.getArguments();
+    const events = [];
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
-        // string case
+        // track("event")
         if (!event) {
-            if (ts_morph_1.Node.isStringLiteral(arg)) {
-                return arg.getLiteralText();
-            }
-            // template literal
-            if (arg.getKind() ===
-                ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
-                return arg
-                    .getText()
-                    .replace(/`/g, "");
-            }
+            const result = (0, extract_1.extractExpression)(arg);
+            if (!result)
+                continue;
+            result.values.forEach((value) => events.push({
+                value,
+                dynamic: result.dynamic
+            }));
         }
-        // object case
+        // track({event})
         if (event) {
-            const result = (0, extract_1.extractEvent)(call, `${i}.${event}`);
-            if (result)
-                return result;
+            const obj = arg.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+            if (!obj)
+                continue;
+            const prop = obj.getProperty(event);
+            if (!prop)
+                continue;
+            if (ts_morph_1.Node.isPropertyAssignment(prop)) {
+                const init = prop.getInitializer();
+                if (!init)
+                    continue;
+                const result = (0, extract_1.extractExpression)(init);
+                if (!result)
+                    continue;
+                result.values.forEach((value) => events.push({
+                    value,
+                    dynamic: result.dynamic
+                }));
+            }
         }
     }
-    return null;
+    return events.length
+        ? events
+        : null;
 }

package/dist/utils/scanners/track.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanTrack = scanTrack;
 const ts_morph_1 = require("ts-morph");
+const extract_1 = require("../extract");
 function scanTrack(source) {
     const events = new Set();
     const calls = source.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
@@ -9,34 +10,27 @@ function scanTrack(source) {
         const expr = call.getExpression();
         let isTrack = false;
         // track()
-        if (expr.getKind() ===
-            ts_morph_1.SyntaxKind.Identifier) {
+        if (ts_morph_1.Node.isIdentifier(expr)) {
             isTrack =
                 expr.getText() === "track";
         }
         // analytics.track()
-        if (expr.getKind() ===
-            ts_morph_1.SyntaxKind.PropertyAccessExpression) {
-            const prop = expr.asKindOrThrow(ts_morph_1.SyntaxKind.PropertyAccessExpression);
+        if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
             isTrack =
-                prop.getName() === "track";
+                expr.getName() === "track";
         }
         if (!isTrack)
             continue;
         const arg = call.getArguments()[0];
         if (!arg)
             continue;
-        if (arg.getKind() ===
-            ts_morph_1.SyntaxKind.StringLiteral) {
-            const value = arg.asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral);
-            events.add(value.getLiteralText());
-        }
-        // template literal
-        if (arg.getKind() ===
-            ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
-            const value = arg.asKindOrThrow(ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral);
-            events.add(value.getLiteralText());
-        }
+        const result = (0, extract_1.extractExpression)(arg);
+        if (!result)
+            continue;
+        result.values.forEach((value) => events.add({
+            value,
+            dynamic: result.dynamic
+        }));
     }
     return events;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {

package/src/commands/sync.ts

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import fg from "fast-glob";
 import { Project } from "ts-morph";
 import fs from "fs/promises";
+import inquirer from "inquirer";
 
 import {
   loadConfig,
@@ -17,6 +18,8 @@ import { scanTrack } from "../utils/scanners/track";
 import { scanFunctionWrappers } from "../utils/scanners/function-wrappers";
 import { scanComponentWrappers } from "../utils/scanners/component-wrappers";
 
+import { ExtractedEvent } from "../types";
+
 export async function sync() {
   const config = await loadConfig();
 
@@ -34,6 +37,9 @@ export async function sync() {
   const project = new Project();
   const events = new Set<string>();
 
+  const aliases =
+    config.aliases ?? {};
+
   const files = await fg(
     config.sync.include,
     {
@@ -41,18 +47,6 @@ export async function sync() {
     }
   );
 
-  const functionWrappers =
-    (config.functionWrappers ?? []).map(
-      (w) => ({
-        name: w.name,
-        path: w.event
-          ? `0.${w.event}`
-          : "0"
-      })
-    );
-  const componentWrappers =
-    config.wrappers ?? [];
-
   for (const file of files) {
     const parser =
       detectParser(file);
@@ -84,26 +78,68 @@ export async function sync() {
         { overwrite: true }
       );
 
-    scanTrack(source).forEach(
-      (e) => events.add(e)
-    );
-
-
-    scanFunctionWrappers(
-      source,
-      functionWrappers
-    ).forEach((e) =>
-      events.add(e)
-    );
-
-    scanComponentWrappers(
-      source,
-      componentWrappers
-    ).forEach((e) =>
-      events.add(e)
-    );
+    const found: ExtractedEvent[] = [
+      ...scanTrack(source),
+      ...scanFunctionWrappers(
+        source,
+        config.functionWrappers ?? []
+      ),
+      ...scanComponentWrappers(
+        source,
+        config.wrappers ?? []
+      )
+    ];
+
+    for (const event of found) {
+      const { value, dynamic } = event;
+
+      // alias exists
+      if (aliases[value]) {
+        events.add(
+          aliases[value]
+        );
+        continue;
+      }
+
+      // dynamic event
+      if (dynamic) {
+        console.log(
+          chalk.yellow(
+            "\nDynamic event detected:"
+          )
+        );
+
+        console.log(
+          chalk.gray(value)
+        );
+
+        const { name } =
+          await inquirer.prompt([
+            {
+              type: "input",
+              name: "name",
+              message:
+                "Enter event name:",
+              validate: (v) =>
+                v
+                  ? true
+                  : "Required"
+            }
+          ]);
+
+        aliases[value] = name;
+
+        events.add(name);
+
+        continue;
+      }
+
+      events.add(value);
+    }
   }
 
+  config.aliases = aliases;
+
   const list =
     [...events].sort();
 

package/src/types.ts

@@ -13,8 +13,14 @@ export type EventraConfig = {
   events: string[];
   wrappers: ComponentWrapper[];
   functionWrappers: FunctionWrapper[];
+  aliases?: Record<string, string>;
   sync: {
     include: string[];
     exclude: string[];
   };
 };
+
+export type ExtractedEvent = {
+  value: string;
+  dynamic: boolean;
+};

package/src/utils/extract.ts

@@ -1,74 +1,115 @@
 import {
-  CallExpression,
   Node,
-  ObjectLiteralExpression,
-  SyntaxKind,
+  SyntaxKind
 } from "ts-morph";
 
-export function extractEvent(
-  call: CallExpression,
-  path: string
-): string | null {
-  const parts = path.split(".");
-
-  let node: Node | undefined =
-    call.getArguments()[Number(parts[0])];
-
-  if (!node) return null;
-
-  node = unwrap(node);
-
-  for (let i = 1; i < parts.length; i++) {
-    if (!Node.isObjectLiteralExpression(node)) {
-      return null;
-    }
-
-    const obj: ObjectLiteralExpression =
-      node;
-
-    const prop =
-      obj.getProperty(parts[i]);
-
-    if (!prop) return null;
-
-    if (!Node.isPropertyAssignment(prop)) {
-      return null;
-    }
-
-    const initializer =
-      prop.getInitializer();
-
-    if (!initializer) return null;
+export type ExtractResult = {
+  values: string[];
+  dynamic: boolean;
+};
+
+export function extractExpression(
+  expr: Node
+): ExtractResult | null {
+
+  // "event"
+  if (Node.isStringLiteral(expr)) {
+    return {
+      values: [expr.getLiteralText()],
+      dynamic: false
+    };
+  }
 
-    node = unwrap(initializer);
+  // `event`
+  if (
+    expr.getKind() ===
+    SyntaxKind.NoSubstitutionTemplateLiteral
+  ) {
+    return {
+      values: [
+        expr
+          .getText()
+          .replace(/`/g, "")
+      ],
+      dynamic: false
+    };
   }
 
-  if (Node.isStringLiteral(node)) {
-    return node.getLiteralText();
+  // identifier
+  if (
+    Node.isIdentifier(expr)
+  ) {
+    return {
+      values: [expr.getText()],
+      dynamic: true
+    };
   }
 
+  // property access (ROUTES.ACCOUNT)
   if (
-    node.getKind() ===
-    SyntaxKind.NoSubstitutionTemplateLiteral
+    Node.isPropertyAccessExpression(expr)
   ) {
-    return node
-      .getText()
-      .replace(/`/g, "");
+    return {
+      values: [expr.getText()],
+      dynamic: true
+    };
   }
 
-  return null;
-}
+  // ternary
+  if (
+    Node.isConditionalExpression(expr)
+  ) {
+    const values: string[] = [];
+
+    const whenTrue =
+      extractExpression(
+        expr.getWhenTrue()
+      );
+
+    const whenFalse =
+      extractExpression(
+        expr.getWhenFalse()
+      );
+
+    if (whenTrue)
+      values.push(
+        ...whenTrue.values
+      );
+
+    if (whenFalse)
+      values.push(
+        ...whenFalse.values
+      );
+
+    return {
+      values,
+      dynamic: true
+    };
+  }
 
-function unwrap(node: Node): Node {
-  let current = node;
+  // template
+  if (
+    Node.isTemplateExpression(expr)
+  ) {
+    return {
+      values: [expr.getText()],
+      dynamic: true
+    };
+  }
 
-  while (
-    Node.isParenthesizedExpression(
-      current
-    )
-    ) {
-    current = current.getExpression();
+  // call
+  if (
+    Node.isCallExpression(expr)
+  ) {
+    return {
+      values: [
+        expr
+          .getExpression()
+          .getText()
+      ],
+      dynamic: true
+    };
   }
 
-  return current;
+  return null;
 }

package/src/utils/scanners/component-wrappers.ts

@@ -1,15 +1,22 @@
 import {
   SourceFile,
   SyntaxKind,
+  Node
 } from "ts-morph";
 
-import { ComponentWrapper } from "../../types";
+import {
+  ComponentWrapper,
+  ExtractedEvent
+} from "../../types";
+
+import { extractExpression } from "../extract";
 
 export function scanComponentWrappers(
   source: SourceFile,
   wrappers: ComponentWrapper[]
 ) {
-  const events = new Set<string>();
+  const events =
+    new Set<ExtractedEvent>();
 
   const elements = [
     ...source.getDescendantsOfKind(
@@ -61,44 +68,39 @@ export function scanComponentWrappers(
 
         if (!init) continue;
 
+        // string
         if (
-          init.getKind() ===
-          SyntaxKind.StringLiteral
+          Node.isStringLiteral(init)
         ) {
-          const value =
-            init.asKindOrThrow(
-              SyntaxKind.StringLiteral
-            );
-
-          events.add(
-            value.getLiteralText()
-          );
+          events.add({
+            value:
+              init.getLiteralText(),
+            dynamic: false
+          });
         }
 
+        // jsx expression
         if (
-          init.getKind() ===
-          SyntaxKind.JsxExpression
+          Node.isJsxExpression(init)
         ) {
           const expr =
-            init
-              .asKindOrThrow(
-                SyntaxKind.JsxExpression
-              )
-              .getExpression();
-
-          if (
-            expr?.getKind() ===
-            SyntaxKind.StringLiteral
-          ) {
-            const value =
-              expr.asKindOrThrow(
-                SyntaxKind.StringLiteral
-              );
-
-            events.add(
-              value.getLiteralText()
-            );
-          }
+            init.getExpression();
+
+          if (!expr) continue;
+
+          const result =
+            extractExpression(expr);
+
+          if (!result) continue;
+
+          result.values.forEach(
+            (value) =>
+              events.add({
+                value,
+                dynamic:
+                result.dynamic
+              })
+          );
         }
       }
     }

package/src/utils/scanners/function-wrappers.ts

@@ -6,14 +6,19 @@ import {
   PropertyAccessExpression,
 } from "ts-morph";
 
-import { extractEvent } from "../extract";
-import { FunctionWrapper } from "../../types";
+import {
+  FunctionWrapper,
+  ExtractedEvent
+} from "../../types";
+
+import { extractExpression } from "../extract";
 
 export function scanFunctionWrappers(
   source: SourceFile,
   wrappers: FunctionWrapper[]
 ) {
-  const events = new Set<string>();
+  const events =
+    new Set<ExtractedEvent>();
 
   const calls =
     source.getDescendantsOfKind(
@@ -30,14 +35,17 @@ export function scanFunctionWrappers(
       if (wrapper.name !== name)
         continue;
 
-      const event =
+      const results =
         extractEventFromArgs(
           call,
           wrapper.event
         );
 
-      if (event)
-        events.add(event);
+      if (!results) continue;
+
+      results.forEach(
+        (r) => events.add(r)
+      );
     }
   }
 
@@ -47,10 +55,10 @@ export function scanFunctionWrappers(
 function getFunctionName(
   call: CallExpression
 ): string | null {
+
   const expression =
     call.getExpression();
 
-  // trackFeature()
   if (
     Node.isIdentifier(
       expression
@@ -59,7 +67,6 @@ function getFunctionName(
     return expression.getText();
   }
 
-  // analytics.trackFeature()
   if (
     Node.isPropertyAccessExpression(
       expression
@@ -76,6 +83,7 @@ function getFunctionName(
 function getDeepName(
   node: PropertyAccessExpression
 ): string {
+
   let current:
     | Node
     | undefined = node;
@@ -97,44 +105,76 @@ function getDeepName(
   return name;
 }
 
-
 function extractEventFromArgs(
   call: CallExpression,
   event?: string
-): string | null {
-  const args = call.getArguments();
+): ExtractedEvent[] | null {
+
+  const args =
+    call.getArguments();
+
+  const events: ExtractedEvent[] = [];
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
 
-    // string case
+    // track("event")
     if (!event) {
-      if (Node.isStringLiteral(arg)) {
-        return arg.getLiteralText();
-      }
-
-      // template literal
-      if (
-        arg.getKind() ===
-        SyntaxKind.NoSubstitutionTemplateLiteral
-      ) {
-        return arg
-          .getText()
-          .replace(/`/g, "");
-      }
+      const result =
+        extractExpression(arg);
+
+      if (!result) continue;
+
+      result.values.forEach(
+        (value) =>
+          events.push({
+            value,
+            dynamic:
+            result.dynamic
+          })
+      );
     }
 
-    // object case
+    // track({event})
     if (event) {
-      const result =
-        extractEvent(
-          call,
-          `${i}.${event}`
+      const obj =
+        arg.asKind(
+          SyntaxKind.ObjectLiteralExpression
         );
 
-      if (result) return result;
+      if (!obj) continue;
+
+      const prop =
+        obj.getProperty(event);
+
+      if (!prop) continue;
+
+      if (
+        Node.isPropertyAssignment(prop)
+      ) {
+        const init =
+          prop.getInitializer();
+
+        if (!init) continue;
+
+        const result =
+          extractExpression(init);
+
+        if (!result) continue;
+
+        result.values.forEach(
+          (value) =>
+            events.push({
+              value,
+              dynamic:
+              result.dynamic
+            })
+        );
+      }
     }
   }
 
-  return null;
+  return events.length
+    ? events
+    : null;
 }

package/src/utils/scanners/track.ts

@@ -1,13 +1,19 @@
 import {
   SourceFile,
-  SyntaxKind
+  SyntaxKind,
+  Node,
+  CallExpression,
+  PropertyAccessExpression
 } from "ts-morph";
 
+import { ExtractedEvent } from "../../types";
+import { extractExpression } from "../extract";
+
 export function scanTrack(
   source: SourceFile
 ) {
   const events =
-    new Set<string>();
+    new Set<ExtractedEvent>();
 
   const calls =
     source.getDescendantsOfKind(
@@ -22,8 +28,7 @@ export function scanTrack(
 
     // track()
     if (
-      expr.getKind() ===
-      SyntaxKind.Identifier
+      Node.isIdentifier(expr)
     ) {
       isTrack =
         expr.getText() === "track";
@@ -31,16 +36,12 @@ export function scanTrack(
 
     // analytics.track()
     if (
-      expr.getKind() ===
-      SyntaxKind.PropertyAccessExpression
+      Node.isPropertyAccessExpression(
+        expr
+      )
     ) {
-      const prop =
-        expr.asKindOrThrow(
-          SyntaxKind.PropertyAccessExpression
-        );
-
       isTrack =
-        prop.getName() === "track";
+        expr.getName() === "track";
     }
 
     if (!isTrack) continue;
@@ -50,34 +51,19 @@ export function scanTrack(
 
     if (!arg) continue;
 
-    if (
-      arg.getKind() ===
-      SyntaxKind.StringLiteral
-    ) {
-      const value =
-        arg.asKindOrThrow(
-          SyntaxKind.StringLiteral
-        );
-
-      events.add(
-        value.getLiteralText()
-      );
-    }
+    const result =
+      extractExpression(arg);
 
-    // template literal
-    if (
-      arg.getKind() ===
-      SyntaxKind.NoSubstitutionTemplateLiteral
-    ) {
-      const value =
-        arg.asKindOrThrow(
-          SyntaxKind.NoSubstitutionTemplateLiteral
-        );
+    if (!result) continue;
 
-      events.add(
-        value.getLiteralText()
-      );
-    }
+    result.values.forEach(
+      (value) =>
+        events.add({
+          value,
+          dynamic:
+          result.dynamic
+        })
+    );
   }
 
   return events;