@eventra_dev/eventra-cli 0.1.33 → 0.2.1

package/dist/engine/scanner.js

@@ -7,23 +7,14 @@ exports.scanSource = scanSource;
 const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
-const functionAnalyzer_1 = require("./functionAnalyzer");
 const exportResolver_1 = require("./exportResolver");
-// UTILS
-function getJsxAttrName(name) {
-    if (typescript_1.default.isIdentifier(name))
-        return name.text;
-    if (typescript_1.default.isJsxNamespacedName(name))
-        return name.name.text;
-    return "";
-}
-function getJsxTagName(tag) {
-    if (typescript_1.default.isIdentifier(tag))
-        return tag.text;
-    if (typescript_1.default.isPropertyAccessExpression(tag)) {
-        return tag.name.text;
-    }
-    return "";
+// HELPERS
+function isValidEvent(v) {
+    return (v &&
+        v.length > 1 &&
+        v.length < 120 &&
+        !v.includes(" ") &&
+        /^[a-zA-Z0-9._:-]+$/.test(v));
 }
 function getCallName(expr) {
     if (typescript_1.default.isIdentifier(expr))
@@ -32,163 +23,132 @@ function getCallName(expr) {
         return expr.name.text;
     return "";
 }
-function isValidEvent(v) {
-    return (v &&
-        v.length > 1 &&
-        v.length < 100 &&
-        !v.includes(" ") &&
-        /^[a-zA-Z0-9._:-]+$/.test(v));
+function getJsxTagName(tag) {
+    if (typescript_1.default.isIdentifier(tag))
+        return tag.text;
+    if (typescript_1.default.isPropertyAccessExpression(tag))
+        return tag.name.text;
+    return tag.getText();
 }
-// COMPONENT ANALYSIS
-function getComponentPropsMap(fn) {
-    const map = new Map();
-    const firstParam = fn.parameters[0];
-    if (!firstParam)
-        return map;
-    // ({ event }) => ...
-    if (typescript_1.default.isObjectBindingPattern(firstParam.name)) {
-        for (const el of firstParam.name.elements) {
-            if (!typescript_1.default.isBindingElement(el))
-                continue;
-            const propName = el.propertyName?.getText() || el.name.getText();
-            map.set(el.name.getText(), propName);
+function getJsxAttrName(name) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text;
+    if (typescript_1.default.isJsxNamespacedName(name))
+        return name.name.text;
+    return "";
+}
+// MAIN
+function scanSource(source, checker, config, visited = new Set(), inheritedParamMap, wrapperCache = new Map()) {
+    const events = new Set();
+    const detectedFunctionWrappers = new Set();
+    const detectedComponentWrappers = new Map();
+    if (visited.has(source.fileName)) {
+        return { events, detectedFunctionWrappers, detectedComponentWrappers };
+    }
+    visited.add(source.fileName);
+    // TRACK DETECTION
+    function isTrackCall(expr) {
+        if (typescript_1.default.isIdentifier(expr)) {
+            return expr.text === "track";
         }
+        if (typescript_1.default.isPropertyAccessExpression(expr)) {
+            return expr.name.text === "track";
+        }
+        return false;
     }
-    // (props) => props.event
-    if (typescript_1.default.isIdentifier(firstParam.name)) {
-        map.set(firstParam.name.text, "*");
+    function extractTrackCall(node, paramMap) {
+        if (!isTrackCall(node.expression))
+            return;
+        const arg = node.arguments[0];
+        if (!arg)
+            return;
+        const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
+        for (const v of res.values) {
+            if (isValidEvent(v)) {
+                events.add(v);
+            }
+        }
     }
-    return map;
-}
-function findTrackedPropName(fn, checker) {
-    const propMap = getComponentPropsMap(fn);
-    let result = null;
-    function resolveIdentifierToProp(node) {
-        const mapped = propMap.get(node.text);
-        if (mapped && mapped !== "*")
-            return mapped;
-        const symbol = checker.getSymbolAtLocation(node);
-        if (!symbol)
+    // WRAPPER DETECTION
+    function isWrapperFunction(fn) {
+        let found = false;
+        function walk(n) {
+            if (found)
+                return;
+            if (typescript_1.default.isCallExpression(n) && isTrackCall(n.expression)) {
+                found = true;
+                return;
+            }
+            typescript_1.default.forEachChild(n, walk);
+        }
+        if (fn.body)
+            walk(fn.body);
+        return found;
+    }
+    // COMPONENT WRAPPER
+    function detectComponentWrapper(tag) {
+        const tagName = getJsxTagName(tag);
+        if (wrapperCache.has(tagName)) {
+            return wrapperCache.get(tagName);
+        }
+        let symbol = checker.getSymbolAtLocation(tag);
+        if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        if (!symbol) {
+            wrapperCache.set(tagName, null);
             return null;
+        }
+        symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
         for (const decl of symbol.getDeclarations() ?? []) {
-            // const e = props.event
+            let fn = null;
+            if (typescript_1.default.isFunctionDeclaration(decl))
+                fn = decl;
             if (typescript_1.default.isVariableDeclaration(decl) &&
                 decl.initializer &&
-                typescript_1.default.isPropertyAccessExpression(decl.initializer)) {
-                return decl.initializer.name.text;
+                (typescript_1.default.isArrowFunction(decl.initializer) ||
+                    typescript_1.default.isFunctionExpression(decl.initializer))) {
+                fn = decl.initializer;
             }
-            // const e = event
-            if (typescript_1.default.isVariableDeclaration(decl) &&
-                decl.initializer &&
-                typescript_1.default.isIdentifier(decl.initializer)) {
-                const inner = propMap.get(decl.initializer.text);
-                if (inner)
-                    return inner;
-            }
-        }
-        return null;
-    }
-    function visit(node) {
-        if (result)
-            return;
-        if (typescript_1.default.isCallExpression(node)) {
-            const expr = node.expression;
-            const isTrack = (typescript_1.default.isIdentifier(expr) && expr.text === "track") ||
-                (typescript_1.default.isPropertyAccessExpression(expr) &&
-                    expr.name.text === "track");
-            if (!isTrack) {
-                typescript_1.default.forEachChild(node, visit);
-                return;
-            }
-            for (const arg of node.arguments) {
-                // track(event)
-                if (typescript_1.default.isIdentifier(arg)) {
-                    const prop = resolveIdentifierToProp(arg);
-                    if (prop) {
-                        result = prop;
-                        return;
-                    }
-                }
-                // track(props.a.b.event)
-                if (typescript_1.default.isPropertyAccessExpression(arg)) {
-                    let current = arg;
-                    while (typescript_1.default.isPropertyAccessExpression(current)) {
-                        result = current.name.text;
+            if (!fn || !fn.body)
+                continue;
+            let prop = null;
+            function walk(n) {
+                if (prop)
+                    return;
+                if (typescript_1.default.isCallExpression(n) && isTrackCall(n.expression)) {
+                    const arg = n.arguments[0];
+                    if (typescript_1.default.isPropertyAccessExpression(arg)) {
+                        prop = arg.name.text;
                         return;
                     }
                 }
-                // track(fn())
-                if (typescript_1.default.isCallExpression(arg)) {
-                    const inner = (0, callResolver_1.resolveFunctionFromCall)(arg.expression, checker);
-                    if (inner?.body) {
-                        visit(inner.body);
-                        if (result)
-                            return;
-                    }
-                }
+                typescript_1.default.forEachChild(n, walk);
+            }
+            walk(fn.body);
+            wrapperCache.set(tagName, prop);
+            if (prop) {
+                detectedComponentWrappers.set(tagName, prop);
+                return prop;
             }
         }
-        typescript_1.default.forEachChild(node, visit);
-    }
-    if (fn.body)
-        visit(fn.body);
-    return result;
-}
-// MAIN SCANNER
-function scanSource(source, checker, config, visited = new Set(), inheritedParamMap, wrapperCache = new Map()) {
-    const events = new Set();
-    const detectedFunctionWrappers = new Set();
-    const detectedComponentWrappers = new Map();
-    if (visited.has(source.fileName) || visited.size > 200) {
-        return { events, detectedFunctionWrappers, detectedComponentWrappers };
+        wrapperCache.set(tagName, null);
+        return null;
     }
-    visited.add(source.fileName);
+    // VISITOR
     function visit(node) {
-        // JSX WRAPPERS
+        // JSX
         if (typescript_1.default.isJsxSelfClosingElement(node) || typescript_1.default.isJsxOpeningElement(node)) {
             const tagName = getJsxTagName(node.tagName);
-            // skip html
             if (tagName[0] === tagName[0].toLowerCase()) {
                 typescript_1.default.forEachChild(node, visit);
                 return;
             }
             let wrapper = config.wrappers.find(w => w.name === tagName);
-            // AUTO DETECT
             if (!wrapper) {
-                if (wrapperCache.has(tagName)) {
-                    const cached = wrapperCache.get(tagName);
-                    if (cached)
-                        wrapper = { name: tagName, prop: cached };
-                }
-                else {
-                    let symbol = checker.getSymbolAtLocation(node.tagName);
-                    if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
-                        symbol = checker.getAliasedSymbol(symbol);
-                    }
-                    if (symbol) {
-                        symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-                        for (const decl of symbol.getDeclarations() ?? []) {
-                            let fn = null;
-                            if (typescript_1.default.isFunctionDeclaration(decl))
-                                fn = decl;
-                            if (typescript_1.default.isVariableDeclaration(decl) &&
-                                decl.initializer &&
-                                (typescript_1.default.isArrowFunction(decl.initializer) ||
-                                    typescript_1.default.isFunctionExpression(decl.initializer))) {
-                                fn = decl.initializer;
-                            }
-                            if (!fn)
-                                continue;
-                            const prop = findTrackedPropName(fn, checker);
-                            wrapperCache.set(tagName, prop ?? null);
-                            if (prop) {
-                                wrapper = { name: tagName, prop };
-                                detectedComponentWrappers.set(tagName, prop);
-                                break;
-                            }
-                        }
-                    }
-                }
+                const prop = detectComponentWrapper(node.tagName);
+                if (prop)
+                    wrapper = { name: tagName, prop };
             }
             if (wrapper) {
                 for (const attr of node.attributes.properties) {
@@ -200,15 +160,15 @@ function scanSource(source, checker, config, visited = new Set(), inheritedParam
                     if (!attr.initializer)
                         continue;
                     if (typescript_1.default.isStringLiteral(attr.initializer)) {
-                        const v = attr.initializer.text;
-                        if (isValidEvent(v))
-                            events.add(v);
+                        if (isValidEvent(attr.initializer.text)) {
+                            events.add(attr.initializer.text);
+                        }
                     }
                     if (typescript_1.default.isJsxExpression(attr.initializer)) {
                         const expr = attr.initializer.expression;
                         if (!expr)
                             continue;
-                        const res = (0, resolver_1.resolveNodeValue)(expr, checker, inheritedParamMap);
+                        const res = (0, resolver_1.resolveNodeValue)(expr, checker);
                         res.values.forEach(v => {
                             if (isValidEvent(v))
                                 events.add(v);
@@ -219,65 +179,40 @@ function scanSource(source, checker, config, visited = new Set(), inheritedParam
             typescript_1.default.forEachChild(node, visit);
             return;
         }
-        // FUNCTION CALLS
+        // CALL
         if (typescript_1.default.isCallExpression(node)) {
-            let trackParamIndex = null;
-            let isTracking = false;
-            const callName = getCallName(node.expression);
-            // direct .track()
-            if (typescript_1.default.isPropertyAccessExpression(node.expression) &&
-                node.expression.name.text === "track") {
-                isTracking = true;
-                trackParamIndex = 0;
-            }
-            // config wrapper
-            const manualWrapper = config.functionWrappers.find(w => w.name === callName);
-            if (manualWrapper) {
-                isTracking = true;
-                trackParamIndex = 0;
-            }
-            // resolve function → check body
             const resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-            if (resolvedFn) {
-                const idx = (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn);
-                if (idx !== null) {
-                    isTracking = true;
-                    trackParamIndex = idx;
-                    if (!manualWrapper && callName !== "track") {
-                        detectedFunctionWrappers.add(callName);
-                    }
-                }
-            }
-            if (!isTracking) {
-                typescript_1.default.forEachChild(node, visit);
-                return;
-            }
             const paramMap = new Map(inheritedParamMap ?? []);
-            if (resolvedFn && typescript_1.default.isFunctionLike(resolvedFn)) {
-                resolvedFn.parameters.forEach((param, i) => {
+            if (resolvedFn) {
+                resolvedFn.parameters.forEach((p, i) => {
                     const arg = node.arguments[i];
                     if (!arg)
                         return;
-                    if (typescript_1.default.isIdentifier(param.name)) {
-                        paramMap.set(param.name.text, arg);
+                    if (typescript_1.default.isIdentifier(p.name)) {
+                        paramMap.set(p.name.text, arg);
                     }
                 });
             }
-            if (trackParamIndex !== null && node.arguments[trackParamIndex]) {
-                const res = (0, resolver_1.resolveNodeValue)(node.arguments[trackParamIndex], checker, paramMap);
-                res.values.forEach(v => {
-                    if (isValidEvent(v))
-                        events.add(v);
-                });
+            extractTrackCall(node, paramMap);
+            if (resolvedFn && isWrapperFunction(resolvedFn)) {
+                const name = getCallName(node.expression);
+                if (name && name !== "track") {
+                    detectedFunctionWrappers.add(name);
+                }
+                if (resolvedFn.body) {
+                    visit(resolvedFn.body);
+                }
             }
-            // CROSS FILE
-            if (resolvedFn) {
+            if (resolvedFn && resolvedFn.body) {
                 const sf = resolvedFn.getSourceFile();
                 if (!visited.has(sf.fileName)) {
                     const res = scanSource(sf, checker, config, visited, paramMap, wrapperCache);
                     res.events.forEach(e => events.add(e));
                 }
             }
+            node.arguments.forEach(visit);
+            visit(node.expression);
+            return;
         }
         typescript_1.default.forEachChild(node, visit);
     }

package/dist/utils/universal.js

@@ -184,7 +184,7 @@ function parseUniversal(content, file) {
     deps.push(...dyn.deps);
     parts.push(...dyn.calls);
     return {
-        code: [...new Set(parts)].join("\n"),
+        code: content,
         deps: [...new Set(deps.filter(Boolean))],
     };
 }

package/package.json

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

package/src/commands/check.ts

@@ -25,28 +25,20 @@ export async function check({ fix = false }: { fix?: boolean }) {
 
   const engine = new EventraEngine(process.cwd());
 
+  const cache = new Map<string, { content: string; deps: string[] }>();
   const toScan = new Set<string>();
 
-  const cache = new Map<
-    string,
-    { content: string; deps: string[] }
-  >();
-
-  // COLLECT + CACHE
+  // COLLECT
   for (const file of files) {
     try {
       const raw = await fs.readFile(file, "utf-8");
-
       if (raw.length > 2_000_000) continue;
 
       const parsed = processFile(file, raw);
 
       cache.set(file, parsed);
       toScan.add(file);
-
-      for (const dep of parsed.deps) {
-        toScan.add(path.resolve(dep));
-      }
+      parsed.deps.forEach(dep => toScan.add(path.resolve(dep)));
 
     } catch {}
   }
@@ -54,17 +46,9 @@ export async function check({ fix = false }: { fix?: boolean }) {
   // PRELOAD
   for (const file of toScan) {
     try {
-      let parsed = cache.get(file);
-
-      if (!parsed) {
-        const raw = await fs.readFile(file, "utf-8");
-        parsed = processFile(file, raw);
-        cache.set(file, parsed);
-      }
-
-      const virtual = getVirtualFile(file);
-      engine.preloadFile(virtual, parsed.content);
-
+      const parsed = cache.get(file);
+      if (!parsed) continue;
+      engine.preloadFile(getVirtualFile(file), parsed.content);
     } catch {}
   }
 
@@ -74,49 +58,34 @@ export async function check({ fix = false }: { fix?: boolean }) {
       const parsed = cache.get(file);
       if (!parsed) continue;
 
-      const virtual = getVirtualFile(file);
-
-      engine.scanFile(virtual, parsed.content, config);
+      engine.scanFile(
+        getVirtualFile(file),
+        parsed.content,
+        config
+      );
 
     } catch {}
   }
 
-  // DIFF
   const found = new Set(engine.getAllEvents());
   const known = new Set(config.events ?? []);
 
-  const newEvents = [...found].filter(e => !known.has(e));
+  const added = [...found].filter(e => !known.has(e));
   const removed = [...known].filter(e => !found.has(e));
 
-  // FIX MODE
   if (fix) {
     config.events = [...found].sort();
     await saveConfig(config);
-
-    console.log(
-      chalk.green(`\nSynced (${config.events.length} events)`)
-    );
+    console.log(chalk.green("Synced"));
     return;
   }
 
-  // CHECK MODE
-  if (newEvents.length || removed.length) {
-    if (newEvents.length) {
-      console.log(chalk.red("\nNew events:"));
-      newEvents.forEach(e =>
-        console.log(chalk.red(`+ ${e}`))
-      );
-    }
-
-    if (removed.length) {
-      console.log(chalk.yellow("\nRemoved events:"));
-      removed.forEach(e =>
-        console.log(chalk.yellow(`- ${e}`))
-      );
-    }
+  if (added.length || removed.length) {
+    added.forEach(e => console.log(chalk.red(`+ ${e}`)));
+    removed.forEach(e => console.log(chalk.yellow(`- ${e}`)));
 
     process.exit(1);
   }
 
-  console.log(chalk.green("\nAll good"));
+  console.log(chalk.green("All good"));
 }

package/src/commands/sync.ts

@@ -19,25 +19,15 @@ export async function sync() {
     absolute: true,
   });
 
-  if (!files.length) {
-    console.log(chalk.yellow("No files found"));
-    return;
-  }
-
   const engine = new EventraEngine(process.cwd());
 
+  const cache = new Map<string, { content: string; deps: string[] }>();
   const toScan = new Set<string>();
 
-  const cache = new Map<
-    string,
-    { content: string; deps: string[] }
-  >();
-
-  // COLLECT + CACHE
+  // COLLECT
   for (const file of files) {
     try {
       const raw = await fs.readFile(file, "utf-8");
-
       if (raw.length > 2_000_000) continue;
 
       const parsed = processFile(file, raw);
@@ -45,9 +35,7 @@ export async function sync() {
       cache.set(file, parsed);
       toScan.add(file);
 
-      for (const dep of parsed.deps) {
-        toScan.add(path.resolve(dep));
-      }
+      parsed.deps.forEach(dep => toScan.add(path.resolve(dep)));
 
     } catch {}
   }
@@ -63,8 +51,7 @@ export async function sync() {
         cache.set(file, parsed);
       }
 
-      const virtual = getVirtualFile(file);
-      engine.preloadFile(virtual, parsed.content);
+      engine.preloadFile(getVirtualFile(file), parsed.content);
 
     } catch {}
   }
@@ -78,21 +65,16 @@ export async function sync() {
       const parsed = cache.get(file);
       if (!parsed) continue;
 
-      const virtual = getVirtualFile(file);
-
-      const res = engine.scanFile(virtual, parsed.content, config);
-
-      res.detectedFunctionWrappers.forEach(w =>
-        detectedFn.add(w)
+      const res = engine.updateFile(
+        getVirtualFile(file),
+        parsed.content,
+        config
       );
 
-      for (const [k, v] of res.detectedComponentWrappers) {
-        detectedCmp.set(k, v);
-      }
+      res.detectedFunctionWrappers.forEach(w => detectedFn.add(w));
+      res.detectedComponentWrappers.forEach((v, k) => detectedCmp.set(k, v));
 
-    } catch {
-      console.log(chalk.gray(`skip: ${file}`));
-    }
+    } catch {}
   }
 
   // RESULT
@@ -108,10 +90,7 @@ export async function sync() {
 
   config.wrappers = mergeUnique(
     config.wrappers ?? [],
-    [...detectedCmp.entries()].map(([name, prop]) => ({
-      name,
-      prop,
-    })),
+    [...detectedCmp.entries()].map(([name, prop]) => ({ name, prop })),
     w => `${w.name}:${w.prop}`
   );
 
@@ -120,17 +99,8 @@ export async function sync() {
   console.log(chalk.green(`Found ${events.length} events`));
 }
 
-// HELPERS
-function mergeUnique<T>(
-  a: T[],
-  b: T[],
-  key: (v: T) => string
-): T[] {
+function mergeUnique<T>(a: T[], b: T[], key: (v: T) => string): T[] {
   const map = new Map<string, T>();
-
-  [...b, ...a].forEach(item => {
-    map.set(key(item), item);
-  });
-
+  [...b, ...a].forEach(item => map.set(key(item), item));
   return [...map.values()];
 }