@eventra_dev/eventra-cli 0.0.17 → 0.0.19

package/src/utils/detect-aliases.ts

@@ -0,0 +1,46 @@
+import {
+  SourceFile,
+  SyntaxKind,
+  Node
+} from "ts-morph";
+
+export function detectAliases(source: SourceFile) {
+  const aliases: Record<string, string> = {};
+
+  const vars = source.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+
+  for (const v of vars) {
+    const name = v.getName();
+    const init = v.getInitializer();
+    if (!init) continue;
+
+    // const A = "event"
+    if (Node.isStringLiteral(init)) {
+      aliases[name] = init.getLiteralText();
+      continue;
+    }
+
+    // const A = `event`
+    if (init.getKind() === SyntaxKind.NoSubstitutionTemplateLiteral) {
+      aliases[name] = init.getText().replace(/`/g, "");
+      continue;
+    }
+
+    // const EVENTS = { CLICK: "click" }
+    if (Node.isObjectLiteralExpression(init)) {
+      for (const p of init.getProperties()) {
+        if (!Node.isPropertyAssignment(p)) continue;
+
+        const key = p.getName();
+        const val = p.getInitializer();
+        if (!val) continue;
+
+        if (Node.isStringLiteral(val)) {
+          aliases[`${name}.${key}`] = val.getLiteralText();
+        }
+      }
+    }
+  }
+
+  return aliases;
+}

package/src/utils/detect-wrappers.ts

@@ -0,0 +1,119 @@
+import {
+  SourceFile,
+  SyntaxKind,
+  Node,
+  CallExpression
+} from "ts-morph";
+
+export type FunctionWrapper = {
+  name: string;
+  event?: string;
+};
+
+export type ComponentWrapper = {
+  name: string;
+  prop: string;
+};
+
+export function detectWrappers(source: SourceFile) {
+  return {
+    functions: detectFunctionWrappers(source),
+    components: detectComponentWrappers(source)
+  };
+}
+
+// FUNCTIONS
+function detectFunctionWrappers(source: SourceFile): FunctionWrapper[] {
+  const result = new Map<string, FunctionWrapper>();
+
+  const functions = [
+    ...source.getDescendantsOfKind(SyntaxKind.FunctionDeclaration),
+    ...source.getDescendantsOfKind(SyntaxKind.ArrowFunction),
+    ...source.getDescendantsOfKind(SyntaxKind.FunctionExpression)
+  ];
+
+  for (const fn of functions) {
+    const body = fn.getBody();
+    if (!body) continue;
+
+    const calls = body.getDescendantsOfKind(SyntaxKind.CallExpression);
+
+    for (const call of calls) {
+      if (!isTrackCall(call)) continue;
+
+      const name = getFunctionName(fn);
+      if (!name) continue;
+
+      const arg = call.getArguments()[0];
+
+      let eventField: string | undefined;
+
+      if (arg && Node.isObjectLiteralExpression(arg)) {
+        const prop = arg.getProperties()[0];
+        if (prop && Node.isPropertyAssignment(prop)) {
+          eventField = prop.getName();
+        }
+      }
+
+      result.set(name, { name, event: eventField });
+    }
+  }
+
+  return [...result.values()];
+}
+
+function isTrackCall(call: CallExpression) {
+  const expr = call.getExpression();
+
+  if (Node.isIdentifier(expr)) {
+    return expr.getText() === "track";
+  }
+
+  if (Node.isPropertyAccessExpression(expr)) {
+    return expr.getName() === "track";
+  }
+
+  return false;
+}
+
+function getFunctionName(fn: Node): string | null {
+  if (Node.isFunctionDeclaration(fn)) {
+    return fn.getName() ?? null;
+  }
+
+  const varDecl = fn.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+  return varDecl?.getName() ?? null;
+}
+
+// COMPONENTS
+function detectComponentWrappers(source: SourceFile): ComponentWrapper[] {
+  const result = new Map<string, ComponentWrapper>();
+
+  const elements = [
+    ...source.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+    ...source.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement)
+  ];
+
+  for (const el of elements) {
+    const name = el.getTagNameNode().getText();
+
+    for (const attr of el.getAttributes()) {
+      const a = attr.asKind(SyntaxKind.JsxAttribute);
+      if (!a) continue;
+
+      const prop = a.getNameNode().getText();
+      const val = a.getInitializer();
+
+      if (!val) continue;
+
+      if (
+        Node.isStringLiteral(val) ||
+        Node.isJsxExpression(val)
+      ) {
+        result.set(name, { name, prop });
+      }
+    }
+  }
+
+  return [...result.values()];
+}

package/src/utils/extract.ts

@@ -1,7 +1,4 @@
-import {
-  Node,
-  SyntaxKind
-} from "ts-morph";
+import { Node, SyntaxKind } from "ts-morph";
 
 export type ExtractResult = {
   values: string[];
@@ -9,7 +6,8 @@ export type ExtractResult = {
 };
 
 export function extractExpression(
-  expr: Node
+  expr: Node,
+  aliases: Record<string, string>
 ): ExtractResult | null {
 
   // "event"
@@ -21,58 +19,22 @@ export function extractExpression(
   }
 
   // `event`
-  if (
-    expr.getKind() ===
-    SyntaxKind.NoSubstitutionTemplateLiteral
-  ) {
+  if (expr.getKind() === SyntaxKind.NoSubstitutionTemplateLiteral) {
     return {
-      values: [
-        expr.getText().replace(/`/g, "")
-      ],
+      values: [expr.getText().replace(/`/g, "")],
       dynamic: false
     };
   }
 
-  // identifier (TEST)
+  // IDENTIFIER
   if (Node.isIdentifier(expr)) {
     const name = expr.getText();
 
-    const defs =
-      "getDefinitions" in expr
-        ? (expr as any).getDefinitions()
-        : [];
-
-    if (defs && defs.length > 0) {
-      const decl = defs[0]?.getDeclarationNode();
-
-      if (decl && Node.isVariableDeclaration(decl)) {
-        const initializer = decl.getInitializer();
-
-        // const TEST = "event"
-        if (
-          initializer &&
-          Node.isStringLiteral(initializer)
-        ) {
-          return {
-            values: [initializer.getLiteralText()],
-            dynamic: false
-          };
-        }
-
-        // const TEST = `event`
-        if (
-          initializer &&
-          initializer.getKind() ===
-          SyntaxKind.NoSubstitutionTemplateLiteral
-        ) {
-          return {
-            values: [
-              initializer.getText().replace(/`/g, "")
-            ],
-            dynamic: false
-          };
-        }
-      }
+    if (name in aliases) {
+      return {
+        values: [aliases[name]],
+        dynamic: false
+      };
     }
 
     return {
@@ -81,82 +43,19 @@ export function extractExpression(
     };
   }
 
