@eventra_dev/eventra-cli 0.0.18 → 0.0.19

package/dist/commands/sync.js

@@ -10,6 +10,8 @@ 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 detect_wrappers_1 = require("../utils/detect-wrappers");
+const detect_aliases_1 = require("../utils/detect-aliases");
 const router_1 = require("../utils/parsers/router");
 const vue_1 = require("../utils/parsers/vue");
 const svelte_1 = require("../utils/parsers/svelte");
@@ -32,65 +34,103 @@ async function sync() {
         ignore: config.sync.exclude
     });
     for (const file of files) {
-        const parser = (0, router_1.detectParser)(file);
-        let content = await promises_1.default.readFile(file, "utf-8");
-        if (parser === "vue")
-            content = (0, vue_1.parseVue)(content);
-        if (parser === "svelte")
-            content = (0, svelte_1.parseSvelte)(content);
-        if (parser === "astro")
-            content = (0, astro_1.parseAstro)(content);
-        const virtualFile = parser === "ts"
-            ? file
-            : file + ".tsx";
-        const source = project.createSourceFile(virtualFile, content, { overwrite: true });
-        const found = [
-            ...(0, track_1.scanTrack)(source, config),
-            ...(0, function_wrappers_1.scanFunctionWrappers)(source, config.functionWrappers ?? []),
-            ...(0, component_wrappers_1.scanComponentWrappers)(source, config.wrappers ?? [])
-        ];
-        for (const event of found) {
-            const { value, dynamic } = event;
-            if (!value)
-                continue;
-            // alias
-            if (aliases[value]) {
-                console.log(chalk_1.default.gray(`alias: ${value} → ${aliases[value]}`));
-                events.add(aliases[value]);
-                continue;
+        try {
+            const parser = (0, router_1.detectParser)(file);
+            let content = await promises_1.default.readFile(file, "utf-8");
+            if (parser === "vue")
+                content = (0, vue_1.parseVue)(content);
+            if (parser === "svelte")
+                content = (0, svelte_1.parseSvelte)(content);
+            if (parser === "astro")
+                content = (0, astro_1.parseAstro)(content);
+            const virtualFile = parser === "ts" ? file : file + ".tsx";
+            const source = project.createSourceFile(virtualFile, content, { overwrite: true });
+            // AUTO ALIASES
+            const detectedAliases = (0, detect_aliases_1.detectAliases)(source);
+            for (const key in detectedAliases) {
+                if (!(key in aliases)) {
+                    aliases[key] = detectedAliases[key];
+                    console.log(chalk_1.default.green(`Detected alias: ${key} → ${detectedAliases[key]}`));
+                }
             }
-            // static
-            if (!dynamic) {
-                events.add(value);
-                continue;
+            // AUTO WRAPPERS
+            const detected = (0, detect_wrappers_1.detectWrappers)(source);
+            // function wrappers
+            for (const fn of detected.functions) {
+                if (!config.functionWrappers?.some((w) => w.name === fn.name)) {
+                    config.functionWrappers.push(fn);
+                    console.log(chalk_1.default.green(`Detected function wrapper: ${fn.name}`));
+                }
             }
-            // already asked
-            if (asked.has(value)) {
-                continue;
+            // component wrappers
+            for (const comp of detected.components) {
+                if (!config.wrappers?.some((w) => w.name === comp.name)) {
+                    config.wrappers.push(comp);
+                    console.log(chalk_1.default.green(`Detected component wrapper: ${comp.name} (prop: ${comp.prop})`));
+                }
             }
-            // ask user
-            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 (or type 'skip'):"
+            // SCAN EVENTS
+            const found = [
+                ...(0, track_1.scanTrack)(source, config, aliases),
+                ...(0, function_wrappers_1.scanFunctionWrappers)(source, config.functionWrappers ?? [], aliases),
+                ...(0, component_wrappers_1.scanComponentWrappers)(source, config.wrappers ?? [], aliases)
+            ];
+            for (const event of found) {
+                const { value, dynamic } = event;
+                if (!value)
+                    continue;
+                // skip explicit ignore
+                if (value in aliases && aliases[value] === "__skip__") {
+                    continue;
+                }
+                // resolve alias
+                if (value in aliases) {
+                    events.add(aliases[value]);
+                    continue;
                 }
-            ]);
-            const normalized = name?.trim();
-            asked.add(value);
-            if (!normalized || normalized === "skip") {
-                continue;
+                // static
+                if (!dynamic) {
+                    events.add(value);
+                    continue;
+                }
+                // already handled
+                if (asked.has(value))
+                    continue;
+                // ASK ONLY IF NEEDED
+                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 (or type 'skip'):"
+                    }
+                ]);
+                const normalized = name?.trim();
+                asked.add(value);
+                if (!normalized || normalized === "skip") {
+                    continue;
+                }
+                // save alias
+                aliases[value] = normalized;
+                console.log(chalk_1.default.green(`Saved alias: ${value} → ${normalized}`));
+                events.add(normalized);
             }
-            // save alias
-            aliases[value] = normalized;
-            events.add(normalized);
+            // free memory
+            project.removeSourceFile(source);
+        }
+        catch {
+            console.log(chalk_1.default.gray(`Skipped file: ${file}`));
         }
     }
