@eventra_dev/eventra-cli 2.1.0 → 2.2.0

package/dist/core/skipped.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanSkipReason = cleanSkipReason;
+exports.errorMessage = errorMessage;
+exports.skippedFrom = skippedFrom;
+exports.formatSkipped = formatSkipped;
+exports.reportSkipped = reportSkipped;
+exports.formatIgnored = formatIgnored;
+exports.reportIgnored = reportIgnored;
+exports.plural = plural;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+/**
+ * A skipped file's error is wrapped once by the CLI, once by the plugin
+ * adapter and once by the plugin itself, each repeating the path. Keep only the
+ * innermost message.
+ */
+function cleanSkipReason(file, message) {
+    let text = message.split(file).join("").trim();
+    text = text.replace(/^Plugin "[^"]*" failed to transform\s*:\s*/, "");
+    text = text.replace(/^Failed to parse [A-Za-z][A-Za-z ]*?\s*:\s*/, "");
+    return text.replace(/\s+/g, " ").trim() || "unknown error";
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function skippedFrom(file, err) {
+    return { file, reason: cleanSkipReason(file, errorMessage(err)) };
+}
+function formatSkipped(skipped, cwd) {
+    if (skipped.length === 0)
+        return [];
+    const lines = [
+        `Skipped ${skipped.length} file${skipped.length === 1 ? "" : "s"} that could not be analysed:`,
+    ];
+    for (const { file, reason } of skipped) {
+        lines.push(`  ${path_1.default.relative(cwd, file).replace(/\\/g, "/")}: ${reason}`);
+    }
+    return lines;
+}
+/** Prints one summary block (stderr) for everything skipped in a scan. */
+function reportSkipped(skipped, cwd = process.cwd()) {
+    const lines = formatSkipped(skipped, cwd);
+    if (lines.length === 0)
+        return;
+    console.error(chalk_1.default.yellow(lines.join("\n")));
+    console.error(chalk_1.default.gray("Events from these files are not in this scan; previously known events were kept. Use --strict to fail on skipped files."));
+}
+/**
+ * Files that were deliberately not analysed (for example generated bundles
+ * over the size limit). Unlike skipped files they are not failures: their
+ * absence neither keeps known events nor makes a catalog snapshot incomplete.
+ */
+function formatIgnored(ignored, cwd) {
+    if (ignored.length === 0)
+        return [];
+    const lines = [
+        `Ignored ${ignored.length} file${ignored.length === 1 ? "" : "s"} (not analysed):`,
+    ];
+    for (const { file, reason } of ignored) {
+        lines.push(`  ${path_1.default.relative(cwd, file).replace(/\\/g, "/")}: ${reason}`);
+    }
+    return lines;
+}
+/** Prints one note (stderr) for everything ignored in a scan. */
+function reportIgnored(ignored, cwd = process.cwd()) {
+    const lines = formatIgnored(ignored, cwd);
+    if (lines.length === 0)
+        return;
+    console.error(chalk_1.default.gray(lines.join("\n")));
+}
+function plural(count, singular, pluralForm = `${singular}s`) {
+    return `${count} ${count === 1 ? singular : pluralForm}`;
+}

package/dist/index.js

@@ -46,22 +46,25 @@ program
     .version(package_json_1.default.version);
 program
     .command("init")
-    .action(async () => {
+    .option("-y, --yes", "do not prompt: accept defaults and keep an existing eventra.json")
+    .action(async (opts) => {
     const { init } = await Promise.resolve().then(() => __importStar(require("./cli/init")));
-    await init();
+    await init({ yes: opts.yes });
 });
 program
     .command("sync")
-    .action(async () => {
+    .option("--strict", "exit with a non-zero code if any file could not be analysed")
+    .action(async (opts) => {
     const { sync } = await Promise.resolve().then(() => __importStar(require("./cli/sync")));
-    await sync();
+    await sync({ strict: opts.strict });
 });
 program
     .command("check")
     .option("--fix", "auto fix issues")
+    .option("--strict", "exit with a non-zero code if any file could not be analysed")
     .action(async (opts) => {
     const { check } = await Promise.resolve().then(() => __importStar(require("./cli/check")));
-    await check({ fix: opts.fix });
+    await check({ fix: opts.fix, strict: opts.strict });
 });
 program
     .command("watch")

package/dist/plugin/builtins/consoleDynamicEventReporter.js

@@ -5,16 +5,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerConsoleDynamicEventReporterPlugin = registerConsoleDynamicEventReporterPlugin;
 const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+// paths are printed relative to where the command runs, with forward slashes
+function displayPath(fileName) {
+    const relative = path_1.default.relative(process.cwd(), fileName);
+    const outside = relative === ".." || relative.startsWith(`..${path_1.default.sep}`) || relative.startsWith("../");
+    const shown = relative && !outside && !path_1.default.isAbsolute(relative) ? relative : fileName;
+    return shown.replace(/\\/g, "/");
+}
 const consoleDynamicEventReporter = {
     name: "console",
-    report({ occurrences }) {
+    report({ occurrences: all }) {
+        // the copy of a component class inside an Angular template module repeats a call the class file already reports
+        const occurrences = all.filter((occ) => !occ.inGeneratedCode);
         if (occurrences.length === 0) {
             return;
         }
         console.log(chalk_1.default.blue("\nDynamic event names:"));
         for (const occ of occurrences) {
             const values = occ.resolvedValues.length > 0 ? ` (resolved: ${occ.resolvedValues.join(", ")})` : "";
-            console.log(chalk_1.default.yellow(`~ ${occ.fileName}:${occ.line} ${occ.calleeText}(...)${values}`));
+            const file = displayPath(occ.fileName);
+            if (occ.inTemplate) {
+                console.log(chalk_1.default.yellow(`~ template of ${file}: event="${occ.eventExpression ?? ""}"${values}`));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`~ ${file}:${occ.line} ${occ.calleeText}(...)${values}`));
+            }
         }
     },
 };

package/dist/plugin/loadPlugins.js

@@ -32,10 +32,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTrustedPluginSpecifier = isTrustedPluginSpecifier;
 exports.createBuiltinPluginRegistry = createBuiltinPluginRegistry;
 exports.createPluginRegistry = createPluginRegistry;
+const module_1 = require("module");
+const path_1 = __importDefault(require("path"));
 const external_1 = require("./adapters/external");
 const configuredSinks_1 = require("./builtins/configuredSinks");
 const eventra_sdk_1 = require("./builtins/eventra-sdk");
@@ -69,6 +74,19 @@ function pluginLoadHint(spec) {
     }
     return "";
 }
+/**
+ * Plugins are installed in the user's project, not next to the CLI (a global
+ * install, npx or a pnpm layout would not find them from here), so resolve from
+ * the project first and fall back to normal resolution relative to the CLI.
+ */
+function resolveFromProject(spec) {
+    try {
+        return (0, module_1.createRequire)(path_1.default.join(process.cwd(), "package.json")).resolve(spec);
+    }
+    catch {
+        return spec;
+    }
+}
 async function loadExternalPlugin(registry, spec) {
     const trimmed = spec.trim();
     // Defensive-only: the sole caller (createPluginRegistry) already does
@@ -80,7 +98,7 @@ async function loadExternalPlugin(registry, spec) {
         return;
     let mod;
     try {
-        mod = await Promise.resolve(`${trimmed}`).then(s => __importStar(require(s)));
+        mod = await Promise.resolve(`${resolveFromProject(trimmed)}`).then(s => __importStar(require(s)));
     }
     catch (err) {
         // Node's dynamic import() only ever rejects with an Error (module
@@ -114,7 +132,7 @@ async function createPluginRegistry(config) {
         if (!trimmed)
             continue;
         if (!isTrustedPluginSpecifier(trimmed)) {
-            console.warn(`Eventra: skipping plugin "${trimmed}" — only official @eventra_dev/cli-plugin-* packages can be loaded.${pluginLoadHint(trimmed)}`);
+            console.warn(`Eventra: skipping plugin "${trimmed}" - only official @eventra_dev/cli-plugin-* packages can be loaded.${pluginLoadHint(trimmed)}`);
             continue;
         }
         await loadExternalPlugin(registry, trimmed);

package/dist/plugin/registry.js

@@ -5,6 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginRegistry = void 0;
 const path_1 = __importDefault(require("path"));
+// the synthetic callee each framework plugin uses for a template `event=...`
+const TEMPLATE_CALLEE = /^__eventra_[a-z]+_template_event__$/;
+// `__eventra_x_template_event__(expr)` (callText may be cut with an ellipsis)
+function templateExpression(occurrence) {
+    const open = occurrence.callText.indexOf("(");
+    let expression = open === -1 ? occurrence.callText : occurrence.callText.slice(open + 1);
+    expression = expression.endsWith(")") ? expression.slice(0, -1) : expression;
+    // Angular qualifies a bare name with `this.`; the template never writes it
+    return occurrence.calleeText.includes("_angular_") ? expression.replace(/^this\./, "") : expression;
+}
 class PluginRegistry {
     preprocessors = [];
     sinkDetectors = [];
@@ -101,9 +111,48 @@ class PluginRegistry {
         return null;
     }
     async runDynamicEventReporters(occurrences) {
+        const attributed = this.attributeToSources(occurrences);
         for (const reporter of this.dynamicEventReporters) {
-            await reporter.report({ occurrences });
+            await reporter.report({ occurrences: attributed });
+        }
+    }
+    /**
+     * Occurrences are found in virtual modules (`App.vue.ts`). Point them back
+     * at the file the user wrote, and flag the ones that come from generated
+     * code so reporters do not print a line number that exists nowhere.
+     */
+    attributeToSources(occurrences) {
+        if (this.sourceToVirtuals.size === 0) {
+            return occurrences;
         }
+        const virtualToSource = new Map();
+        for (const [source, virtuals] of this.sourceToVirtuals) {
+            for (const virtual of virtuals) {
+                if (virtual !== source) {
+                    virtualToSource.set(virtual, source);
+                }
+            }
+        }
+        return occurrences.map((occurrence) => {
+            const source = virtualToSource.get(this.normalizePath(occurrence.fileName));
+            if (!source) {
+                return occurrence;
+            }
+            const template = TEMPLATE_CALLEE.test(occurrence.calleeText);
+            if (template) {
+                return {
+                    ...occurrence,
+                    fileName: source,
+                    inTemplate: true,
+                    eventExpression: templateExpression(occurrence),
+                };
+            }
+            // an Angular template module embeds the component class: lines there
+            // are generated, the real call is also reported from the class file
+            return source.toLowerCase().endsWith(".html")
+                ? { ...occurrence, fileName: source, inGeneratedCode: true }
+                : { ...occurrence, fileName: source };
+        });
     }
     normalizePath(fileName) {
         return path_1.default.resolve(fileName).replace(/\\/g, "/");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Static analytics event extraction CLI powered by the TypeScript compiler API",
   "license": "MIT",
   "author": {
@@ -37,7 +37,8 @@
     "test:e2e": "pnpm run clean && pnpm run build && tsx tests/run.ts",
     "clean": "rm -rf dist",
     "test:mutation": "stryker run",
-    "check:presets": "tsx scripts/check-preset-packages.ts"
+    "check:presets": "tsx scripts/check-preset-packages.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
     "chalk": "^4.1.2",