@eventra_dev/eventra-cli 0.0.6 → 0.0.8

package/dist/commands/init.js

@@ -5,29 +5,93 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = init;
 const chalk_1 = __importDefault(require("chalk"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const config_1 = require("../utils/config");
 async function init() {
     console.log(chalk_1.default.blue("Initializing Eventra..."));
-    const configPath = path_1.default.join(process.cwd(), config_1.CONFIG_NAME);
-    if (await fs_extra_1.default.pathExists(configPath)) {
-        console.log(chalk_1.default.yellow("eventra.json already exists"));
-        return;
-    }
-    const answers = await inquirer_1.default.prompt([
+    // API KEY
+    const { apiKey } = await inquirer_1.default.prompt([
         {
             type: "input",
             name: "apiKey",
             message: "API Key (optional):"
         }
     ]);
+    console.log(chalk_1.default.gray("\nEventra automatically detects:"));
+    console.log(chalk_1.default.gray("• track('event')"));
+    console.log(chalk_1.default.gray("• tracker.track('event')"));
+    const wrappers = [];
+    const functionWrappers = [];
+    // COMPONENT WRAPPERS
+    console.log(chalk_1.default.blue("\nComponent wrappers"));
+    let addComponent = true;
+    while (addComponent) {
+        const { useWrapper } = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "useWrapper",
+                message: "Add component wrapper?",
+                default: false
+            }
+        ]);
+        if (!useWrapper)
+            break;
+        const { name, prop } = await inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "name",
+                message: "Component name:",
+                validate: (v) => v ? true : "Required"
+            },
+            {
+                type: "input",
+                name: "prop",
+                message: "Event prop:",
+                default: "event"
+            }
+        ]);
+        wrappers.push({
+            name,
+            prop
+        });
+    }
+    // FUNCTION WRAPPERS
+    console.log(chalk_1.default.blue("\nFunction wrappers"));
+    let addFunction = true;
+    while (addFunction) {
+        const { useWrapper } = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "useWrapper",
+                message: "Add function wrapper?",
+                default: false
+            }
+        ]);
+        if (!useWrapper)
+            break;
+        const { name, event } = await inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "name",
+                message: "Function name:"
+            },
+            {
+                type: "input",
+                name: "event",
+                message: "Event field (leave empty if string argument):",
+                default: ""
+            }
+        ]);
+        functionWrappers.push({
+            name,
+            event: event || undefined
+        });
+    }
     const config = {
-        apiKey: answers.apiKey || "",
+        apiKey,
         events: [],
-        wrappers: [],
-        functionWrappers: [],
+        wrappers,
+        functionWrappers,
         sync: {
             include: [
                 "**/*.{ts,tsx,js,jsx,vue,svelte,astro}"
@@ -41,5 +105,6 @@ async function init() {
         }
     };
     await (0, config_1.saveConfig)(config);
-    console.log(chalk_1.default.green("eventra.json created"));
+    console.log(chalk_1.default.green("\neventra.json created"));
+    console.log(chalk_1.default.gray("\nRun `eventra sync`"));
 }

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,14 +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) => ({
-        ...w,
-        path: w.path ?? "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");
@@ -46,10 +43,47 @@ 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) {
+            if (!event)
+                continue;
+            const value = typeof event === "string"
+                ? event
+                : event.value;
+            const dynamic = typeof event === "string"
+                ? false
+                : event.dynamic;
+            // 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,68 @@
 "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);
-    }
-    if (ts_morph_1.Node.isStringLiteral(node)) {
-        return node.getLiteralText();
-    }
-    if (node.getKind() ===
+function extractExpression(expr) {
+    // "signup"
+    if (ts_morph_1.Node.isStringLiteral(expr)) {
+        return {
+            value: expr.getLiteralText(),
+            dynamic: false
+        };
+    }
+    // `signup`
+    if (expr.getKind() ===
         ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
-        return node
-            .getText()
-            .replace(/`/g, "");
+        return {
+            value: expr
+                .getText()
+                .replace(/`/g, ""),
+            dynamic: false
+        };
     }
-    return null;
-}
-function unwrap(node) {
-    let current = node;
-    while (ts_morph_1.Node.isParenthesizedExpression(current)) {
-        current = current.getExpression();
+    // template `${event}`
+    if (ts_morph_1.Node.isTemplateExpression(expr)) {
+        return {
+            value: expr.getText(),
+            dynamic: true
+        };
+    }
+    // ROUTES.APP
+    if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
+        return {
+            value: expr.getText(),
+            dynamic: true
+        };
+    }
+    // EVENT
+    if (ts_morph_1.Node.isIdentifier(expr)) {
+        return {
+            value: expr.getText(),
+            dynamic: true
+        };
     }
-    return current;
+    // getEvent()
+    if (ts_morph_1.Node.isCallExpression(expr)) {
+        return {
+            value: expr
+                .getExpression()
+                .getText(),
+            dynamic: true
+        };
+    }
+    // condition ? "a" : "b"
+    if (ts_morph_1.Node.isConditionalExpression(expr)) {
+        return {
+            value: expr.getText(),
+            dynamic: true
+        };
+    }
+    // array[index]
+    if (ts_morph_1.Node.isElementAccessExpression(expr)) {
+        return {
+            value: expr.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,21 @@ 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());
+                // event="signup"
+                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());
-                    }
+                // event={...}
+                if (ts_morph_1.Node.isJsxExpression(init)) {
+                    const expr = init.getExpression();
+                    if (!expr)
+                        continue;
+                    const result = (0, extract_1.extractExpression)(expr);
+                    if (result)
+                        events.add(result);
                 }
             }
         }

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

