@eventra_dev/eventra-cli 2.0.10 → 2.2.0

package/dist/core/projectScanner.js

@@ -12,59 +12,47 @@ const EventraEngine_1 = require("./EventraEngine");
 const processFile_1 = require("../filesystem/processFile");
 const getVirtualFile_1 = require("../filesystem/getVirtualFile");
 const loadPlugins_1 = require("../plugin/loadPlugins");
+const scanFilters_1 = require("./scanFilters");
+const skipped_1 = require("./skipped");
+const fileLimits_1 = require("./fileLimits");
 const SDK_TYPES_FILE = "__eventra_sdk_types__.d.ts";
-async function getParsedFile(file, cache) {
-    const existing = cache.get(file);
-    if (existing)
-        return existing;
-    const raw = await promises_1.default.readFile(file, "utf8");
-    const parsed = await (0, processFile_1.processFile)(file, raw);
-    cache.set(file, parsed);
-    return parsed;
-}
 async function scanProject(config) {
     const plugins = await (0, loadPlugins_1.createPluginRegistry)(config);
     const include = [...config.sync.include, ...plugins.getIncludePatterns()];
     const files = await (0, fast_glob_1.default)(include, {
-        ignore: config.sync.exclude,
+        ignore: (0, scanFilters_1.expandExcludePatterns)(config.sync.exclude),
         absolute: true,
     });
     const engine = new EventraEngine_1.EventraEngine(process.cwd(), plugins);
     const cache = new Map();
     const toScan = new Set();
+    const skipped = [];
+    const ignored = [];
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf8");
-            if (raw.length > 2_000_000)
+            if ((0, fileLimits_1.isOversized)(raw)) {
+                ignored.push({ file, reason: fileLimits_1.OVERSIZED_REASON });
                 continue;
+            }
             const virtualFiles = await plugins.preprocessFile({ fileName: file, content: raw });
             for (const virtualFile of virtualFiles) {
                 const parsed = await (0, processFile_1.processFile)(virtualFile.fileName, virtualFile.content);
                 const scanPath = path_1.default.resolve(virtualFile.fileName);
                 cache.set(scanPath, parsed);
                 toScan.add(scanPath);
-                for (const dep of parsed.dependencies) {
-                    if (dep.startsWith(".") || dep.startsWith("/")) {
-                        toScan.add(path_1.default.resolve(path_1.default.dirname(scanPath), dep));
-                    }
-                }
             }
         }
         catch (err) {
-            console.error(`skip: ${file}`, err instanceof Error ? err.message : err);
+            skipped.push((0, skipped_1.skippedFrom)(file, err));
         }
     }
     const virtualFiles = [SDK_TYPES_FILE, ...toScan].map((f) => (0, getVirtualFile_1.getVirtualFile)(f));
     engine.beginPreload();
     await engine.preloadFile(SDK_TYPES_FILE, eventraSdk_1.EVENTRA_SDK_SHIM);
     for (const file of toScan) {
-        try {
-            const parsed = await getParsedFile(file, cache);
-            await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content);
-        }
-        catch (err) {
-            console.error(`preload skip: ${file}`, err instanceof Error ? err.message : err);
-        }
+        // every path in toScan was parsed and cached in the loop above
+        await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(file), cache.get(file).content);
     }
     engine.endPreload();
     await engine.runFullAnalysis(virtualFiles, config);
@@ -77,5 +65,7 @@ async function scanProject(config) {
         results,
         files,
         plugins,
+        skipped,
+        ignored,
     };
 }

