@eventra_dev/eventra-cli 0.2.4 → 0.3.1

package/dist/compiler/compilerContext.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompilerContext = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
+const documentRegistry_1 = require("./documentRegistry");
+const processFile_1 = require("../filesystem/processFile");
+class CompilerContext {
+    rootDir;
+    registry = new documentRegistry_1.DocumentRegistry();
+    compilerOptions;
+    host;
+    builder;
+    rootNames = new Set();
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+        const configPath = typescript_1.default.findConfigFile(rootDir, typescript_1.default.sys.fileExists, "tsconfig.json");
+        let compilerOptions = {
+            target: typescript_1.default.ScriptTarget.ESNext,
+            module: typescript_1.default.ModuleKind.ESNext,
+            moduleResolution: typescript_1.default.ModuleResolutionKind.Bundler,
+            jsx: typescript_1.default.JsxEmit.Preserve,
+            allowJs: true,
+            checkJs: false,
+            strict: false,
+            skipLibCheck: true,
+            noEmit: true,
+            allowSyntheticDefaultImports: true,
+            esModuleInterop: true,
+            resolveJsonModule: true,
+            allowNonTsExtensions: true,
+            incremental: true,
+        };
+        if (configPath) {
+            const config = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+            if (config.error) {
+                throw new Error(typescript_1.default.flattenDiagnosticMessageText(config.error.messageText, "\n"));
+            }
+            const parsed = typescript_1.default.parseJsonConfigFileContent(config.config, typescript_1.default.sys, path_1.default.dirname(configPath));
+            compilerOptions = {
+                ...compilerOptions,
+                ...parsed.options,
+            };
+            for (const file of parsed.fileNames) {
+                this.rootNames.add(this.normalize(file));
+            }
+        }
+        this.compilerOptions =
+            compilerOptions;
+        this.host =
+            typescript_1.default.createCompilerHost(this.compilerOptions, true);
+        this.patchCompilerHost();
+        this.builder =
+            typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram([...this.rootNames], this.compilerOptions, this.host);
+    }
+    normalize(fileName) {
+        return this.registry
+            .normalize(fileName);
+    }
+    patchCompilerHost() {
+        const originalGetSourceFile = this.host.getSourceFile;
+        this.host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+            const normalized = this.normalize(fileName);
+            this.registry.ensure(normalized);
+            const snapshot = this.registry.getSnapshot(normalized);
+            if (!snapshot) {
+                return originalGetSourceFile(normalized, languageVersion, onError, shouldCreateNewSourceFile);
+            }
+            return typescript_1.default.createSourceFile(normalized, snapshot.getText(0, snapshot.getLength()), languageVersion, true, this.getScriptKind(normalized));
+        };
+        this.host.readFile = (fileName) => {
+            const normalized = this.normalize(fileName);
+            this.registry.ensure(normalized);
+            return (this.registry.getContent(normalized)
+                ?? fs_1.default.readFileSync(normalized, "utf8"));
+        };
+        this.host.fileExists = (fileName) => {
+            const normalized = this.normalize(fileName);
+            return (this.registry.has(normalized)
+                || fs_1.default.existsSync(normalized));
+        };
+        this.host.getCanonicalFileName =
+            (f) => this.normalize(f);
+        this.host.useCaseSensitiveFileNames =
+            () => true;
+        this.host.getCurrentDirectory =
+            () => this.rootDir;
+        this.host.getNewLine =
+            () => "\n";
+    }
+    getScriptKind(fileName) {
+        if (fileName.endsWith(".tsx")) {
+            return typescript_1.default.ScriptKind.TSX;
+        }
+        if (fileName.endsWith(".ts")) {
+            return typescript_1.default.ScriptKind.TS;
+        }
+        if (fileName.endsWith(".jsx")) {
+            return typescript_1.default.ScriptKind.JSX;
+        }
+        if (fileName.endsWith(".js")) {
+            return typescript_1.default.ScriptKind.JS;
+        }
+        if (fileName.endsWith(".json")) {
+            return typescript_1.default.ScriptKind.JSON;
+        }
+        return typescript_1.default.ScriptKind.Unknown;
+    }
+    rebuild() {
+        this.builder =
+            typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram([...this.rootNames], this.compilerOptions, this.host, this.builder);
+    }
+    async updateFile(fileName, content) {
+        const normalized = this.normalize(fileName);
+        const processed = await (0, processFile_1.processFile)(normalized, content);
+        this.registry.update(processed.fileName, processed.content);
+        this.rootNames.add(processed.fileName);
+        this.rebuild();
+    }
+    removeFile(fileName) {
+        const normalized = this.normalize(fileName);
+        this.registry.remove(normalized);
+        this.rootNames.delete(normalized);
+        this.rebuild();
+    }
+    invalidate() {
+        this.registry.invalidate();
+        this.rebuild();
+    }
+    getProgram() {
+        return this.builder
+            .getProgram();
+    }
+    getChecker() {
+        return this.builder
+            .getProgram()
+            .getTypeChecker();
+    }
+    getSourceFile(fileName) {
+        return this.builder
+            .getProgram()
+            .getSourceFile(this.normalize(fileName));
+    }
+    getSemanticDiagnostics(fileName) {
+        const program = this.builder.getProgram();
+        if (!fileName) {
+            return typescript_1.default.getPreEmitDiagnostics(program);
+        }
+        const sourceFile = this.getSourceFile(fileName);
+        if (!sourceFile) {
+            return [];
+        }
+        return [
+            ...program.getSemanticDiagnostics(sourceFile),
+            ...program.getSyntacticDiagnostics(sourceFile),
+        ];
+    }
+    resolveModule(moduleName, fromFile) {
+        const resolved = typescript_1.default.resolveModuleName(moduleName, this.normalize(fromFile), this.compilerOptions, this.host);
+        return resolved
+            .resolvedModule
+            ?.resolvedFileName;
+    }
+    getResolvedModules(fileName) {
+        const source = this.getSourceFile(fileName);
+        if (!source) {
+            return [];
+        }
+        const modules = new Set();
+        for (const statement of source.statements) {
+            if (!typescript_1.default.isImportDeclaration(statement)
+                && !typescript_1.default.isExportDeclaration(statement)) {
+                continue;
+            }
+            const specifier = statement.moduleSpecifier;
+            if (!specifier
+                || !typescript_1.default.isStringLiteral(specifier)) {
+                continue;
+            }
+            const resolved = this.resolveModule(specifier.text, source.fileName);
+            if (!resolved) {
+                continue;
+            }
+            modules.add(this.normalize(resolved));
+        }
+        return [
+            ...modules,
+        ];
+    }
+    getAllSourceFiles() {
+        return this.builder
+            .getProgram()
+            .getSourceFiles()
+            .filter(sf => !sf.isDeclarationFile);
+    }
+    getRealFileName(fileName) {
+        return fileName;
+    }
+}
+exports.CompilerContext = CompilerContext;

