ts-axi 0.1.16 → 0.1.18

package/dist/src/project.js

@@ -547,9 +547,91 @@ export function createSemanticProject(index, scope) {
         }
         return undefined;
     };
-    const split = (absFile, pos) => {
+    /** Where findReferences stops on CommonJS: a `module.exports` property of the Symbol, and the locals of `const { x } = require()`. */
+    const commonJsHop = (fileName, start) => {
+        const sf = program.getSourceFile(fileName);
+        if (!sf)
+            return undefined;
+        const id = nodeAt(sf, start);
+        if (!ts.isIdentifier(id))
+            return undefined;
+        const parent = id.parent;
+        if ((ts.isShorthandPropertyAssignment(parent) && parent.name === id) || (ts.isPropertyAssignment(parent) && parent.initializer === id)) {
+            return isModuleExportsObject(parent.parent) ? parent.name.getStart(sf) : undefined;
+        }
+        const element = ts.isBindingElement(parent) ? parent : undefined;
+        if (!element || !ts.isIdentifier(element.name) || !ts.isObjectBindingPattern(element.parent))
+            return undefined;
+        const decl = element.parent.parent;
+        if (!ts.isVariableDeclaration(decl) || !decl.initializer || !isRequireCall(decl.initializer))
+            return undefined;
+        return element.name.getStart(sf);
+    };
+    /** findReferences of the Symbol at `pos`, with the CommonJS hops of `commonJsHop` merged into the target group. */
+    const referenceGroups = (absFile, pos) => {
         const twin = declarationTwin(absFile, pos);
         const groups = [...(service.findReferences(absFile, pos) ?? []), ...(twin ? service.findReferences(twin.file, twin.pos) ?? [] : [])];
+        const covers = (r) => resolve(r.fileName) === resolve(absFile) && r.textSpan.start <= pos && pos <= r.textSpan.start + r.textSpan.length;
+        const target = groups.find((g) => g.references.some(covers));
+        if (!target)
+            return { groups, extra: [] };
+        const seen = new Set(groups.flatMap((g) => g.references.map((r) => `${resolve(r.fileName)}#${r.textSpan.start}`)));
+        const extra = [];
+        const hops = new Set();
+        const queue = [...target.references];
+        for (let i = 0; i < queue.length && i < 500; i++) {
+            const hop = commonJsHop(queue[i].fileName, queue[i].textSpan.start);
+            const hopKey = `${resolve(queue[i].fileName)}#${hop}`;
+            if (hop === undefined || hops.has(hopKey))
+                continue;
+            hops.add(hopKey);
+            for (const g of service.findReferences(queue[i].fileName, hop) ?? []) {
+                for (const r of g.references) {
+                    const key = `${resolve(r.fileName)}#${r.textSpan.start}`;
+                    // A renamed local (`{ x: y }`) declares `y`; its uses are the References.
+                    if (seen.has(key) || (r.isDefinition && resolve(r.fileName) === resolve(queue[i].fileName) && r.textSpan.start === hop && hop !== queue[i].textSpan.start))
+                        continue;
+                    seen.add(key);
+                    const entry = { ...r, isDefinition: false };
+                    extra.push(entry);
+                    queue.push(entry);
+                }
+            }
+        }
+        return { groups: extra.length === 0 ? groups : groups.map((g) => (g === target ? { ...g, references: [...g.references, ...extra] } : g)), extra };
+    };
+    /** Call sites among CommonJS-hop References; call hierarchy does not reach a destructured `require()` local. */
+    const commonJsCalls = (refs) => {
+        const sites = [];
+        for (const ref of refs) {
+            const sf = program.getSourceFile(ref.fileName);
+            const loc = location(ref.fileName, ref.textSpan.start);
+            if (!sf || !loc)
+                continue;
+            const id = nodeAt(sf, ref.textSpan.start);
+            const call = id.parent;
+            if (!(ts.isCallExpression(call) || ts.isNewExpression(call)) || call.expression !== id)
+                continue;
+            const item = enclosingItem(sf, call);
+            sites.push({ ...loc, caller: callerName(item), item });
+        }
+        return sites;
+    };
+    /** Call hierarchy item of the nearest named function around `node`, else the file itself. */
+    const enclosingItem = (sf, node) => {
+        for (let n = node.parent; n && !ts.isSourceFile(n); n = n.parent) {
+            if (!ts.isFunctionLike(n))
+                continue;
+            const prepared = service.prepareCallHierarchy(sf.fileName, n.getStart(sf));
+            const item = Array.isArray(prepared) ? prepared[0] : prepared;
+            if (item && item.kind !== ts.ScriptElementKind.scriptElement)
+                return item;
+        }
+        const span = { start: 0, length: sf.end };
+        return { name: sf.fileName, kind: ts.ScriptElementKind.scriptElement, file: sf.fileName, span, selectionSpan: span };
+    };
+    const split = (absFile, pos) => {
+        const { groups } = referenceGroups(absFile, pos);
         const descriptors = [];
         let target = -1;
         let flagged = -1;
@@ -661,6 +743,7 @@ export function createSemanticProject(index, scope) {
             const seen = new Set();
             return items
                 .flatMap((item) => splitSites(item.file, item.selectionSpan.start, [...service.provideCallHierarchyIncomingCalls(item.file, item.selectionSpan.start), ...twinCalls]))
+                .concat(commonJsCalls(referenceGroups(absFile, pos).extra))
                 .filter((site) => {
                 const key = `${site.file}:${site.line}:${site.col}`;
                 return !seen.has(key) && Boolean(seen.add(key));
@@ -726,3 +809,20 @@ export function openProject(cwd, options = {}) {
     const index = createSyntacticIndex(root, project);
     return { cwd, root, location, index, ...(project.implicit ? { warning: IMPLICIT_WARNING } : {}) };
 }
+/** The object of `module.exports = {...}`. */
+function isModuleExportsObject(node) {
+    if (!ts.isObjectLiteralExpression(node))
+        return false;
+    let assign = node.parent;
+    while (ts.isParenthesizedExpression(assign))
+        assign = assign.parent;
+    if (!ts.isBinaryExpression(assign) || assign.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+        return false;
+    const left = assign.left;
+    return ts.isPropertyAccessExpression(left) && ts.isIdentifier(left.expression) && left.expression.text === "module" && left.name.text === "exports";
+}
+function isRequireCall(expr) {
+    while (ts.isParenthesizedExpression(expr))
+        expr = expr.expression;
+    return ts.isCallExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === "require" && expr.arguments.length === 1;
+}

package/dist/src/symbols.js

@@ -390,6 +390,25 @@ export function collectDeclarations(sf, file) {
                 !(ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node)),
         });
     };
+    const classMembers = (cls, exported, qualified) => {
+        for (const member of cls.members) {
+            if (ts.isSemicolonClassElement(member) || ts.isClassStaticBlockDeclaration(member) || ts.isIndexSignatureDeclaration(member))
+                continue;
+            const memberName = ts.isConstructorDeclaration(member) ? "constructor" : nameText(member.name, sf);
+            if (!memberName)
+                continue;
+            const nameNode = ts.isConstructorDeclaration(member)
+                ? member.getChildren(sf).find((c) => c.kind === ts.SyntaxKind.ConstructorKeyword)
+                : member.name;
+            add(member, nameNode, memberName, exported && !isPrivateMember(member), qualified);
+        }
+    };
+    /** `module.exports = class X {...}`, `exports.X = class {...}`, `export default class {...}` expression. */
+    const exportedClass = (cls, fallback) => {
+        const name = cls.name?.text ?? fallback;
+        add(cls, cls.name, name, true);
+        classMembers(cls, true, name);
+    };
     const nested = (raw) => {
         raws.push({ ...raw, qualifiedName: raw.qualifiedName ?? (raw.parentName ? `${raw.parentName}.${raw.name}` : raw.name), hasBody: true });
     };
@@ -422,6 +441,10 @@ export function collectDeclarations(sf, file) {
                     nested({ start: prop.getStart(sf), end: prop.end, kind: "method", name, parentName: holder, exported, signature: headUntil(prop, fn, sf), namePos: prop.name.getStart(sf) });
                 else if (scope && ts.isIdentifier(value))
                     aliasedMember(scope, value, name, holder, exported, prop.name);
+                else if (holder === "exports" && !ts.isIdentifier(value)) {
+                    // `module.exports = { x: make(...) }`: the property is the only Declaration a destructured require can reach.
+                    nested({ start: prop.getStart(sf), end: prop.end, kind: "property", name, parentName: holder, exported, signature: clip(tokenText(prop, sf, prop.getStart(sf), prop.end)), namePos: prop.name.getStart(sf) });
+                }
             }
             else if (scope && ts.isShorthandPropertyAssignment(prop)) {
                 aliasedMember(scope, prop.name, name, holder, exported, prop.name);
@@ -737,7 +760,9 @@ export function collectDeclarations(sf, file) {
             return;
         const target = compact(left, sf);
         if (target === "module.exports") {
-            if (ts.isObjectLiteralExpression(right))
+            if (ts.isClassExpression(right))
+                exportedClass(right, "exports");
+            else if (ts.isObjectLiteralExpression(right))
                 objectMembers(right, "exports", true);
             else if (asFunction(right))
                 returnedMembers(asFunction(right).body, "exports", true);
@@ -746,6 +771,8 @@ export function collectDeclarations(sf, file) {
             return;
         }
         if (target === `exports.${left.name.text}` || target === `module.exports.${left.name.text}`) {
+            if (ts.isClassExpression(right))
+                return exportedClass(right, left.name.text);
             if (ts.isObjectLiteralExpression(right))
                 objectMembers(right, left.name.text, true);
             else
@@ -829,7 +856,9 @@ export function collectDeclarations(sf, file) {
         }
         else if (ts.isExportAssignment(statement)) {
             const value = unwrap(statement.expression);
-            if (ts.isObjectLiteralExpression(value))
+            if (ts.isClassExpression(value))
+                exportedClass(value, "default");
+            else if (ts.isObjectLiteralExpression(value))
                 objectMembers(value, "default", true);
             else
                 stateArray(statement.expression);
@@ -876,17 +905,7 @@ export function collectDeclarations(sf, file) {
                 add(statement, statement.name, name, exported, parent);
                 const qualified = parent ? `${parent}.${name}` : name;
                 if (ts.isClassDeclaration(statement)) {
-                    for (const member of statement.members) {
-                        if (ts.isSemicolonClassElement(member) || ts.isClassStaticBlockDeclaration(member) || ts.isIndexSignatureDeclaration(member))
-                            continue;
-                        const memberName = ts.isConstructorDeclaration(member) ? "constructor" : nameText(member.name, sf);
-                        if (!memberName)
-                            continue;
-                        const nameNode = ts.isConstructorDeclaration(member)
-                            ? member.getChildren(sf).find((c) => c.kind === ts.SyntaxKind.ConstructorKeyword)
-                            : member.name;
-                        add(member, nameNode, memberName, exported && !isPrivateMember(member), qualified);
-                    }
+                    classMembers(statement, exported, qualified);
                 }
                 else if (ts.isInterfaceDeclaration(statement)) {
                     for (const member of statement.members) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-axi",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "AXI-compliant TypeScript symbol CLI for agents - definitions, references, callers, file outlines and change impact (blast radius) with token-efficient TOON output",
   "type": "module",
   "keywords": [