@@ -13,20 +13,18 @@ function scanFunctionWrappers(source, wrappers) {
         for (const wrapper of wrappers) {
             if (wrapper.name !== name)
                 continue;
-            const event = (0, extract_1.extractEvent)(call, wrapper.path ?? "0");
-            if (event)
-                events.add(event);
+            const result = extractEventFromArgs(call, wrapper.event);
+            if (result)
+                events.add(result);
         }
     }
     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);
     }
@@ -43,3 +41,31 @@ function getDeepName(node) {
     }
     return name;
 }
+function extractEventFromArgs(call, event) {
+    const args = call.getArguments();
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        // track("event")
+        if (!event) {
+            const result = (0, extract_1.extractExpression)(arg);
+            if (result)
+                return result;
+        }
+        // track({ event: "..." })
+        if (event) {
+            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;
+                return (0, extract_1.extractExpression)(init);
+            }
+        }
+    }
+    return null;
+}

package/package.json

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

package/src/commands/init.ts

@@ -1,45 +1,143 @@
 import chalk from "chalk";
-import fs from "fs-extra";
-import path from "path";
 import inquirer from "inquirer";
-import {
-  CONFIG_NAME,
-  saveConfig
-} from "../utils/config";
+
+import { saveConfig } from "../utils/config";
+import {ComponentWrapper, FunctionWrapper} from "../types";
 
 export async function init() {
   console.log(
     chalk.blue("Initializing Eventra...")
   );
 
-  const configPath = path.join(
-    process.cwd(),
-    CONFIG_NAME
+  // API KEY
+  const { apiKey } =
+    await inquirer.prompt([
+      {
+        type: "input",
+        name: "apiKey",
+        message:
+          "API Key (optional):"
+      }
+    ]);
+
+  console.log(
+    chalk.gray(
+      "\nEventra automatically detects:"
+    )
+  );
+
+  console.log(
+    chalk.gray("• track('event')")
+  );
+
+  console.log(
+    chalk.gray(
+      "• tracker.track('event')"
+    )
   );
 
-  if (await fs.pathExists(configPath)) {
-    console.log(
-      chalk.yellow(
-        "eventra.json already exists"
-      )
-    );
-    return;
+  const wrappers: ComponentWrapper[] = [];
+  const functionWrappers: FunctionWrapper[] = [];
+
+
+  // COMPONENT WRAPPERS
+  console.log(
+    chalk.blue(
+      "\nComponent wrappers"
+    )
+  );
+
+  let addComponent = true;
+
+  while (addComponent) {
+    const { useWrapper } =
+      await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "useWrapper",
+          message:
+            "Add component wrapper?",
+          default: false
+        }
+      ]);
+
+    if (!useWrapper) break;
+
+    const { name, prop } =
+      await inquirer.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "Component name:",
+          validate: (v) =>
+            v ? true : "Required"
+        },
+        {
+          type: "input",
+          name: "prop",
+          message:
+            "Event prop:",
+          default: "event"
+        }
+      ]);
+
+    wrappers.push({
+      name,
+      prop
+    });
   }
 