package/dist/compiler/documentRegistry.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentRegistry = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
+class DocumentRegistry {
+    documents = new Map();
+    normalize(fileName) {
+        return path_1.default.resolve(fileName)
+            .replace(/\\/g, "/");
+    }
+    has(fileName) {
+        return this.documents.has(this.normalize(fileName));
+    }
+    get(fileName) {
+        return this.documents.get(this.normalize(fileName));
+    }
+    getContent(fileName) {
+        return this.get(fileName)?.content;
+    }
+    getSnapshot(fileName) {
+        return this.get(fileName)?.snapshot;
+    }
+    getVersion(fileName) {
+        return (this.get(fileName)
+            ?.version
+            .toString()
+            ?? "0");
+    }
+    update(fileName, content) {
+        const normalized = this.normalize(fileName);
+        const existing = this.documents.get(normalized);
+        // critical:
+        // avoid snapshot churn
+        if (existing &&
+            existing.content === content) {
+            return;
+        }
+        this.documents.set(normalized, {
+            fileName: normalized,
+            content,
+            version: existing
+                ? existing.version + 1
+                : 1,
+            snapshot: typescript_1.default.ScriptSnapshot
+                .fromString(content),
+        });
+    }
+    ensure(fileName) {
+        const normalized = this.normalize(fileName);
+        if (this.documents.has(normalized)) {
+            return;
+        }
+        try {
+            const content = fs_1.default.readFileSync(normalized, "utf8");
+            this.update(normalized, content);
+        }
+        catch {
+            // ignore missing files
+        }
+    }
+    remove(fileName) {
+        this.documents.delete(this.normalize(fileName));
+    }
+    getFileNames() {
+        return [
+            ...this.documents.keys()
+        ];
+    }
+    invalidate() {
+        this.documents.clear();
+    }
+}
+exports.DocumentRegistry = DocumentRegistry;