package/dist/core/scanFilters.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandExcludePatterns = expandExcludePatterns;
+exports.globToRegExp = globToRegExp;
+exports.toPosix = toPosix;
+exports.createFileFilter = createFileFilter;
+const path_1 = __importDefault(require("path"));
+const GLOB_CHARS = /[*?[\]{}()!]/;
+/**
+ * `sync.exclude` entries are written as bare directory names (`node_modules`,
+ * `dist`). fast-glob only matches a bare name against the repo root, so a
+ * nested `packages/x/node_modules` would still be scanned. A plain name is
+ * therefore expanded to match at any depth; entries that already contain a
+ * `/` or glob characters are left exactly as written.
+ */
+function expandExcludePatterns(exclude) {
+    const out = new Set();
+    for (const entry of exclude) {
+        const pattern = entry.trim();
+        if (!pattern)
+            continue;
+        if (pattern.includes("/") || GLOB_CHARS.test(pattern)) {
+            out.add(pattern);
+        }
+        else {
+            out.add(`**/${pattern}`);
+            out.add(`**/${pattern}/**`);
+        }
+    }
+    return [...out];
+}
+// fast-glob runs with dot:false: `*`, `**` and `?` never match a path segment
+// that starts with a dot (.svelte-kit, .nuxt, .turbo, ...) unless the glob
+// spells the dot itself (`.github/**`). The watch filter must agree, or
+// generated output in those directories leaks in while `sync` ignores it.
+const NO_DOT = "(?!\\.)";
+/** Converts the glob subset used by eventra configs (`**`, `*`, `?`, `{a,b}`, `[..]`) to a RegExp. */
+function globToRegExp(glob) {
+    const source = glob.replace(/^\.\//, "");
+    let out = "";
+    let braceDepth = 0;
+    // a segment starts at the beginning, after a slash, or at a brace alternative
+    const atSegmentStart = (i) => i === 0 || "/{,".includes(source[i - 1]);
+    for (let i = 0; i < source.length; i++) {
+        const ch = source[i];
+        if (ch === "*") {
+            if (source[i + 1] === "*") {
+                if (source[i + 2] === "/" && atSegmentStart(i)) {
+                    // zero or more whole segments, none of them hidden
+                    out += `(?:${NO_DOT}[^/]+/)*`;
+                    i += 2;
+                }
+                else if (i + 2 >= source.length && atSegmentStart(i)) {
+                    // trailing `**`: everything below, again without hidden segments
+                    out += `(?:${NO_DOT}[^/]+/)*(?:${NO_DOT}[^/]*)?`;
+                    i += 1;
+                }
+                else {
+                    out += ".*";
+                    i += 1;
+                }
+            }
+            else {
+                out += `${atSegmentStart(i) ? NO_DOT : ""}[^/]*`;
+            }
+        }
+        else if (ch === "?") {
+            out += `${atSegmentStart(i) ? NO_DOT : ""}[^/]`;
+        }
+        else if (ch === "{") {
+            braceDepth++;
+            out += "(?:";
+        }
+        else if (ch === "}" && braceDepth > 0) {
+            braceDepth--;
+            out += ")";
+        }
+        else if (ch === "," && braceDepth > 0) {
+            out += "|";
+        }
+        else if (ch === "[") {
+            const end = source.indexOf("]", i + 1);
+            if (end === -1) {
+                out += "\\[";
+            }
+            else {
+                out += source.slice(i, end + 1);
+                i = end;
+            }
+        }
+        else {
+            out += ch.replace(/[.+^$()|\\\]]/g, "\\$&");
+        }
+    }
+    return new RegExp(`^${out}$`);
+}
+function toPosix(file) {
+    return file.replace(/\\/g, "/");
+}
+/**
+ * Mirrors what the initial fast-glob scan accepts, so watch mode reacts to the
+ * same files as `sync`.
+ */
+function createFileFilter(include, exclude, cwd, alwaysExcluded = []) {
+    const includeRes = include.filter((p) => !p.startsWith("!")).map(globToRegExp);
+    const negatedRes = include
+        .filter((p) => p.startsWith("!"))
+        .map((p) => globToRegExp(p.slice(1)));
+    const excludeRes = exclude
+        .map((p) => p.trim())
+        .filter(Boolean)
+        .map((p) => {
+        const globbed = p.includes("/") || GLOB_CHARS.test(p) ? p : `**/${p}`;
+        return globToRegExp(globbed.replace(/\/+$/, ""));
+    });
+    const relative = (absPath) => toPosix(path_1.default.relative(cwd, absPath));
+    const isExcluded = (absPath) => {
+        const rel = relative(absPath);
+        if (alwaysExcluded.includes(rel))
+            return true;
+        const segments = rel.split("/");
+        // test every leading prefix so a match on a directory excludes what is inside it
+        for (let n = 1; n <= segments.length; n++) {
+            const prefix = segments.slice(0, n).join("/");
+            if (excludeRes.some((re) => re.test(prefix)))
+                return true;
+        }
+        return false;
+    };
+    return {
+        isExcluded,
+        isIncluded(absPath) {
+            const rel = relative(absPath);
+            if (rel === ".." || rel.startsWith("../") || path_1.default.isAbsolute(rel))
+                return false;
+            if (isExcluded(absPath))
+                return false;
+            if (negatedRes.some((re) => re.test(rel)))
+                return false;
+            return includeRes.some((re) => re.test(rel));
+        },
+    };
+}