-    config.aliases = aliases;
-    const list = [...events].sort();
-    config.events = list;
+    // SAVE CONFIG
+    config.aliases = Object.fromEntries(Object.entries(aliases).sort());
+    // MERGE
+    const merged = new Set([
+        ...config.events,
+        ...events
+    ]);
+    config.events = [...merged].sort();
     await (0, config_1.saveConfig)(config);
-    console.log(chalk_1.default.green(`Found ${list.length} events`));
+    console.log(chalk_1.default.green(`\nFound ${config.events.length} events`));
 }

package/dist/commands/watch.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watch = watch;
+const chokidar_1 = __importDefault(require("chokidar"));
+const chalk_1 = __importDefault(require("chalk"));
+const ts_morph_1 = require("ts-morph");
+const promises_1 = __importDefault(require("fs/promises"));
+const config_1 = require("../utils/config");
+const router_1 = require("../utils/parsers/router");
+const vue_1 = require("../utils/parsers/vue");
+const svelte_1 = require("../utils/parsers/svelte");
+const astro_1 = require("../utils/parsers/astro");
+const track_1 = require("../utils/scanners/track");
+const function_wrappers_1 = require("../utils/scanners/function-wrappers");
+const component_wrappers_1 = require("../utils/scanners/component-wrappers");
+async function watch() {
+    const config = await (0, config_1.loadConfig)();
+    if (!config) {
+        console.log(chalk_1.default.red("Run init first"));
+        return;
+    }
+    console.log(chalk_1.default.blue("Watching...\n"));
+    const project = new ts_morph_1.Project();
+    const aliases = config.aliases ?? {};
+    // уже известные события
+    const seen = new Set(config.events);
+    const queue = new Set();
+    let timer;
+    const processQueue = async () => {
+        const files = [...queue];
+        queue.clear();
+        for (const file of files) {
+            await handle(file);
+        }
+        config.events = [...new Set(config.events)].sort();
+        await (0, config_1.saveConfig)(config);
+    };
+    const handle = async (file) => {
+        try {
+            let content = await promises_1.default.readFile(file, "utf-8");
+            const parser = (0, router_1.detectParser)(file);
+            if (parser === "vue")
+                content = (0, vue_1.parseVue)(content);
+            if (parser === "svelte")
+                content = (0, svelte_1.parseSvelte)(content);
+            if (parser === "astro")
+                content = (0, astro_1.parseAstro)(content);
+            const source = project.createSourceFile(file, content, {
+                overwrite: true
+            });
+            const found = [
+                ...(0, track_1.scanTrack)(source, config, aliases),
+                ...(0, function_wrappers_1.scanFunctionWrappers)(source, config.functionWrappers ?? [], aliases),
+                ...(0, component_wrappers_1.scanComponentWrappers)(source, config.wrappers ?? [], aliases)
+            ];
+            for (const e of found) {
+                if (!e.value)
+                    continue;
+                if (aliases[e.value] === "__skip__")
+                    continue;
+                if (e.value in aliases)
+                    continue;
+                if (seen.has(e.value))
+                    continue;
+                seen.add(e.value);
+                if (!e.dynamic) {
+                    config.events.push(e.value);
+                    console.log(chalk_1.default.green(`+ ${e.value}`));
+                }
+                else {
+                    console.log(chalk_1.default.yellow(`Dynamic: ${e.value}`));
+                }
+            }
+            project.removeSourceFile(source);
+        }
+        catch {
+            console.log(chalk_1.default.gray(`skip: ${file}`));
+        }
+    };
+    const watcher = chokidar_1.default.watch(config.sync.include, {
+        ignored: [
+            ...config.sync.exclude,
+            "**/*.log",
+            "**/*.tmp",
+            "**/*.swp"
+        ],
+        ignoreInitial: true
+    });
+    watcher.on("change", (file) => {
+        queue.add(file);
+        clearTimeout(timer);
+        timer = setTimeout(processQueue, 200);
+    });
+}