package/dist/compiler/importGraph.js

@@ -0,0 +1,83 @@
+"use strict";
+// src/compiler/importGraph.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportGraph = void 0;
+class ImportGraph {
+    // file -> imports
+    imports = new Map();
+    // import -> importers
+    reverse = new Map();
+    updateFile(file, nextImports) {
+        const previous = this.imports.get(file)
+            ?? new Set();
+        const next = new Set(nextImports);
+        // remove old edges
+        for (const imported of previous) {
+            if (next.has(imported)) {
+                continue;
+            }
+            const reverseImporters = this.reverse.get(imported);
+            if (reverseImporters) {
+                reverseImporters.delete(file);
+                if (reverseImporters.size
+                    === 0) {
+                    this.reverse.delete(imported);
+                }
+            }
+        }
+        // add new edges
+        for (const imported of next) {
+            if (previous.has(imported)) {
+                continue;
+            }
+            let importers = this.reverse.get(imported);
+            if (!importers) {
+                importers =
+                    new Set();
+                this.reverse.set(imported, importers);
+            }
+            importers.add(file);
+        }
+        this.imports.set(file, next);
+    }
+    removeFile(file) {
+        const imports = this.imports.get(file);
+        if (imports) {
+            for (const imported of imports) {
+                const importers = this.reverse.get(imported);
+                if (importers) {
+                    importers.delete(file);
+                    if (importers.size
+                        === 0) {
+                        this.reverse.delete(imported);
+                    }
+                }
+            }
+        }
+        this.imports.delete(file);
+        this.reverse.delete(file);
+        for (const importers of this.reverse.values()) {
+            importers.delete(file);
+        }
+    }
+    collectDependents(file) {
+        const result = new Set();
+        const queue = [file];
+        while (queue.length) {
+            const current = queue.pop();
+            if (result.has(current)) {
+                continue;
+            }
+            result.add(current);
+            const importers = this.reverse.get(current);
+            if (!importers) {
+                continue;
+            }
+            for (const importer of importers) {
+                queue.push(importer);
+            }
+        }
+        return result;
+    }
+}
+exports.ImportGraph = ImportGraph;

package/dist/compiler/scheduler.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+class Scheduler {
+    flush;
+    pending = new Map();
+    scheduled = false;
+    currentFlush = null;
+    constructor(flush) {
+        this.flush = flush;
+    }
+    async enqueue(fileName, content) {
+        this.pending.set(fileName, content);
+        if (!this.scheduled) {
+            this.scheduled = true;
+            this.currentFlush =
+                Promise.resolve()
+                    .then(() => this.run());
+        }
+        await this.currentFlush;
+    }
+    async run() {
+        this.scheduled = false;
+        const batch = new Map(this.pending);
+        this.pending.clear();
+        await this.flush(batch);
+    }
+}
+exports.Scheduler = Scheduler;

package/dist/core/EventraEngine.js

