@eventra_dev/eventra-cli 0.0.17 → 0.0.19

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,21 +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")
+    .option("--fix", "auto fix issues")
+    .action(async (opts) => {
+    const { check } = await Promise.resolve().then(() => __importStar(require("./commands/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()];
 }

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

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanFunctionWrappers = scanFunctionWrappers;
 const ts_morph_1 = require("ts-morph");
 const extract_1 = require("../extract");
-function scanFunctionWrappers(source, wrappers) {
-    const events = new Set();
+function scanFunctionWrappers(source, wrappers, aliases) {
+    const events = new Map();
     const calls = source.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
     for (const call of calls) {
         const name = getFunctionName(call);
@@ -13,13 +13,16 @@ function scanFunctionWrappers(source, wrappers) {
         for (const wrapper of wrappers) {
             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) {
     const expression = call.getExpression();
@@ -35,21 +38,18 @@ function getDeepName(node) {
     let current = node;
     let name = "";
     while (ts_morph_1.Node.isPropertyAccessExpression(current)) {
-        name =
-            current.getName();
-        current =
-            current.getExpression();
+        name = current.getName();
+        current = current.getExpression();
     }
     return name;
 }
-function extractEventFromArgs(call, event) {
+function extractEventFromArgs(call, event, aliases) {
     const args = call.getArguments();
     const events = [];
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
+    for (const arg of args) {
         // track("event")
         if (!event) {
-            const result = (0, extract_1.extractExpression)(arg);
+            const result = (0, extract_1.extractExpression)(arg, aliases);
             if (!result)
                 continue;
             result.values.forEach((value) => events.push({
@@ -57,7 +57,7 @@ function extractEventFromArgs(call, event) {
                 dynamic: result.dynamic
             }));
         }
-        // track({event})
+        // track({ event })
         if (event) {
             const obj = arg.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
             if (!obj)
@@ -69,7 +69,7 @@ function extractEventFromArgs(call, event) {
                 const init = prop.getInitializer();
                 if (!init)
                     continue;
-                const result = (0, extract_1.extractExpression)(init);
+                const result = (0, extract_1.extractExpression)(init, aliases);
                 if (!result)
                     continue;
                 result.values.forEach((value) => events.push({
@@ -79,7 +79,5 @@ function extractEventFromArgs(call, event) {
             }
         }
     }
-    return events.length
-        ? events
-        : null;
+    return events.length ? events : null;
 }

package/dist/utils/scanners/track.js

@@ -1,10 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanTrack = scanTrack;
 const ts_morph_1 = require("ts-morph");
+const path_1 = __importDefault(require("path"));
 const extract_1 = require("../extract");
-function scanTrack(source, config) {
-    const events = new Set();
+function scanTrack(source, config, aliases) {
+    const events = new Map();
     const calls = source.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
     for (const call of calls) {
         const expr = call.getExpression();
@@ -19,6 +23,7 @@ function scanTrack(source, config) {
         }
         if (!isTrack)
             continue;
+        // ❗ skip wrapper functions
         const func = call.getFirstAncestorByKind(ts_morph_1.SyntaxKind.FunctionDeclaration) ||
             call.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ArrowFunction) ||
             call.getFirstAncestorByKind(ts_morph_1.SyntaxKind.FunctionExpression);
@@ -40,13 +45,20 @@ function scanTrack(source, config) {
         const arg = call.getArguments()[0];
         if (!arg)
             continue;
-        const result = (0, extract_1.extractExpression)(arg);
+        const result = (0, extract_1.extractExpression)(arg, aliases);
         if (!result)
             continue;
-        result.values.forEach((value) => events.add({
-            value,
-            dynamic: result.dynamic,
-        }));
+        const line = call.getStartLineNumber();
+        const file = path_1.default.relative(process.cwd(), source.getFilePath());
+        for (const value of result.values) {
+            const key = `${value}:${file}:${line}`;
+            events.set(key, {
+                value,
+                dynamic: result.dynamic,
+                file,
+                line
+            });
+        }
     }
-    return events;
+    return [...events.values()];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {
@@ -20,6 +20,7 @@
   },
   "dependencies": {
     "chalk": "^4.1.2",
+    "chokidar": "^5.0.0",
     "commander": "^11.0.0",
     "fast-glob": "^3.3.3",
     "fs-extra": "^11.2.0",