@eventra_dev/eventra-cli 0.2.3 → 0.3.1

package/dist/engine/resolver.js

@@ -1,149 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveNodeValue = resolveNodeValue;
-const typescript_1 = __importDefault(require("typescript"));
-const exportResolver_1 = require("./exportResolver");
-const callResolver_1 = require("./callResolver");
-function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
-    if (seen.has(node))
-        return { values: [], dynamic: true };
-    seen.add(node);
-    // param passthrough
-    if (typescript_1.default.isIdentifier(node) && paramMap?.has(node.text)) {
-        return resolveNodeValue(paramMap.get(node.text), checker, paramMap, seen);
-    }
-    // string
-    if (typescript_1.default.isStringLiteral(node)) {
-        return { values: [node.text], dynamic: false };
-    }
-    // template
-    if (typescript_1.default.isTemplateExpression(node)) {
-        let results = node.head.text ? [node.head.text] : [""];
-        for (const span of node.templateSpans) {
-            const r = resolveNodeValue(span.expression, checker, paramMap, seen);
-            results = results.flatMap(s => r.values.length ? r.values.map(v => s + v) : [s + "*"]);
-            results = results.map(s => s + span.literal.text);
-        }
-        return { values: results, dynamic: true };
-    }
-    // ternary
-    if (typescript_1.default.isConditionalExpression(node)) {
-        const a = resolveNodeValue(node.whenTrue, checker, paramMap, seen);
-        const b = resolveNodeValue(node.whenFalse, checker, paramMap, seen);
-        return {
-            values: [...new Set([...a.values, ...b.values])],
-            dynamic: true,
-        };
-    }
-    // object (event/name priority)
-    if (typescript_1.default.isObjectLiteralExpression(node)) {
-        for (const p of node.properties) {
-            if (typescript_1.default.isPropertyAssignment(p)) {
-                const key = p.name.getText();
-                if (key === "event" || key === "name") {
-                    return resolveNodeValue(p.initializer, checker, paramMap, seen);
-                }
-            }
-        }
-        const vals = [];
-        for (const p of node.properties) {
-            if (!typescript_1.default.isPropertyAssignment(p))
-                continue;
-            const r = resolveNodeValue(p.initializer, checker, paramMap, seen);
-            vals.push(...r.values);
-        }
-        return { values: [...new Set(vals)], dynamic: true };
-    }
-    // array
-    if (typescript_1.default.isArrayLiteralExpression(node)) {
-        const vals = [];
-        for (const el of node.elements) {
-            const r = resolveNodeValue(el, checker, paramMap, seen);
-            vals.push(...r.values);
-        }
-        return { values: [...new Set(vals)], dynamic: true };
-    }
-    // concat
-    if (typescript_1.default.isBinaryExpression(node) &&
-        node.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken) {
-        const l = resolveNodeValue(node.left, checker, paramMap, seen);
-        const r = resolveNodeValue(node.right, checker, paramMap, seen);
-        return {
-            values: l.values.flatMap(a => r.values.length ? r.values.map(b => a + b) : [a + "*"]),
-            dynamic: true,
-        };
-    }
-    // identifier (const / enum)
-    if (typescript_1.default.isIdentifier(node)) {
-        let s = checker.getSymbolAtLocation(node);
-        if (!s)
-            return { values: [], dynamic: true };
-        s = (0, exportResolver_1.resolveExportedSymbol)(s, checker) ?? s;
-        for (const d of s.getDeclarations() ?? []) {
-            if (typescript_1.default.isVariableDeclaration(d) && d.initializer) {
-                return resolveNodeValue(d.initializer, checker, paramMap, seen);
-            }
-            if (typescript_1.default.isEnumMember(d) && d.initializer && typescript_1.default.isStringLiteral(d.initializer)) {
-                return { values: [d.initializer.text], dynamic: false };
-            }
-        }
-        return { values: [], dynamic: true };
-    }
-    // PROPERTY ACCESS (OBJECT + ENUM)
-    if (typescript_1.default.isPropertyAccessExpression(node)) {
-        const obj = node.expression;
-        const prop = node.name.text;
-        // object literal lookup
-        if (typescript_1.default.isIdentifier(obj)) {
-            const sym = checker.getSymbolAtLocation(obj);
-            if (sym) {
-                const s = (0, exportResolver_1.resolveExportedSymbol)(sym, checker) ?? sym;
-                for (const d of s.getDeclarations() ?? []) {
-                    if (typescript_1.default.isVariableDeclaration(d) &&
-                        d.initializer &&
-                        typescript_1.default.isObjectLiteralExpression(d.initializer)) {
-                        for (const p of d.initializer.properties) {
-                            if (typescript_1.default.isPropertyAssignment(p) &&
-                                p.name.getText() === prop) {
-                                return resolveNodeValue(p.initializer, checker, paramMap, seen);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        // enum fallback
-        const sym = checker.getSymbolAtLocation(node);
-        if (sym) {
-            let s = (0, exportResolver_1.resolveExportedSymbol)(sym, checker) ?? sym;
-            if (s.flags & typescript_1.default.SymbolFlags.Alias)
-                s = checker.getAliasedSymbol(s);
-            for (const d of s.getDeclarations() ?? []) {
-                if (typescript_1.default.isEnumMember(d) && d.initializer && typescript_1.default.isStringLiteral(d.initializer)) {
-                    return { values: [d.initializer.text], dynamic: false };
-                }
-            }
-        }
-        return { values: [], dynamic: true };
-    }
-    // CALL (unwrap + dive into wrapper body)
-    if (typescript_1.default.isCallExpression(node)) {
-        const vals = [];
-        // args
-        for (const a of node.arguments) {
-            const r = resolveNodeValue(a, checker, paramMap, seen);
-            vals.push(...r.values);
-        }
-        // dive into called function (wrapper support)
-        const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-        if (fn?.body) {
-            const r = resolveNodeValue(fn.body, checker, paramMap, seen);
-            vals.push(...r.values);
-        }
-        return { values: [...new Set(vals)], dynamic: true };
-    }
-    return { values: [], dynamic: true };
-}

package/dist/engine/scanner.js

@@ -1,230 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scanSource = scanSource;
-const typescript_1 = __importDefault(require("typescript"));
-const resolver_1 = require("./resolver");
-const callResolver_1 = require("./callResolver");
-const exportResolver_1 = require("./exportResolver");
-// 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))
-        return expr.text;
-    if (typescript_1.default.isPropertyAccessExpression(expr))
-        return expr.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 tag.getText();
-}
-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) {
-        const name = getCallName(expr);
-        // direct track()
-        if (name === "track") {
-            return true;
-        }
-        // configured wrappers
-        if (config.functionWrappers?.some(w => w.name === name)) {
-            return true;
-        }
-        // *.track()
-        return typescript_1.default.isPropertyAccessExpression(expr) &&
-            expr.name.text === "track";
-    }
-    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);
-            }
-        }
-    }
-    // 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() ?? []) {
-            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 || !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;
-                    }
-                }
-                typescript_1.default.forEachChild(n, walk);
-            }
-            walk(fn.body);
-            wrapperCache.set(tagName, prop);
-            if (prop) {
-                detectedComponentWrappers.set(tagName, prop);
-                return prop;
-            }
-        }
-        wrapperCache.set(tagName, null);
-        return null;
-    }
-    // VISITOR
-    function visit(node) {
-        // JSX
-        if (typescript_1.default.isJsxSelfClosingElement(node) || typescript_1.default.isJsxOpeningElement(node)) {
-            const tagName = getJsxTagName(node.tagName);
-            if (tagName[0] === tagName[0].toLowerCase()) {
-                typescript_1.default.forEachChild(node, visit);
-                return;
-            }
-            let wrapper = config.wrappers.find(w => w.name === tagName);
-            if (!wrapper) {
-                const prop = detectComponentWrapper(node.tagName);
-                if (prop)
-                    wrapper = { name: tagName, prop };
-            }
-            if (wrapper) {
-                for (const attr of node.attributes.properties) {
-                    if (!typescript_1.default.isJsxAttribute(attr))
-                        continue;
-                    const name = getJsxAttrName(attr.name);
-                    if (name !== wrapper.prop)
-                        continue;
-                    if (!attr.initializer)
-                        continue;
-                    if (typescript_1.default.isStringLiteral(attr.initializer)) {
-                        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);
-                        res.values.forEach(v => {
-                            if (isValidEvent(v))
-                                events.add(v);
-                        });
-                    }
-                }
-            }
-            typescript_1.default.forEachChild(node, visit);
-            return;
-        }
-        // CALL
-        if (typescript_1.default.isCallExpression(node)) {
-            const resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-            const paramMap = new Map(inheritedParamMap ?? []);
-            if (resolvedFn) {
-                resolvedFn.parameters.forEach((p, i) => {
-                    const arg = node.arguments[i];
-                    if (!arg)
-                        return;
-                    if (typescript_1.default.isIdentifier(p.name)) {
-                        paramMap.set(p.name.text, arg);
-                    }
-                });
-            }
-            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);
-                }
-            }
-            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);
-    }
-    visit(source);
-    return {
-        events,
-        detectedFunctionWrappers,
-        detectedComponentWrappers,
-    };
-}