-  // property access (EVENTS.CLICK)
+  // PROPERTY ACCESS
   if (Node.isPropertyAccessExpression(expr)) {
-    const fullName = expr.getText(); // EVENTS.CLICK
-    const propName = expr.getName(); // CLICK
-
-    const defs =
-      "getDefinitions" in expr
-        ? (expr as any).getDefinitions()
-        : [];
-
-    if (defs && defs.length > 0) {
-      const decl = defs[0]?.getDeclarationNode();
-
-      // const EVENTS = { CLICK: "event" }
-      if (decl && Node.isVariableDeclaration(decl)) {
-        const init = decl.getInitializer();
-
-        if (init && Node.isObjectLiteralExpression(init)) {
-          const prop = init.getProperty(propName);
-
-          if (
-            prop &&
-            Node.isPropertyAssignment(prop)
-          ) {
-            const value = prop.getInitializer();
-
-            if (
-              value &&
-              Node.isStringLiteral(value)
-            ) {
-              return {
-                values: [value.getLiteralText()],
-                dynamic: false
-              };
-            }
-          }
-        }
-      }
-
-      // fallback
-      if (decl && Node.isPropertyAssignment(decl)) {
-        const initializer = decl.getInitializer();
+    const name = expr.getText();
 
-        if (
-          initializer &&
-          Node.isStringLiteral(initializer)
-        ) {
-          return {
-            values: [initializer.getLiteralText()],
-            dynamic: false
-          };
-        }
-      }
+    if (name in aliases) {
+      return {
+        values: [aliases[name]],
+        dynamic: false
+      };
     }
 
     return {
-      values: [fullName],
-      dynamic: true
-    };
-  }
-
-  // ternary (a ? b : c)
-  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,
+      values: [name],
       dynamic: true
     };
   }