-  const answers = await inquirer.prompt([
-    {
-      type: "input",
-      name: "apiKey",
-      message:
-        "API Key (optional):"
-    }
-  ]);
+  // FUNCTION WRAPPERS
+  console.log(
+    chalk.blue(
+      "\nFunction wrappers"
+    )
+  );
+
+  let addFunction = true;
+
+  while (addFunction) {
+    const { useWrapper } =
+      await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "useWrapper",
+          message:
+            "Add function wrapper?",
+          default: false
+        }
+      ]);
+
+    if (!useWrapper) break;
+
+    const { name, event } =
+      await inquirer.prompt([
+        {
+          type: "input",
+          name: "name",
+          message:
+            "Function name:"
+        },
+        {
+          type: "input",
+          name: "event",
+          message:
+            "Event field (leave empty if string argument):",
+          default: ""
+        }
+      ]);
+
+    functionWrappers.push({
+      name,
+      event: event || undefined
+    });
+  }
 
   const config = {
-    apiKey: answers.apiKey || "",
+    apiKey,
     events: [],
-    wrappers: [],
-    functionWrappers: [],
+    wrappers,
+    functionWrappers,
     sync: {
       include: [
         "**/*.{ts,tsx,js,jsx,vue,svelte,astro}"
@@ -57,7 +155,13 @@ export async function init() {
 
   console.log(
     chalk.green(
-      "eventra.json created"
+      "\neventra.json created"
+    )
+  );
+
+  console.log(
+    chalk.gray(
+      "\nRun `eventra sync`"
     )
   );
 }

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,
@@ -34,6 +35,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,17 +45,6 @@ export async function sync() {
     }
   );
 
-  const functionWrappers =
-    (config.functionWrappers ?? []).map(
-      (w) => ({
-        ...w,
-        path: w.path ?? "0"
-      })
-    );
-
-  const componentWrappers =
-    config.wrappers ?? [];
-
   for (const file of files) {
     const parser =
       detectParser(file);
@@ -83,26 +76,78 @@ 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 = [
+      ...scanTrack(source),
+      ...scanFunctionWrappers(
+        source,
+        config.functionWrappers ?? []
+      ),
+      ...scanComponentWrappers(
+        source,
+        config.wrappers ?? []
+      )
+    ];
+
+    for (const event of found) {
+      if (!event) continue;
+
+      const value =
+        typeof event === "string"
+          ? event
+          : event.value;
+
+      const dynamic =
+        typeof event === "string"
+          ? false
+          : event.dynamic;
+
+      // 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

@@ -5,7 +5,7 @@ export type ComponentWrapper = {
 
 export type FunctionWrapper = {
   name: string;
-  path?: string;
+  event?: string;
 };
 
 export type EventraConfig = {
@@ -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,97 @@
 import {
-  CallExpression,
   Node,
-  ObjectLiteralExpression,
-  SyntaxKind,
+  SyntaxKind
 } from "ts-morph";
 
-export function extractEvent(
-  call: CallExpression,
-  path: string
-): string | null {
-  const parts = path.split(".");
+import { ExtractedEvent } from "../types";
 
-  let node: Node | undefined =
-    call.getArguments()[Number(parts[0])];
+export function extractExpression(
+  expr: Node
+): ExtractedEvent | null {
 
-  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();
+  // "signup"
+  if (Node.isStringLiteral(expr)) {
+    return {
+      value: expr.getLiteralText(),
+      dynamic: false
+    };
+  }
 
-    if (!initializer) return null;
+  // `signup`
+  if (
+    expr.getKind() ===
+    SyntaxKind.NoSubstitutionTemplateLiteral
+  ) {
+    return {
+      value: expr
+        .getText()
+        .replace(/`/g, ""),
+      dynamic: false
+    };
+  }
 
-    node = unwrap(initializer);
+  // template `${event}`
+  if (
+    Node.isTemplateExpression(expr)
+  ) {
+    return {
+      value: expr.getText(),
+      dynamic: true
+    };
   }
 
-  if (Node.isStringLiteral(node)) {
-    return node.getLiteralText();
+  // ROUTES.APP
+  if (
+    Node.isPropertyAccessExpression(expr)
+  ) {
+    return {
+      value: expr.getText(),
+      dynamic: true
+    };
   }
 
+  // EVENT
   if (
-    node.getKind() ===
-    SyntaxKind.NoSubstitutionTemplateLiteral
+    Node.isIdentifier(expr)
   ) {
-    return node
-      .getText()
-      .replace(/`/g, "");
+    return {
+      value: expr.getText(),
+      dynamic: true
+    };
   }
 
-  return null;
-}
+  // getEvent()
+  if (
+    Node.isCallExpression(expr)
+  ) {
+    return {
+      value:
+        expr
+          .getExpression()
+          .getText(),
+      dynamic: true
+    };
+  }
 
-function unwrap(node: Node): Node {
-  let current = node;
+  // condition ? "a" : "b"
+  if (
+    Node.isConditionalExpression(expr)
+  ) {
+    return {
+      value: expr.getText(),
+      dynamic: true
+    };
+  }
 
-  while (
-    Node.isParenthesizedExpression(
-      current
-    )
-    ) {
-    current = current.getExpression();
+  // array[index]
+  if (
+    Node.isElementAccessExpression(expr)
+  ) {
+    return {
+      value: expr.getText(),
+      dynamic: true
+    };
   }
 
-  return current;
+  return null;
 }

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

@@ -1,15 +1,18 @@
 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 +64,31 @@ export function scanComponentWrappers(
 
         if (!init) continue;
 
+        // event="signup"
         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
+          });
         }
 
+        // event={...}
         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)
+            events.add(result);
         }
       }
     }

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

@@ -6,14 +6,15 @@ import {
   PropertyAccessExpression,
 } from "ts-morph";
 
-import { extractEvent } from "../extract";
-import { FunctionWrapper } from "../../types";
+import { extractExpression } from "../extract";
+import { FunctionWrapper, ExtractedEvent } from "../../types";
 
 export function scanFunctionWrappers(
   source: SourceFile,
   wrappers: FunctionWrapper[]
 ) {
-  const events = new Set<string>();
+  const events =
+    new Set<ExtractedEvent>();
 
   const calls =
     source.getDescendantsOfKind(
@@ -30,14 +31,14 @@ export function scanFunctionWrappers(
       if (wrapper.name !== name)
         continue;
 
-      const event =
-        extractEvent(
+      const result =
+        extractEventFromArgs(
           call,
-          wrapper.path ?? "0"
+          wrapper.event
         );
 
-      if (event)
-        events.add(event);
+      if (result)
+        events.add(result);
     }
   }
 
@@ -50,16 +51,12 @@ function getFunctionName(
   const expression =
     call.getExpression();
 
-  // trackFeature()
   if (
-    Node.isIdentifier(
-      expression
-    )
+    Node.isIdentifier(expression)
   ) {
     return expression.getText();
   }
 
-  // analytics.trackFeature()
   if (
     Node.isPropertyAccessExpression(
       expression
@@ -96,3 +93,55 @@ function getDeepName(
 
   return name;
 }
+
+function extractEventFromArgs(
+  call: CallExpression,
+  event?: string
+): ExtractedEvent | null {
+
+  const args =
+    call.getArguments();
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    // track("event")
+    if (!event) {
+      const result =
+        extractExpression(arg);
+
+      if (result)
+        return result;
+    }
+
+    // track({ event: "..." })
+    if (event) {
+      const obj =
+        arg.asKind(
+          SyntaxKind.ObjectLiteralExpression
+        );
+
+      if (!obj) continue;
+
+      const prop =
+        obj.getProperty(event);
+
+      if (!prop) continue;
+
+      if (
+        Node.isPropertyAssignment(prop)
+      ) {
+        const init =
+          prop.getInitializer();
+
+        if (!init) continue;
+
+        return extractExpression(
+          init
+        );
+      }
+    }
+  }
+
+  return null;
+}