@eventra_dev/eventra-cli 0.1.24 → 0.1.26

package/dist/engine/exportResolver.js

@@ -5,21 +5,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveExportedSymbol = resolveExportedSymbol;
 const typescript_1 = __importDefault(require("typescript"));
+function isRealDeclaration(node) {
+    return (typescript_1.default.isFunctionDeclaration(node) ||
+        typescript_1.default.isVariableDeclaration(node) ||
+        typescript_1.default.isClassDeclaration(node));
+}
 function resolveExportedSymbol(symbol, checker, visited = new Set()) {
     if (visited.has(symbol))
         return null;
     visited.add(symbol);
+    // unwrap alias
     if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
         const aliased = checker.getAliasedSymbol(symbol);
         return resolveExportedSymbol(aliased, checker, visited);
     }
-    if (symbol.getDeclarations()?.length) {
+    // export symbol
+    const exportSymbol = checker.getExportSymbolOfSymbol(symbol);
+    if (exportSymbol && exportSymbol !== symbol) {
+        return resolveExportedSymbol(exportSymbol, checker, visited);
+    }
+    const decls = symbol.getDeclarations() ?? [];
+    if (decls.some(isRealDeclaration)) {
         return symbol;
     }
-    const declarations = symbol.getDeclarations() ?? [];
-    for (const decl of declarations) {
+    // exports (re-export)
+    for (const decl of decls) {
         const source = decl.getSourceFile();
-        const moduleSymbol = checker.getSymbolAtLocation(source);
+        const moduleSymbol = source.symbol;
         if (!moduleSymbol)
             continue;
         const exports = checker.getExportsOfModule(moduleSymbol);

package/dist/engine/functionAnalyzer.js

@@ -10,19 +10,81 @@ function findTrackParamIndex(fn) {
     fn.parameters.forEach((p, i) => {
         if (typescript_1.default.isIdentifier(p.name)) {
             paramIndex.set(p.name.text, i);
+            // default param: (name = "x")
+            if (p.initializer && typescript_1.default.isStringLiteral(p.initializer)) {
+                if (i === 0)
+                    return 0;
+            }
         }
     });
     let result = null;
+    function unwrap(node) {
+        // as / parentheses
+        while (typescript_1.default.isAsExpression(node) ||
+            typescript_1.default.isParenthesizedExpression(node)) {
+            node = node.expression;
+        }
+        return node;
+    }
+    function checkArg(arg) {
+        arg = unwrap(arg);
+        // identifier → param
+        if (typescript_1.default.isIdentifier(arg)) {
+            const idx = paramIndex.get(arg.text);
+            if (idx !== undefined) {
+                result = idx;
+                return true;
+            }
+        }
+        // string literal
+        if (typescript_1.default.isStringLiteral(arg)) {
+            result = 0;
+            return true;
+        }
+        // template `${name}`
+        if (typescript_1.default.isTemplateExpression(arg)) {
+            for (const span of arg.templateSpans) {
+                if (typescript_1.default.isIdentifier(span.expression)) {
+                    const idx = paramIndex.get(span.expression.text);
+                    if (idx !== undefined) {
+                        result = idx;
+                        return true;
+                    }
+                }
+            }
+            result = 0;
+            return true;
+        }
+        // object { event: name }
+        if (typescript_1.default.isObjectLiteralExpression(arg)) {
+            for (const prop of arg.properties) {
+                if (!typescript_1.default.isPropertyAssignment(prop))
+                    continue;
+                const name = prop.name.getText();
+                if (["event", "name", "type"].includes(name)) {
+                    return checkArg(prop.initializer);
+                }
+            }
+        }
+        // call: String(name)
+        if (typescript_1.default.isCallExpression(arg)) {
+            for (const inner of arg.arguments) {
+                if (checkArg(inner))
+                    return true;
+            }
+        }
+        return false;
+    }
     function visit(node) {
+        if (result !== null)
+            return;
         if (typescript_1.default.isCallExpression(node)) {
             let isTrackCall = false;
             if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
-                const method = node.expression.name.text;
-                if (method === "track") {
+                if (node.expression.name.text === "track") {
                     isTrackCall = true;
                 }
             }
-            // fallback
             if (typescript_1.default.isIdentifier(node.expression)) {
                 if (node.expression.text === "track") {
                     isTrackCall = true;
@@ -30,17 +92,8 @@ function findTrackParamIndex(fn) {
             }
             if (isTrackCall) {
                 for (const arg of node.arguments) {
-                    if (typescript_1.default.isIdentifier(arg)) {
-                        const idx = paramIndex.get(arg.text);
-                        if (idx !== undefined) {
-                            result = idx;
-                            return;
-                        }
-                    }
-                    if (typescript_1.default.isStringLiteral(arg)) {
-                        result = 0;
+                    if (checkArg(arg))
                         return;
-                    }
                 }
             }
         }

package/dist/engine/graph.js

@@ -18,13 +18,16 @@ class DependencyGraph {
         this.paths = paths;
     }
     normalize(file) {
-        return path_1.default.resolve(file);
+        return path_1.default.resolve(file).replace(/\\/g, "/");
     }
+    // MODULE RESOLVE
     resolveModule(module, from) {
+        // relative import
         if (module.startsWith(".")) {
             const abs = path_1.default.resolve(path_1.default.dirname(from), module);
             return this.resolveFile(abs);
         }
+        // tsconfig paths
         for (const key in this.paths) {
             const pattern = key.replace(/\*/g, "(.*)");
             const regex = new RegExp("^" + pattern + "$");
@@ -43,9 +46,19 @@ class DependencyGraph {
                     return resolved;
             }
         }
+        // node resolution (safe)
+        try {
+            const resolved = require.resolve(module, {
+                paths: [path_1.default.dirname(from)],
+            });
+            return this.normalize(resolved);
+        }
+        catch { }
+        // fallback
         const abs = path_1.default.resolve(this.baseUrl, module);
         return this.resolveFile(abs);
     }
+    // FILE RESOLVE
     resolveFile(base) {
         if (this.fileCache.has(base)) {
             return this.fileCache.get(base);
@@ -56,6 +69,12 @@ class DependencyGraph {
             base + ".tsx",
             base + ".js",
             base + ".jsx",
+            base + ".mjs",
+            base + ".cjs",
+            base + ".d.ts",
+            base + ".vue",
+            base + ".svelte",
+            base + ".astro",
             path_1.default.join(base, "index.ts"),
             path_1.default.join(base, "index.tsx"),
             path_1.default.join(base, "index.js"),
@@ -70,12 +89,22 @@ class DependencyGraph {
         this.fileCache.set(base, null);
         return null;
     }
+    // UPDATE GRAPH
     update(file, source) {
         const normalizedFile = this.normalize(file);
+        for (const deps of this.reverse.values()) {
+            deps.delete(normalizedFile);
+        }
         this.exports.set(normalizedFile, new Set());
         for (const stmt of source.statements) {
+            // IMPORT
             if (typescript_1.default.isImportDeclaration(stmt)) {
-                const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+                // ignore import type
+                if (stmt.importClause?.importKind === "type")
+                    continue;
+                const module = stmt.moduleSpecifier
+                    .getText()
+                    .replace(/['"]/g, "");
                 const resolved = this.resolveModule(module, normalizedFile);
                 if (!resolved)
                     continue;
@@ -84,8 +113,13 @@ class DependencyGraph {
                 }
                 this.reverse.get(resolved).add(normalizedFile);
             }
-            if (typescript_1.default.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
-                const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+            // EXPORT (re-export)
+            if (typescript_1.default.isExportDeclaration(stmt)) {
+                if (!stmt.moduleSpecifier)
+                    continue;
+                const module = stmt.moduleSpecifier
+                    .getText()
+                    .replace(/['"]/g, "");
                 const resolved = this.resolveModule(module, normalizedFile);
                 if (!resolved)
                     continue;
@@ -97,6 +131,7 @@ class DependencyGraph {
             }
         }
     }
+    // DEPENDENTS
     getAllDependentsDeep(file) {
         const start = this.normalize(file);
         const visited = new Set();
@@ -116,6 +151,7 @@ class DependencyGraph {
         walk(start);
         return [...result];
     }
+    // REMOVE
     remove(file) {
         const normalized = this.normalize(file);
         this.reverse.delete(normalized);

package/dist/engine/languageService.js

@@ -12,20 +12,27 @@ class TSService {
     files = new Map();
     fileNames = new Set();
     service;
-    compilerOptions = {};
-    baseUrl = "";
-    paths = {};
+    compilerOptions;
+    baseUrl;
+    paths;
+    usage = new Map();
+    tick = 0;
+    MAX_FILES = 2000;
     constructor(root) {
         this.root = root;
         const configPath = typescript_1.default.findConfigFile(root, typescript_1.default.sys.fileExists, "tsconfig.json");
         let compilerOptions = {
             allowJs: true,
-            jsx: typescript_1.default.JsxEmit.Preserve,
+            jsx: typescript_1.default.JsxEmit.React,
+            jsxImportSource: "react",
             moduleResolution: typescript_1.default.ModuleResolutionKind.Node16,
             target: typescript_1.default.ScriptTarget.ESNext,
             esModuleInterop: true,
             allowSyntheticDefaultImports: true,
+            skipLibCheck: true,
         };
+        let baseUrl = root;
+        let paths = {};
         if (configPath) {
             const configFile = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
             const parsed = typescript_1.default.parseJsonConfigFileContent(configFile.config, typescript_1.default.sys, root);
@@ -33,46 +40,104 @@ class TSService {
                 ...compilerOptions,
                 ...parsed.options,
             };
-            this.paths = parsed.options.paths || {};
-            this.baseUrl = parsed.options.baseUrl
+            paths = parsed.options.paths || {};
+            baseUrl = parsed.options.baseUrl
                 ? path_1.default.resolve(root, parsed.options.baseUrl)
                 : root;
         }
-        else {
-            this.baseUrl = root;
-        }
         this.compilerOptions = compilerOptions;
+        this.baseUrl = baseUrl;
+        this.paths = paths;
         const host = {
-            getScriptFileNames: () => {
-                return [...new Set(this.fileNames)].sort((a, b) => a.localeCompare(b));
+            getScriptFileNames: () => Array.from(this.fileNames),
+            getScriptVersion: (file) => {
+                file = this.normalize(file);
+                return this.files.get(file)?.version.toString() ?? "0";
             },
-            getScriptVersion: (file) => this.files.get(file)?.version.toString() ?? "0",
             getScriptSnapshot: (file) => {
+                file = this.normalize(file);
                 const f = this.files.get(file);
                 if (f) {
+                    this.touch(file);
                     return typescript_1.default.ScriptSnapshot.fromString(f.content);
                 }
-                if (fs_1.default.existsSync(file)) {
-                    return typescript_1.default.ScriptSnapshot.fromString(fs_1.default.readFileSync(file, "utf-8"));
+                try {
+                    if (fs_1.default.existsSync(file)) {
+                        const content = fs_1.default.readFileSync(file, "utf-8");
+                        this.files.set(file, {
+                            content,
+                            version: 1,
+                        });
+                        this.fileNames.add(file);
+                        this.touch(file);
+                        this.evictIfNeeded();
+                        return typescript_1.default.ScriptSnapshot.fromString(content);
+                    }
                 }
-                return undefined;
+                catch { }
+                // fallback
+                return typescript_1.default.ScriptSnapshot.fromString("");
             },
             getCurrentDirectory: () => this.root,
             getCompilationSettings: () => this.compilerOptions,
             getDefaultLibFileName: (opts) => typescript_1.default.getDefaultLibFilePath(opts),
-            readFile: typescript_1.default.sys.readFile,
             fileExists: typescript_1.default.sys.fileExists,
+            readFile: typescript_1.default.sys.readFile,
             readDirectory: typescript_1.default.sys.readDirectory,
         };
         this.service = typescript_1.default.createLanguageService(host);
     }
+    // INTERNAL
+    normalize(file) {
+        return path_1.default.resolve(file).replace(/\\/g, "/");
+    }
+    touch(file) {
+        this.tick++;
+        this.usage.set(file, this.tick);
+    }
+    evictIfNeeded() {
+        if (this.fileNames.size <= this.MAX_FILES)
+            return;
+        let oldestFile = null;
+        let oldestTick = Infinity;
+        for (const f of this.fileNames) {
+            const t = this.usage.get(f) ?? 0;
+            if (t < oldestTick) {
+                oldestTick = t;
+                oldestFile = f;
+            }
+        }
+        if (oldestFile) {
+            this.files.delete(oldestFile);
+            this.fileNames.delete(oldestFile);
+            this.usage.delete(oldestFile);
+        }
+    }
+    ensureProgram() {
+        try {
+            this.service.getProgram();
+        }
+        catch { }
+    }
+    // PUBLIC API
     updateFile(file, content) {
+        file = this.normalize(file);
         const prev = this.files.get(file);
         this.files.set(file, {
             content,
             version: prev ? prev.version + 1 : 1,
         });
         this.fileNames.add(file);
+        this.touch(file);
+        this.evictIfNeeded();
+        this.ensureProgram();
+    }
+    removeFile(file) {
+        file = this.normalize(file);
+        this.files.delete(file);
+        this.fileNames.delete(file);
+        this.usage.delete(file);
+        this.ensureProgram();
     }
     getProgram() {
         return this.service.getProgram();
@@ -81,15 +146,13 @@ class TSService {
         return this.getProgram()?.getTypeChecker();
     }
     getSourceFile(file) {
+        file = this.normalize(file);
         return this.getProgram()?.getSourceFile(file);
     }
     getFileContent(file) {
+        file = this.normalize(file);
         return this.files.get(file)?.content;
     }
-    removeFile(file) {
-        this.files.delete(file);
-        this.fileNames.delete(file);
-    }
     getModuleResolutionConfig() {
         return {
             baseUrl: this.baseUrl,

package/dist/engine/resolver.js

@@ -11,7 +11,7 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         return { values: [], dynamic: true };
     }
     seen.add(node);
-    // param mapping
+    // PARAM MAPPING
     if (typescript_1.default.isIdentifier(node) && paramMap?.has(node.text)) {
         return resolveNodeValue(paramMap.get(node.text), checker, paramMap, seen);
     }
@@ -28,11 +28,14 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 values.push(...res.values);
             }
         }
-        return { values, dynamic: true };
+        return {
+            values: [...new Set(values)],
+            dynamic: true
+        };
     }
     // TEMPLATE
     if (typescript_1.default.isTemplateExpression(node)) {
-        let results = [node.head.text];
+        let results = node.head.text ? [node.head.text] : [""];
         for (const span of node.templateSpans) {
             const res = resolveNodeValue(span.expression, checker, paramMap, seen);
             if (res.values.length) {
@@ -59,16 +62,18 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         let symbol = checker.getSymbolAtLocation(node);
         if (!symbol)
             return { values: [], dynamic: true };
+        // INLINE FIRST
+        for (const decl of symbol.getDeclarations() ?? []) {
+            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
+            }
+        }
         // unwrap export
         symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
         if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
             symbol = checker.getAliasedSymbol(symbol);
         }
-        // inline variable
         for (const decl of symbol.getDeclarations() ?? []) {
-            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
-                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
-            }
             if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
                 if (typescript_1.default.isStringLiteral(decl.initializer)) {
                     return {
@@ -78,12 +83,12 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
-        // UNION TYPES
         const type = checker.getTypeAtLocation(node);
+        // UNION
         if (type.isUnion()) {
             const values = [];
             for (const t of type.types) {
-                if (t.isStringLiteral?.()) {
+                if (t.flags & typescript_1.default.TypeFlags.StringLiteral) {
                     values.push(t.value);
                 }
             }
@@ -91,13 +96,16 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 return { values, dynamic: false };
             }
         }
-        // TYPE FALLBACK (as const)
-        if (type.isStringLiteral?.()) {
-            return { values: [type.value], dynamic: false };
+        // STRING LITERAL TYPE
+        if (type.flags & typescript_1.default.TypeFlags.StringLiteral) {
+            return {
+                values: [type.value],
+                dynamic: false
+            };
         }
         return { values: [], dynamic: true };
     }
-    // PROPERTY ACCESS (obj.a.b)
+    // PROPERTY ACCESS
     if (typescript_1.default.isPropertyAccessExpression(node)) {
         const symbol = checker.getSymbolAtLocation(node);
         if (symbol) {
@@ -116,14 +124,12 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
-        // constant enum / readonly
         const constantValue = checker.getConstantValue(node);
         if (typeof constantValue === "string") {
             return { values: [constantValue], dynamic: false };
         }
-        // type fallback
         const type = checker.getTypeAtLocation(node);
-        if (type.isStringLiteral?.()) {
+        if (type.flags & typescript_1.default.TypeFlags.StringLiteral) {
             return {
                 values: [type.value],
                 dynamic: false,
@@ -149,16 +155,16 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
-        return { values: [], dynamic: true };
+        // fallback
+        return resolveNodeValue(node.name, checker, paramMap, seen);
     }
-    // ARRAY ACCESS (arr[0])
+    // ARRAY ACCESS
     if (typescript_1.default.isElementAccessExpression(node)) {
         const obj = resolveNodeValue(node.expression, checker, paramMap, seen);
         if (!node.argumentExpression) {
             return { values: obj.values, dynamic: true };
         }
         const index = resolveNodeValue(node.argumentExpression, checker, paramMap, seen);
-        // if index known
         if (index.values.length === 1) {
             const i = Number(index.values[0]);
             if (!Number.isNaN(i) && obj.values[i] !== undefined) {
@@ -168,7 +174,6 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 };
             }
         }
-        // fallback → dynamic
         return obj.values.length
             ? { values: obj.values, dynamic: true }
             : { values: [], dynamic: true };
@@ -185,7 +190,10 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 values.push(...res.values);
             }
         }
-        return { values, dynamic: true };
+        return {
+            values: [...new Set(values)],
+            dynamic: true
+        };
     }
     // BINARY ("btn_" + name)
     if (typescript_1.default.isBinaryExpression(node)) {