@@ -164,19 +63,7 @@ export function extractExpression(
   // template `${}`
   if (Node.isTemplateExpression(expr)) {
     return {
-      values: [
-        expr.getText().replace(/`/g, "")
-      ],
-      dynamic: true
-    };
-  }
-
-  // call (fn())
-  if (Node.isCallExpression(expr)) {
-    return {
-      values: [
-        expr.getExpression().getText()
-      ],
+      values: [expr.getText()],
       dynamic: true
     };
   }

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

@@ -13,9 +13,10 @@ import { extractExpression } from "../extract";
 
 export function scanComponentWrappers(
   source: SourceFile,
-  wrappers: ComponentWrapper[]
+  wrappers: ComponentWrapper[],
+  aliases: Record<string, string>
 ) {
-  const events = new Set<ExtractedEvent>();
+  const events = new Map<string, ExtractedEvent>();
 
   const elements = [
     ...source.getDescendantsOfKind(
@@ -36,14 +37,10 @@ export function scanComponentWrappers(
       if (name !== wrapper.name.toLowerCase())
         continue;
 
-      const attrs = el.getAttributes();
+      for (const attr of el.getAttributes()) {
 
-      for (const attr of attrs) {
-
-        // ❗ NO spread props
-        if (Node.isJsxSpreadAttribute(attr)) {
+        if (Node.isJsxSpreadAttribute(attr))
           continue;
-        }
 
         const attrNode =
           attr.asKind(SyntaxKind.JsxAttribute);
@@ -63,45 +60,50 @@ export function scanComponentWrappers(
 
         // <Button event />
         if (!init) {
-          events.add({
-            value: key,
+          const value = key;
+          const k = `${value}:true`;
+
+          events.set(k, {
+            value,
             dynamic: true
           });
+
           continue;
         }
 
-        // string: <Button event="click" />
+        // <Button event="click" />
         if (Node.isStringLiteral(init)) {
-          events.add({
-            value: init.getLiteralText(),
+          const value = init.getLiteralText();
+          const k = `${value}:false`;
+
+          events.set(k, {
+            value,
             dynamic: false
           });
+
           continue;
         }
 
-        // jsx expression: <Button event={"click"} />
+        // <Button event={...} />
         if (Node.isJsxExpression(init)) {
           const expr = init.getExpression();
-
           if (!expr) continue;
 
-          const result =
-            extractExpression(expr);
-
+          const result = extractExpression(expr, aliases);
           if (!result) continue;
 
-          result.values.forEach((value) =>
-            events.add({
+          for (const value of result.values) {
+            const k = `${value}:${result.dynamic}`;
+
+            events.set(k, {
               value,
               dynamic: result.dynamic
-            })
-          );
-
-          continue;
+            });
+          }
         }
       }
     }
   }
 
-  return events;
+  return [...events.values()];
 }

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

@@ -15,10 +15,10 @@ import { extractExpression } from "../extract";
 
 export function scanFunctionWrappers(
   source: SourceFile,
-  wrappers: FunctionWrapper[]
+  wrappers: FunctionWrapper[],
+  aliases: Record<string, string>
 ) {
-  const events =
-    new Set<ExtractedEvent>();
+  const events = new Map<string, ExtractedEvent>();
 
   const calls =
     source.getDescendantsOfKind(
@@ -26,55 +26,42 @@ export function scanFunctionWrappers(
     );
 
   for (const call of calls) {
-    const name =
-      getFunctionName(call);
-
+    const name = getFunctionName(call);
     if (!name) continue;
 
     for (const wrapper of wrappers) {
-      if (wrapper.name !== name)
-        continue;
+      if (wrapper.name !== name) continue;
 
-      const results =
-        extractEventFromArgs(
-          call,
-          wrapper.event
-        );
+      const results = extractEventFromArgs(
+        call,
+        wrapper.event,
+        aliases
+      );
 
       if (!results) continue;
 
-      results.forEach(
-        (r) => events.add(r)
-      );
+      for (const r of results) {
+        const key = `${r.value}:${r.dynamic}`;
+        events.set(key, r);
+      }
     }
   }
 
-  return events;
+  return [...events.values()];
 }
 
 function getFunctionName(
   call: CallExpression
 ): string | null {
 
-  const expression =
-    call.getExpression();
+  const expression = call.getExpression();
 
-  if (
-    Node.isIdentifier(
-      expression
-    )
-  ) {
+  if (Node.isIdentifier(expression)) {
     return expression.getText();
   }
 
-  if (
-    Node.isPropertyAccessExpression(
-      expression
-    )
-  ) {
-    return getDeepName(
-      expression
-    );
+  if (Node.isPropertyAccessExpression(expression)) {
+    return getDeepName(expression);
   }
 
   return null;
@@ -84,22 +71,12 @@ function getDeepName(
   node: PropertyAccessExpression
 ): string {
 
-  let current:
-    | Node
-    | undefined = node;
-
+  let current: Node | undefined = node;
   let name = "";
 
-  while (
-    Node.isPropertyAccessExpression(
-      current
-    )
-    ) {
-    name =
-      current.getName();
-
-    current =
-      current.getExpression();
+  while (Node.isPropertyAccessExpression(current)) {
+    name = current.getName();
+    current = current.getExpression();
   }
 
   return name;
@@ -107,74 +84,54 @@ function getDeepName(
 
 function extractEventFromArgs(
   call: CallExpression,
-  event?: string
+  event: string | undefined,
+  aliases: Record<string, string>
 ): ExtractedEvent[] | null {
 
-  const args =
-    call.getArguments();
-
+  const args = call.getArguments();
   const events: ExtractedEvent[] = [];
 
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
+  for (const arg of args) {
 
     // track("event")
     if (!event) {
-      const result =
-        extractExpression(arg);
-
+      const result = extractExpression(arg, aliases);
       if (!result) continue;
 
-      result.values.forEach(
-        (value) =>
-          events.push({
-            value,
-            dynamic:
-            result.dynamic
-          })
+      result.values.forEach((value) =>
+        events.push({
+          value,
+          dynamic: result.dynamic
+        })
       );
     }
 
-    // track({event})
+    // track({ event })
     if (event) {
-      const obj =
-        arg.asKind(
-          SyntaxKind.ObjectLiteralExpression
-        );
-
+      const obj = arg.asKind(
+        SyntaxKind.ObjectLiteralExpression
+      );
       if (!obj) continue;
 
-      const prop =
-        obj.getProperty(event);
-
+      const prop = obj.getProperty(event);
       if (!prop) continue;
 
-      if (
-        Node.isPropertyAssignment(prop)
-      ) {
-        const init =
-          prop.getInitializer();
-
+      if (Node.isPropertyAssignment(prop)) {
+        const init = prop.getInitializer();
         if (!init) continue;
 
-        const result =
-          extractExpression(init);
-
+        const result = extractExpression(init, aliases);
         if (!result) continue;
 
-        result.values.forEach(
-          (value) =>
-            events.push({
-              value,
-              dynamic:
-              result.dynamic
-            })
+        result.values.forEach((value) =>
+          events.push({
+            value,
+            dynamic: result.dynamic
+          })
         );
       }
     }
   }
 
-  return events.length
-    ? events
-    : null;
+  return events.length ? events : null;
 }