package/dist/core/scanResults.js

@@ -3,16 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildConfigFromScan = buildConfigFromScan;
 exports.persistScanResults = persistScanResults;
 const config_1 = require("../config/config");
-function buildConfigFromScan(config, engine) {
-    const functionWrappers = engine
-        .getAllFunctionWrappers()
-        .map((name) => ({ name }));
+const uniqueSorted = (values) => [...new Set(values)].sort();
+function buildConfigFromScan(config, engine, options = {}) {
+    const foundWrappers = engine.getAllFunctionWrappers();
+    const foundEvents = engine.getAllEvents();
+    if (options.preserveKnown) {
+        return {
+            ...config,
+            events: uniqueSorted([...(config.events ?? []), ...foundEvents]),
+            functionWrappers: uniqueSorted([
+                ...(config.functionWrappers ?? []).map((w) => w.name),
+                ...foundWrappers,
+            ]).map((name) => ({ name })),
+        };
+    }
+    const functionWrappers = foundWrappers.map((name) => ({ name }));
     return {
         ...config,
-        events: engine.getAllEvents(),
+        events: foundEvents,
         functionWrappers,
     };
 }
-async function persistScanResults(config, engine) {
-    await (0, config_1.saveConfig)(buildConfigFromScan(config, engine));
+async function persistScanResults(config, engine, options = {}) {
+    const next = buildConfigFromScan(config, engine, options);
+    await (0, config_1.saveConfig)(next);
+    // what is now in eventra.json: callers report these counts
+    return (0, config_1.normalizeConfig)(next);
 }

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/configuredSinks.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSinkRules = resolveSinkRules;
+exports.createConfiguredSinkDetector = createConfiguredSinkDetector;
+exports.registerConfiguredSinks = registerConfiguredSinks;
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("../../analysis/shared/utils");
+const sinkPresets_1 = require("./sinkPresets");
+/** Expands presets and drops malformed rules. `warn` receives a message per dropped rule. */
+function resolveSinkRules(rules, warn) {
+    const resolved = [];
+    for (const rule of rules) {
+        if (rule.preset !== undefined) {
+            const preset = typeof rule.preset === "string" && Object.hasOwn(sinkPresets_1.SINK_PRESETS, rule.preset) ? sinkPresets_1.SINK_PRESETS[rule.preset] : undefined;
+            if (!preset) {
+                warn(`Eventra: unknown sinks preset "${rule.preset}" (available: ${Object.keys(sinkPresets_1.SINK_PRESETS).join(", ")}) - skipped.`);
+                continue;
+            }
+            resolved.push(...preset);
+            continue;
+        }
+        // eventra.json is hand-edited JSON: every field can hold any type, and a wrong one must be skipped, not crash.
+        const callee = typeof rule.callee === "string" ? rule.callee.trim() : undefined;
+        if (!callee || !/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(callee)) {
+            warn(`Eventra: sinks rule needs a "preset" or a dotted "callee" like "analytics.track" - skipped.`);
+            continue;
+        }
+        const nameArg = rule.nameArg ?? 0;
+        if (!Number.isInteger(nameArg) || nameArg < 0) {
+            warn(`Eventra: sinks rule "${callee}" has an invalid "nameArg" - skipped.`);
+            continue;
+        }
+        if (rule.nameProperty !== undefined && typeof rule.nameProperty !== "string") {
+            warn(`Eventra: sinks rule "${callee}" has an invalid "nameProperty" - skipped.`);
+            continue;
+        }
+        if (rule.modules !== undefined &&
+            (!Array.isArray(rule.modules) || !rule.modules.every((m) => typeof m === "string" && m !== ""))) {
+            warn(`Eventra: sinks rule "${callee}" has an invalid "modules" - skipped.`);
+            continue;
+        }
+        let when;
+        if (rule.when !== undefined) {
+            const candidate = rule.when;
+            if (!candidate ||
+                !Number.isInteger(candidate.arg) ||
+                candidate.arg < 0 ||
+                typeof candidate.equals !== "string" ||
+                candidate.equals === "") {
+                warn(`Eventra: sinks rule "${callee}" has an invalid "when" - skipped.`);
+                continue;
+            }
+            when = { arg: candidate.arg, equals: candidate.equals };
+        }
+        resolved.push({
+            callee,
+            nameArg,
+            ...(rule.nameProperty ? { nameProperty: rule.nameProperty } : {}),
+            ...(rule.modules?.length ? { modules: rule.modules } : {}),
+            ...(when ? { when } : {}),
+        });
+    }
+    return resolved;
+}
+/** `a.b.c` / `this.a.b` / `a?.b` -> "a.b.c"; null for anything that isn't a plain property path. */
+function calleePath(expr) {
+    const e = (0, utils_1.unwrapExpression)(expr);
+    if (typescript_1.default.isIdentifier(e))
+        return e.text;
+    if (e.kind === typescript_1.default.SyntaxKind.ThisKeyword)
+        return "this";
+    if (typescript_1.default.isPropertyAccessExpression(e)) {
+        const head = calleePath(e.expression);
+        return head === null ? null : `${head}.${e.name.text}`;
+    }
+    return null;
+}
+function moduleMatches(specifier, modules) {
+    return modules.some((m) => specifier === m || specifier.startsWith(`${m}/`));
+}
+const MAX_ALIAS_HOPS = 6;
+/** Identifiers naming the types in a type annotation: `PostHog`, `PostHog | null`, `ph.PostHog`. */
+function typeReferenceRoots(type) {
+    if (typescript_1.default.isParenthesizedTypeNode(type))
+        return typeReferenceRoots(type.type);
+    if (typescript_1.default.isUnionTypeNode(type) || typescript_1.default.isIntersectionTypeNode(type))
+        return type.types.flatMap(typeReferenceRoots);
+    if (typescript_1.default.isTypeReferenceNode(type)) {
+        let name = type.typeName;
+        while (typescript_1.default.isQualifiedName(name))
+            name = name.left;
+        return [name];
+    }
+    return [];
+}
+/**
+ * The symbol an identifier refers to, keeping an import as the import binding itself. TS resolves an
+ * import all the way to its target in some positions once something makes the module resolvable
+ * (a wildcard `declare module "*"` does that for every unresolved package), and the trail to the
+ * package's name is gone by then.
+ */
+function symbolAt(id, checker) {
+    const symbol = checker.getSymbolAtLocation(id);
+    // Stryker disable next-line ConditionalExpression: fast path only; the scope lookup below returns the same alias
+    if (symbol && symbol.flags & typescript_1.default.SymbolFlags.Alias)
+        return symbol;
+    return checker.getSymbolsInScope(id, typescript_1.default.SymbolFlags.Alias).find((alias) => alias.name === id.text) ?? symbol;
+}
+/** The symbol `name` exported by the module a specifier points at, when TS can resolve that module. */
+function resolveExport(specifier, name, checker) {
+    const moduleSymbol = checker.getSymbolAtLocation(specifier);
+    return moduleSymbol ? checker.tryGetMemberInModuleExports(name, moduleSymbol) : undefined;
+}
+/**
+ * `usePostHog()`, `new PostHog(k)`, `await init()`, `this.client`, `this.getClient()`,
+ * `AnalyticsBrowser.load()` or a bare alias `usePostHog`: true when the name at the heart of the
+ * expression, or the import its chain hangs off, originates from `modules`.
+ */
+function expressionFromModules(expression, checker, modules, hops) {
+    let expr = (0, utils_1.unwrapExpression)(expression);
+    if (typescript_1.default.isAwaitExpression(expr))
+        expr = (0, utils_1.unwrapExpression)(expr.expression);
+    if (typescript_1.default.isCallExpression(expr) || typescript_1.default.isNewExpression(expr))
+        expr = (0, utils_1.unwrapExpression)(expr.expression);
+    const fromName = (name) => typescript_1.default.isIdentifier(name) && symbolFromModules(symbolAt(name, checker), checker, modules, hops);
+    if (!typescript_1.default.isPropertyAccessExpression(expr))
+        return fromName(expr);
+    // `this.client` is vetted through the property's own declaration; `AnalyticsBrowser.load()` and
+    // `amplitude.getInstance()` hang off an import, so the chain's root decides.
+    let root = expr;
+    while (typescript_1.default.isPropertyAccessExpression(root))
+        root = (0, utils_1.unwrapExpression)(root.expression);
+    return fromName(expr.name) || fromName(root);
+}
+function declarationFromModules(decl, checker, modules, hops) {
+    if (typescript_1.default.isImportSpecifier(decl) || typescript_1.default.isImportClause(decl) || typescript_1.default.isNamespaceImport(decl)) {
+        // Every import binding sits under an ImportDeclaration, whose specifier is a string literal.
+        const importDecl = typescript_1.default.findAncestor(decl, typescript_1.default.isImportDeclaration);
+        if (moduleMatches(importDecl.moduleSpecifier.text, modules))
+            return true;
+        if (typescript_1.default.isNamespaceImport(decl))
+            return false;
+        const exported = typescript_1.default.isImportSpecifier(decl) ? (decl.propertyName ?? decl.name).text : "default";
+        return symbolFromModules(resolveExport(importDecl.moduleSpecifier, exported, checker), checker, modules, hops + 1);
+    }
+    if (typescript_1.default.isExportSpecifier(decl)) {
+        const specifier = decl.parent.parent.moduleSpecifier;
+        if (!specifier) {
+            // export { local as alias }
+            return symbolFromModules(checker.getExportSpecifierLocalTargetSymbol(decl), checker, modules, hops + 1);
+        }
+        // export { name as alias } from "module"
+        if (moduleMatches(specifier.text, modules))
+            return true;
+        const exported = (decl.propertyName ?? decl.name).text;
+        return symbolFromModules(resolveExport(specifier, exported, checker), checker, modules, hops + 1);
+    }
+    // export default client
+    if (typescript_1.default.isExportAssignment(decl)) {
+        return expressionFromModules(decl.expression, checker, modules, hops + 1);
+    }
+    // const { posthog } = usePostHog(): the binding's own declaration is the enclosing variable.
+    const owner = typescript_1.default.isBindingElement(decl) ? decl.parent.parent : decl;
+    // Variables, properties, parameters, functions (return type) and type aliases all keep their
+    // annotation in `type`; variables, properties and parameters keep a default/initial value in
+    // `initializer`. Anything else (classes, interfaces, ...) simply has neither.
+    const { type, initializer } = owner;
+    // let client: PostHog | null / private client: PostHog / (client: PostHog) => ... / type Client = PostHog
+    if (type &&
+        typeReferenceRoots(type).some((id) => symbolFromModules(symbolAt(id, checker), checker, modules, hops + 1))) {
+        return true;
+    }
+    // const ph = usePostHog() / new PostHog(k) / client = new PostHog(k) / const useTrack = usePostHog
+    return initializer !== undefined && expressionFromModules(initializer, checker, modules, hops + 1);
+}
+/**
+ * True when `symbol` originates from one of `modules`, following import/re-export chains
+ * (`import { useAnalytics } from "@/hooks"` -> `export { usePostHog as useAnalytics } from "posthog-js/react"`).
+ * Works without installed dependencies, by reading the specifiers along the chain.
+ */
+function symbolFromModules(symbol, checker, modules, hops = 0) {
+    if (!symbol || hops > MAX_ALIAS_HOPS)
+        return false;
+    // A real ts.Symbol's `declarations` is only undefined for synthetic symbols we never see here.
+    // Stryker disable next-line ArrayDeclaration: unreachable fallback, see above
+    /* v8 ignore next */
+    const declarations = symbol.declarations ?? [];
+    return declarations.some((decl) => declarationFromModules(decl, checker, modules, hops));
+}
+/** `rule.when`: the guard argument must be the exact string literal (`gtag("event", ...)` but not `gtag("config", ...)`). */
+function whenSatisfied(call, rule) {
+    if (!rule.when)
+        return true;
+    const guard = call.arguments[rule.when.arg];
+    const literal = guard && (0, utils_1.unwrapExpression)(guard);
+    return literal !== undefined && typescript_1.default.isStringLiteralLike(literal) && literal.text === rule.when.equals;
+}
+function trackedArgumentFor(call, rule) {
+    const arg = call.arguments[rule.nameArg];
+    if (!arg)
+        return null;
+    const literal = (0, utils_1.unwrapExpression)(arg);
+    if (typescript_1.default.isObjectLiteralExpression(literal)) {
+        // Only `{ event: name }` is a usable shape; the scanner reads this property off the literal.
+        // (`SpreadAssignment` has no name, hence the kind check.)
+        const found = literal.properties.some((p) => (typescript_1.default.isPropertyAssignment(p) || typescript_1.default.isShorthandPropertyAssignment(p)) && p.name.getText() === rule.nameProperty);
+        return found ? { index: rule.nameArg, propertyPath: [rule.nameProperty] } : null;
+    }
+    // Stryker disable next-line ArrayDeclaration: propertyPath is only read for object-literal arguments
+    return { index: rule.nameArg, propertyPath: [] };
+}
+function createConfiguredSinkDetector(rules) {
+    return {
+        name: "configured-sinks",
+        detect({ call, checker }) {
+            const callee = (0, utils_1.unwrapExpression)(call.expression);
+            // `gtag(...)` / `x.capture(...)`: the name actually being called.
+            const last = typescript_1.default.isIdentifier(callee) ? callee.text : typescript_1.default.isPropertyAccessExpression(callee) ? callee.name.text : null;
+            const path = calleePath(callee);
+            for (const rule of rules) {
+                // A dotted rule needs the whole plain path (`foo().analytics.track` has none); a bare name
+                // matches whatever receiver it hangs off, including a call (`usePostHog().capture`).
+                const matched = rule.callee.includes(".")
+                    ? path !== null && (path === rule.callee || path.endsWith(`.${rule.callee}`))
+                    : last === rule.callee;
+                if (!matched || !whenSatisfied(call, rule))
+                    continue;
+                // A bare name is too generic to match alone: a receiver-vetted rule checks where the receiver
+                // (`x` in `x.capture(...)`) or, for a bare call, the called name itself comes from.
+                if (rule.modules &&
+                    !expressionFromModules(typescript_1.default.isPropertyAccessExpression(callee) ? callee.expression : callee, checker, rule.modules, 0)) {
+                    continue;
+                }
+                const tracked = trackedArgumentFor(call, rule);
+                if (tracked)
+                    return { call, trackedArguments: [tracked] };
+            }
+            return null;
+        },
+    };
+}
+/** Registers the `sinks` rules from eventra.json (declarative data only - never code). */
+function registerConfiguredSinks(registry, rules, warn = (m) => console.warn(m)) {
+    if (!rules?.length)
+        return;
+    const resolved = resolveSinkRules(rules, warn);
+    if (resolved.length === 0)
+        return;
+    registry.registerSinkDetector(createConfiguredSinkDetector(resolved));
+}

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}`));
+            }
         }
     },
 };