@@ -0,0 +1,234 @@
+"use strict";
+// src/engine/engine.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventraEngine = void 0;
+const path_1 = __importDefault(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
+const compilerContext_1 = require("../compiler/compilerContext");
+const scheduler_1 = require("../compiler/scheduler");
+const importGraph_1 = require("../compiler/importGraph");
+const evaluationCache_1 = require("../analysis/cache/evaluationCache");
+const resolvedCallCache_1 = require("../analysis/cache/resolvedCallCache");
+const resolvedExportCache_1 = require("../analysis/cache/resolvedExportCache");
+const symbolInvalidation_1 = require("../analysis/cache/symbolInvalidation");
+const scanner_1 = require("../analysis/scanner/scanner");
+const extractor_1 = require("../analysis/extractor/extractor");
+const wrapperRegistry_1 = require("../analysis/symbols/wrapperRegistry");
+const EMPTY_RESULT = () => ({
+    events: new Set(),
+    detectedFunctionWrappers: new Set(),
+    detectedComponentWrappers: new Map(),
+});
+class EventraEngine {
+    compiler;
+    scheduler;
+    importGraph = new importGraph_1.ImportGraph();
+    evaluationCache = new evaluationCache_1.EvaluationCache();
+    resolvedCallCache = new resolvedCallCache_1.ResolvedCallCache();
+    resolvedExportCache = new resolvedExportCache_1.ResolvedExportCache();
+    wrapperRegistry;
+    fileResults = new Map();
+    normalizedPathCache = new Map();
+    isPreloading = false;
+    lastConfig = {
+        events: [],
+        wrappers: [],
+        functionWrappers: [],
+        sync: {
+            include: [],
+            exclude: [],
+        },
+    };
+    constructor(rootDir) {
+        this.compiler =
+            new compilerContext_1.CompilerContext(rootDir);
+        this.wrapperRegistry = new wrapperRegistry_1.WrapperRegistry();
+        this.scheduler =
+            new scheduler_1.Scheduler(async (updates) => {
+                //
+                // APPLY UPDATES
+                //
+                for (const [file, content] of updates) {
+                    //
+                    // SYMBOL INVALIDATION
+                    //
+                    const existing = this.compiler.getSourceFile(file);
+                    if (existing) {
+                        (0, symbolInvalidation_1.invalidateSourceFileSymbols)(existing, this.compiler.getChecker(), this.evaluationCache, this.resolvedCallCache, this.resolvedExportCache);
+                    }
+                    //
+                    // UPDATE FILE
+                    //
+                    await this.compiler.updateFile(file, content);
+                    //
+                    // UPDATE IMPORT GRAPH
+                    //
+                    this.updateImportGraph(file);
+                }
+                //
+                // COLLECT AFFECTED FILES
+                //
+                const affected = new Set();
+                for (const file of updates.keys()) {
+                    const dependents = this.importGraph
+                        .collectDependents(file);
+                    for (const dependent of dependents) {
+                        affected.add(dependent);
+                    }
+                }
+                //
+                // RE-ANALYZE
+                //
+                for (const file of affected) {
+                    this.analyzeFile(file, this.lastConfig);
+                }
+            });
+    }
+    invalidateCaches() {
+        this.evaluationCache
+            .clear();
+        this.resolvedCallCache
+            .clear();
+        this.resolvedExportCache
+            .clear();
+        this.wrapperRegistry
+            .clear();
+    }
+    beginPreload() {
+        this.isPreloading =
+            true;
+    }
+    endPreload() {
+        this.isPreloading =
+            false;
+    }
+    normalize(fileName) {
+        const cached = this.normalizedPathCache.get(fileName);
+        if (cached) {
+            return cached;
+        }
+        const normalized = path_1.default.resolve(fileName)
+            .replace(/\\/g, "/");
+        this.normalizedPathCache.set(fileName, normalized);
+        return normalized;
+    }
+    updateImportGraph(fileName) {
+        const normalized = this.normalize(fileName);
+        const source = this.compiler.getSourceFile(normalized);
+        if (!source) {
+            this.importGraph.removeFile(normalized);
+            return;
+        }
+        const imports = [];
+        for (const statement of source.statements) {
+            if (typescript_1.default.isExportAssignment(statement)) {
+                continue;
+            }
+            if (!typescript_1.default.isImportDeclaration(statement)
+                && !typescript_1.default.isExportDeclaration(statement)) {
+                continue;
+            }
+            const specifier = statement.moduleSpecifier;
+            if (!specifier
+                || !typescript_1.default.isStringLiteral(specifier)) {
+                continue;
+            }
+            const resolved = this.compiler.resolveModule(specifier.text, this.compiler.getRealFileName(source.fileName));
+            if (!resolved) {
+                continue;
+            }
+            imports.push(this.normalize(resolved));
+        }
+        this.importGraph.updateFile(normalized, imports);
+    }
+    analyzeFile(fileName, config) {
+        const normalized = this.normalize(fileName);
+        const source = this.compiler.getSourceFile(normalized);
+        if (!source) {
+            this.fileResults.delete(normalized);
+            return EMPTY_RESULT();
+        }
+        const checker = this.compiler.getChecker();
+        const index = (0, scanner_1.scanSource)(source, checker, config, this.resolvedCallCache, this.resolvedExportCache, this.wrapperRegistry);
+        const result = (0, extractor_1.extractEvents)(index, checker, config, this.evaluationCache, this.resolvedExportCache, this.resolvedCallCache, this.wrapperRegistry);
+        this.fileResults.set(normalized, result);
+        return result;
+    }
+    async preloadFile(fileName, content) {
+        if (!this.isPreloading) {
+            throw new Error("preload phase not active");
+        }
+        const normalized = this.normalize(fileName);
+        await this.compiler.updateFile(normalized, content);
+        this.updateImportGraph(normalized);
+    }
+    async updateFile(fileName, content, config) {
+        this.lastConfig =
+            config;
+        const normalized = this.normalize(fileName);
+        await this.scheduler.enqueue(normalized, content);
+    }
+    scanFile(fileName, config) {
+        this.lastConfig =
+            config;
+        return this.analyzeFile(fileName, config);
+    }
+    async syncFile(fileName, content, config) {
+        this.lastConfig =
+            config;
+        const normalized = this.normalize(fileName);
+        const existing = this.compiler.getSourceFile(normalized);
+        if (existing) {
+            (0, symbolInvalidation_1.invalidateSourceFileSymbols)(existing, this.compiler.getChecker(), this.evaluationCache, this.resolvedCallCache, this.resolvedExportCache);
+        }
+        await this.compiler.updateFile(normalized, content);
+        this.updateImportGraph(normalized);
+        return this.analyzeFile(normalized, config);
+    }
+    async removeFile(fileName, config) {
+        const normalized = this.normalize(fileName);
+        this.invalidateCaches();
+        const affected = this.importGraph
+            .collectDependents(normalized);
+        this.importGraph.removeFile(normalized);
+        this.compiler.removeFile(normalized);
+        this.fileResults.delete(normalized);
+        this.normalizedPathCache.delete(fileName);
+        this.normalizedPathCache.delete(normalized);
+        const nextConfig = config
+            ?? this.lastConfig;
+        for (const file of affected) {
+            if (file === normalized) {
+                continue;
+            }
+            this.analyzeFile(file, nextConfig);
+        }
+    }
+    getResult(fileName) {
+        return (this.fileResults.get(this.normalize(fileName))
+            ?? EMPTY_RESULT());
+    }
+    getAllEvents() {
+        const events = new Set();
+        for (const result of this.fileResults.values()) {
+            for (const event of result.events) {
+                events.add(event);
+            }
+        }
+        return [
+            ...events,
+        ].sort();
+    }
+    getDiagnostics(fileName) {
+        return this.compiler
+            .getSemanticDiagnostics(fileName);
+    }
+    invalidate() {
+        this.invalidateCaches();
+        this.fileResults.clear();
+    }
+}
+exports.EventraEngine = EventraEngine;

package/dist/core/projectScanner.js

@@ -0,0 +1,73 @@
+"use strict";
+// src/core/projectScanner.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanProject = scanProject;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const EventraEngine_1 = require("./EventraEngine");
+const processFile_1 = require("../filesystem/processFile");
+const getVirtualFile_1 = require("../filesystem/getVirtualFile");
+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 files = await (0, fast_glob_1.default)(config.sync.include, {
+        ignore: config.sync.exclude,
+        absolute: true,
+    });
+    const engine = new EventraEngine_1.EventraEngine(process.cwd());
+    const cache = new Map();
+    const toScan = new Set();
+    // COLLECT
+    for (const file of files) {
+        try {
+            const raw = await promises_1.default.readFile(file, "utf8");
+            if (raw.length
+                > 2_000_000) {
+                continue;
+            }
+            const parsed = await (0, processFile_1.processFile)(file, raw);
+            cache.set(file, parsed);
+            toScan.add(file);
+            for (const dep of parsed.dependencies) {
+                toScan.add(path_1.default.resolve(path_1.default.dirname(file), dep));
+            }
+        }
+        catch { }
+    }
+    // PRELOAD
+    engine.beginPreload();
+    for (const file of toScan) {
+        try {
+            const parsed = await getParsedFile(file, cache);
+            await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content);
+        }
+        catch { }
+    }
+    engine.endPreload();
+    // SCAN
+    const results = new Map();
+    for (const file of toScan) {
+        try {
+            const result = engine.scanFile((0, getVirtualFile_1.getVirtualFile)(file), config);
+            results.set(file, result);
+        }
+        catch { }
+    }
+    return {
+        engine,
+        results,
+        files,
+    };
+}