package/dist/index.js

@@ -42,28 +42,32 @@ program
     .version("0.0.1");
 program
     .command("init")
-    .description("Initialize Eventra")
     .action(async () => {
     const { init } = await Promise.resolve().then(() => __importStar(require("./commands/init")));
     await init();
 });
 program
     .command("sync")
-    .description("Sync events")
     .action(async () => {
     const { sync } = await Promise.resolve().then(() => __importStar(require("./commands/sync")));
     await sync();
 });
 program
     .command("check")
-    .description("Validate events (CI mode)")
-    .action(async () => {
+    .option("--fix", "auto fix issues")
+    .action(async (opts) => {
     const { check } = await Promise.resolve().then(() => __importStar(require("./commands/check")));
-    await check();
+    await check({ fix: opts.fix });
+});
+program
+    .command("watch")
+    .description("Watch files and detect events in real-time")
+    .action(async () => {
+    const { watch } = await Promise.resolve().then(() => __importStar(require("./commands/watch")));
+    await watch();
 });
 program
     .command("send")
-    .description("Send events")
     .action(async () => {
     const { send } = await Promise.resolve().then(() => __importStar(require("./commands/send")));
     await send();

package/dist/utils/detect-aliases.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAliases = detectAliases;
+const ts_morph_1 = require("ts-morph");
+function detectAliases(source) {
+    const aliases = {};
+    const vars = source.getDescendantsOfKind(ts_morph_1.SyntaxKind.VariableDeclaration);
+    for (const v of vars) {
+        const name = v.getName();
+        const init = v.getInitializer();
+        if (!init)
+            continue;
+        // const A = "event"
+        if (ts_morph_1.Node.isStringLiteral(init)) {
+            aliases[name] = init.getLiteralText();
+            continue;
+        }
+        // const A = `event`
+        if (init.getKind() === ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
+            aliases[name] = init.getText().replace(/`/g, "");
+            continue;
+        }
+        // const EVENTS = { CLICK: "click" }
+        if (ts_morph_1.Node.isObjectLiteralExpression(init)) {
+            for (const p of init.getProperties()) {
+                if (!ts_morph_1.Node.isPropertyAssignment(p))
+                    continue;
+                const key = p.getName();
+                const val = p.getInitializer();
+                if (!val)
+                    continue;
+                if (ts_morph_1.Node.isStringLiteral(val)) {
+                    aliases[`${name}.${key}`] = val.getLiteralText();
+                }
+            }
+        }
+    }
+    return aliases;
+}

package/dist/utils/detect-wrappers.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectWrappers = detectWrappers;
+const ts_morph_1 = require("ts-morph");
+function detectWrappers(source) {
+    return {
+        functions: detectFunctionWrappers(source),
+        components: detectComponentWrappers(source)
+    };
+}
+// FUNCTIONS
+function detectFunctionWrappers(source) {
+    const result = new Map();
+    const functions = [
+        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionDeclaration),
+        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.ArrowFunction),
+        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionExpression)
+    ];
+    for (const fn of functions) {
+        const body = fn.getBody();
+        if (!body)
+            continue;
+        const calls = body.getDescendantsOfKind(ts_morph_1.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;
+            if (arg && ts_morph_1.Node.isObjectLiteralExpression(arg)) {
+                const prop = arg.getProperties()[0];
+                if (prop && ts_morph_1.Node.isPropertyAssignment(prop)) {
+                    eventField = prop.getName();
+                }
+            }
+            result.set(name, { name, event: eventField });
+        }
+    }
+    return [...result.values()];
+}
+function isTrackCall(call) {
+    const expr = call.getExpression();
+    if (ts_morph_1.Node.isIdentifier(expr)) {
+        return expr.getText() === "track";
+    }
+    if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
+        return expr.getName() === "track";
+    }
+    return false;
+}
+function getFunctionName(fn) {
+    if (ts_morph_1.Node.isFunctionDeclaration(fn)) {
+        return fn.getName() ?? null;
+    }
+    const varDecl = fn.getFirstAncestorByKind(ts_morph_1.SyntaxKind.VariableDeclaration);
+    return varDecl?.getName() ?? null;
+}
+// COMPONENTS
+function detectComponentWrappers(source) {
+    const result = new Map();
+    const elements = [
+        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxOpeningElement),
+        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxSelfClosingElement)
+    ];
+    for (const el of elements) {
+        const name = el.getTagNameNode().getText();
+        for (const attr of el.getAttributes()) {
+            const a = attr.asKind(ts_morph_1.SyntaxKind.JsxAttribute);
+            if (!a)
+                continue;
+            const prop = a.getNameNode().getText();
+            const val = a.getInitializer();
+            if (!val)
+                continue;
+            if (ts_morph_1.Node.isStringLiteral(val) ||
+                ts_morph_1.Node.isJsxExpression(val)) {
+                result.set(name, { name, prop });
+            }
+        }
+    }
+    return [...result.values()];
+}

package/dist/utils/extract.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractExpression = extractExpression;
 const ts_morph_1 = require("ts-morph");
-function extractExpression(expr) {
+function extractExpression(expr, aliases) {
     // "event"
     if (ts_morph_1.Node.isStringLiteral(expr)) {
         return {
@@ -11,124 +11,44 @@ function extractExpression(expr) {
         };
     }
     // `event`
-    if (expr.getKind() ===
-        ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
+    if (expr.getKind() === ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
         return {
-            values: [
-                expr.getText().replace(/`/g, "")
-            ],
+            values: [expr.getText().replace(/`/g, "")],
             dynamic: false
         };
     }
-    // identifier (TEST)
+    // IDENTIFIER
     if (ts_morph_1.Node.isIdentifier(expr)) {
         const name = expr.getText();
-        const defs = "getDefinitions" in expr
-            ? expr.getDefinitions()
-            : [];
-        if (defs && defs.length > 0) {
-            const decl = defs[0]?.getDeclarationNode();
-            if (decl && ts_morph_1.Node.isVariableDeclaration(decl)) {
-                const initializer = decl.getInitializer();
-                // const TEST = "event"
-                if (initializer &&
-                    ts_morph_1.Node.isStringLiteral(initializer)) {
-                    return {
-                        values: [initializer.getLiteralText()],
-                        dynamic: false
-                    };
-                }
-                // const TEST = `event`
-                if (initializer &&
-                    initializer.getKind() ===
-                        ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
-                    return {
-                        values: [
-                            initializer.getText().replace(/`/g, "")
-                        ],
-                        dynamic: false
-                    };
-                }
-            }
+        if (name in aliases) {
+            return {
+                values: [aliases[name]],
+                dynamic: false
+            };
         }
         return {
             values: [name],
             dynamic: true
         };
     }
-    // property access (EVENTS.CLICK)
+    // PROPERTY ACCESS
     if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
-        const fullName = expr.getText(); // EVENTS.CLICK
-        const propName = expr.getName(); // CLICK
-        const defs = "getDefinitions" in expr
-            ? expr.getDefinitions()
-            : [];
-        if (defs && defs.length > 0) {
-            const decl = defs[0]?.getDeclarationNode();
-            // const EVENTS = { CLICK: "event" }
-            if (decl && ts_morph_1.Node.isVariableDeclaration(decl)) {
-                const init = decl.getInitializer();
-                if (init && ts_morph_1.Node.isObjectLiteralExpression(init)) {
-                    const prop = init.getProperty(propName);
-                    if (prop &&
-                        ts_morph_1.Node.isPropertyAssignment(prop)) {
-                        const value = prop.getInitializer();
-                        if (value &&
-                            ts_morph_1.Node.isStringLiteral(value)) {
-                            return {
-                                values: [value.getLiteralText()],
-                                dynamic: false
-                            };
-                        }
-                    }
-                }
-            }
-            // fallback
-            if (decl && ts_morph_1.Node.isPropertyAssignment(decl)) {
-                const initializer = decl.getInitializer();
-                if (initializer &&
-                    ts_morph_1.Node.isStringLiteral(initializer)) {
-                    return {
-                        values: [initializer.getLiteralText()],
-                        dynamic: false
-                    };
-                }
-            }
+        const name = expr.getText();
+        if (name in aliases) {
+            return {
+                values: [aliases[name]],
+                dynamic: false
+            };
         }
         return {
-            values: [fullName],
-            dynamic: true
-        };
-    }
-    // ternary (a ? b : c)
-    if (ts_morph_1.Node.isConditionalExpression(expr)) {
-        const values = [];
-        const whenTrue = extractExpression(expr.getWhenTrue());
-        const whenFalse = extractExpression(expr.getWhenFalse());
-        if (whenTrue)
-            values.push(...whenTrue.values);
-        if (whenFalse)
-            values.push(...whenFalse.values);
-        return {
-            values,
+            values: [name],
             dynamic: true
         };
     }
     // template `${}`
     if (ts_morph_1.Node.isTemplateExpression(expr)) {
         return {
-            values: [
-                expr.getText().replace(/`/g, "")
-            ],
-            dynamic: true
-        };
-    }
-    // call (fn())
-    if (ts_morph_1.Node.isCallExpression(expr)) {
-        return {
-            values: [
-                expr.getExpression().getText()
-            ],
+            values: [expr.getText()],
             dynamic: true
         };
     }

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

@@ -3,8 +3,8 @@ 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();
+function scanComponentWrappers(source, wrappers, aliases) {
+    const events = new Map();
     const elements = [
         ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxOpeningElement),
         ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxSelfClosingElement)
@@ -17,12 +17,9 @@ function scanComponentWrappers(source, wrappers) {
         for (const wrapper of wrappers) {
             if (name !== wrapper.name.toLowerCase())
                 continue;
-            const attrs = el.getAttributes();
-            for (const attr of attrs) {
-                // ❗ NO spread props
-                if (ts_morph_1.Node.isJsxSpreadAttribute(attr)) {
+            for (const attr of el.getAttributes()) {
+                if (ts_morph_1.Node.isJsxSpreadAttribute(attr))
                     continue;
-                }
                 const attrNode = attr.asKind(ts_morph_1.SyntaxKind.JsxAttribute);
                 if (!attrNode)
                     continue;
@@ -35,36 +32,42 @@ function scanComponentWrappers(source, wrappers) {
                 const init = attrNode.getInitializer();
                 // <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 (ts_morph_1.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 (ts_morph_1.Node.isJsxExpression(init)) {
                     const expr = init.getExpression();
                     if (!expr)
                         continue;
-                    const result = (0, extract_1.extractExpression)(expr);
+                    const result = (0, extract_1.extractExpression)(expr, aliases);
                     if (!result)
                         continue;
-                    result.values.forEach((value) => events.add({
-                        value,
-                        dynamic: result.dynamic
-                    }));
-                    continue;
+                    for (const value of result.values) {
+                        const k = `${value}:${result.dynamic}`;
+                        events.set(k, {
+                            value,
+                            dynamic: result.dynamic
+                        });
+                    }
                 }
             }
         }
     }
-    return events;
+    return [...events.values()];
 }