package/dist/utils/processFile.js

@@ -1,28 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processFile = processFile;
-const path_1 = __importDefault(require("path"));
-const universal_1 = require("./universal");
-function extractImports(content, file) {
-    return (0, universal_1.parseUniversal)(content, file).deps;
-}
-function processFile(file, content) {
-    const ext = path_1.default.extname(file);
-    if (ext === ".ts" ||
-        ext === ".tsx" ||
-        ext === ".js" ||
-        ext === ".jsx") {
-        return {
-            content,
-            deps: extractImports(content, file),
-        };
-    }
-    const parsed = (0, universal_1.parseUniversal)(content, file);
-    return {
-        content: parsed.code || "",
-        deps: [...new Set(parsed.deps.filter(Boolean))],
-    };
-}

package/dist/utils/universal.js

@@ -1,190 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseUniversal = parseUniversal;
-const path_1 = __importDefault(require("path"));
-/* ---------------------------------- */
-/* COMMENT STRIP (SAFE)               */
-/* ---------------------------------- */
-function stripComments(input) {
-    return input
-        .replace(/<!--[\s\S]*?-->/g, "")
-        .replace(/\/\*[\s\S]*?\*\//g, "");
-}
-/* ---------------------------------- */
-/* TRACK DETECTOR                     */
-/* ---------------------------------- */
-function looksLikeTracking(code) {
-    return /\btrack\s*\(|\.track\s*\(/.test(code);
-}
-/* ---------------------------------- */
-/* SAFE {} PARSER (JSX / TEMPLATES)   */
-/* ---------------------------------- */
-function extractBracedExpressions(input) {
-    const result = [];
-    let depth = 0;
-    let start = -1;
-    let inString = null;
-    for (let i = 0; i < input.length; i++) {
-        const char = input[i];
-        // handle strings
-        if (inString) {
-            if (char === inString && input[i - 1] !== "\\") {
-                inString = null;
-            }
-            continue;
-        }
-        if (char === '"' || char === "'" || char === "`") {
-            inString = char;
-            continue;
-        }
-        if (char === "{") {
-            if (depth === 0)
-                start = i + 1;
-            depth++;
-        }
-        else if (char === "}") {
-            depth--;
-            if (depth === 0 && start !== -1) {
-                const expr = input.slice(start, i);
-                if (looksLikeTracking(expr)) {
-                    result.push(expr);
-                }
-                start = -1;
-            }
-        }
-    }
-    return result;
-}
-/* ---------------------------------- */
-/* HTML HANDLERS                      */
-/* ---------------------------------- */
-function extractHTMLHandlers(input) {
-    const result = [];
-    const regex = /\bon\w+\s*=\s*["']([^"']+)["']/g;
-    for (const m of input.matchAll(regex)) {
-        if (looksLikeTracking(m[1])) {
-            result.push(m[1]);
-        }
-    }
-    return result;
-}
-/* ---------------------------------- */
-/* VUE HANDLERS                       */
-/* ---------------------------------- */
-function extractVueHandlers(input) {
-    const result = [];
-    const regex = /(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g;
-    for (const m of input.matchAll(regex)) {
-        if (looksLikeTracking(m[1])) {
-            result.push(m[1]);
-        }
-    }
-    return result;
-}
-/* ---------------------------------- */
-/* SVELTE HANDLERS                    */
-/* ---------------------------------- */
-function extractSvelteHandlers(input) {
-    const result = [];
-    const regex = /\bon:[\w]+\s*=\s*{([\s\S]*?)}/g;
-    for (const m of input.matchAll(regex)) {
-        const expr = m[1];
-        const nested = extractBracedExpressions(`{${expr}}`);
-        result.push(...nested);
-    }
-    return result;
-}
-/* ---------------------------------- */
-/* SCRIPT EXTRACTION                  */
-/* ---------------------------------- */
-function extractScripts(input, file) {
-    const scripts = [];
-    const deps = [];
-    // <script src="">
-    const srcRegex = /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/gi;
-    for (const m of input.matchAll(srcRegex)) {
-        const src = m[1];
-        const resolved = src.startsWith("/")
-            ? path_1.default.resolve(process.cwd(), "." + src)
-            : path_1.default.resolve(path_1.default.dirname(file), src);
-        deps.push(resolved);
-    }
-    // inline <script>
-    const scriptRegex = /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
-    for (const m of input.matchAll(scriptRegex)) {
-        if (m[1]?.trim()) {
-            scripts.push(m[1]);
-        }
-    }
-    const noScripts = input.replace(scriptRegex, "");
-    return { scripts, deps, noScripts };
-}
-/* ---------------------------------- */
-/* STATIC IMPORTS                     */
-/* ---------------------------------- */
-function extractStaticImports(input, file) {
-    const deps = [];
-    const regex = /import\s+(?:.+?\s+from\s+)?["'](.+?)["']/g;
-    for (const m of input.matchAll(regex)) {
-        const mod = m[1];
-        if (!mod.startsWith(".") && !mod.startsWith("/"))
-            continue;
-        const resolved = path_1.default.resolve(path_1.default.dirname(file), mod);
-        deps.push(resolved);
-    }
-    return deps;
-}
-/* ---------------------------------- */
-/* DYNAMIC IMPORTS                    */
-/* ---------------------------------- */
-function extractDynamicImports(input, file) {
-    const deps = [];
-    const calls = [];
-    const regex = /import\(\s*["'](.+?)["']\s*\)/g;
-    for (const m of input.matchAll(regex)) {
-        const mod = m[1];
-        const resolved = mod.startsWith("/")
-            ? path_1.default.resolve(process.cwd(), "." + mod)
-            : path_1.default.resolve(path_1.default.dirname(file), mod);
-        deps.push(resolved);
-        if (looksLikeTracking(mod)) {
-            calls.push(`import("${mod}")`);
-        }
-    }
-    return { deps, calls };
-}
-/* ---------------------------------- */
-/* MAIN                               */
-/* ---------------------------------- */
-function parseUniversal(content, file) {
-    const parts = [];
-    const deps = [];
-    const clean = stripComments(content);
-    /* ---------- ASTRO FRONTMATTER ---------- */
-    const fm = clean.match(/^\s*---([\s\S]*?)---/);
-    if (fm?.[1]) {
-        parts.push(fm[1]);
-    }
-    /* ---------- SCRIPTS ---------- */
-    const { scripts, deps: scriptDeps, noScripts } = extractScripts(clean, file);
-    parts.push(...scripts);
-    deps.push(...scriptDeps);
-    /* ---------- HANDLERS ---------- */
-    parts.push(...extractHTMLHandlers(noScripts));
-    parts.push(...extractVueHandlers(noScripts));
-    parts.push(...extractSvelteHandlers(noScripts));
-    /* ---------- JSX / TEMPLATE ---------- */
-    parts.push(...extractBracedExpressions(clean));
-    /* ---------- IMPORTS ---------- */
-    deps.push(...extractStaticImports(clean, file));
-    const dyn = extractDynamicImports(clean, file);
-    deps.push(...dyn.deps);
-    parts.push(...dyn.calls);
-    return {
-        code: parts.length ? parts.join("\n") : content,
-        deps: [...new Set(deps.filter(Boolean))],
-    };
-}

package/src/commands/check.ts

@@ -1,91 +0,0 @@
-import chalk from "chalk";
-import fg from "fast-glob";
-import fs from "fs/promises";
-import path from "path";
-
-import { loadConfig, saveConfig } from "../utils/config";
-import { EventraEngine } from "../engine/engine";
-import { processFile } from "../utils/processFile";
-import { getVirtualFile } from "../utils/getVirtualFile";
-
-export async function check({ fix = false }: { fix?: boolean }) {
-  const config = await loadConfig();
-
-  if (!config) {
-    console.log(chalk.red("eventra.json not found"));
-    process.exit(1);
-  }
-
-  console.log(chalk.blue("Checking events..."));
-
-  const files = await fg(config.sync.include, {
-    ignore: config.sync.exclude,
-    absolute: true,
-  });
-
-  const engine = new EventraEngine(process.cwd());
-
-  const cache = new Map<string, { content: string; deps: string[] }>();
-  const toScan = new Set<string>();
-
-  // 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);
-      parsed.deps.forEach(dep => toScan.add(path.resolve(dep)));
-
-    } catch {}
-  }
-
-  // PRELOAD
-  for (const file of toScan) {
-    try {
-      const parsed = cache.get(file);
-      if (!parsed) continue;
-      engine.preloadFile(getVirtualFile(file), parsed.content);
-    } catch {}
-  }
-
-  // SCAN
-  for (const file of toScan) {
-    try {
-      const parsed = cache.get(file);
-      if (!parsed) continue;
-
-      engine.scanFile(
-        getVirtualFile(file),
-        parsed.content,
-        config
-      );
-
-    } catch {}
-  }
-
-  const found = new Set(engine.getAllEvents());
-  const known = new Set(config.events ?? []);
-
-  const added = [...found].filter(e => !known.has(e));
-  const removed = [...known].filter(e => !found.has(e));
-
-  if (fix) {
-    config.events = [...found].sort();
-    await saveConfig(config);
-    console.log(chalk.green("Synced"));
-    return;
-  }
-
-  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("All good"));
-}