ts-axi 0.1.11 → 0.1.13

package/dist/src/symbols.js

@@ -278,6 +278,38 @@ function registeredFunction(arg) {
         return asFunction(arg.elements[arg.elements.length - 1]);
     return asFunction(arg);
 }
+/**
+ * A registration's callback given by identifier (`.directive('x', fancyBox)`, `['$a', fancyBox]`): the
+ * function declaration or function-valued variable of that name among the statements of the call's scope.
+ */
+function functionByIdentifier(call, arg) {
+    const ref = arg && ts.isArrayLiteralExpression(arg) ? arg.elements[arg.elements.length - 1] : arg;
+    if (!ref || !ts.isIdentifier(ref))
+        return undefined;
+    let scope = call;
+    while (!ts.isSourceFile(scope) && !(ts.isBlock(scope) && ts.isFunctionLike(scope.parent)))
+        scope = scope.parent;
+    const statements = scope.statements;
+    let found;
+    let inject;
+    for (const st of statements) {
+        if (ts.isFunctionDeclaration(st) && st.name?.text === ref.text && st.body)
+            found = { fn: st, name: st.name };
+        else if (ts.isVariableStatement(st)) {
+            for (const d of st.declarationList.declarations) {
+                const fn = asFunction(d.initializer);
+                if (fn && ts.isIdentifier(d.name) && d.name.text === ref.text)
+                    found = { fn, name: d.name };
+            }
+        }
+        else if (ts.isExpressionStatement(st) && ts.isBinaryExpression(st.expression) && ts.isPropertyAccessExpression(st.expression.left)) {
+            const { left, right } = st.expression;
+            if (left.name.text === "$inject" && ts.isIdentifier(left.expression) && left.expression.text === ref.text && ts.isArrayLiteralExpression(right))
+                inject = right;
+        }
+    }
+    return found && (inject ? { ...found, inject } : found);
+}
 function isStringName(node) {
     return node !== undefined && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node));
 }
@@ -303,6 +335,8 @@ function headUntil(node, fn, sf) {
 export function collectDeclarations(sf, file) {
     const raws = [];
     const local = localExportNames(sf);
+    /** Body spans of functions registered by identifier. */
+    const registeredBodies = [];
     const add = (node, nameNode, name, exported, parent) => {
         const kind = kindOf(node);
         if (!kind)
@@ -353,23 +387,22 @@ export function collectDeclarations(sf, file) {
             if (!ts.isExpressionStatement(statement) || !ts.isBinaryExpression(statement.expression))
                 continue;
             const { left, operatorToken, right } = statement.expression;
+            if (operatorToken.kind !== ts.SyntaxKind.EqualsToken || !ts.isPropertyAccessExpression(left) || left.expression.kind !== ts.SyntaxKind.ThisKeyword)
+                continue;
+            const value = unwrap(right);
+            if (ts.isObjectLiteralExpression(value))
+                objectMembers(value, `${owner}.${left.name.text}`, exported);
             const fn = asFunction(right);
-            if (operatorToken.kind !== ts.SyntaxKind.EqualsToken || !fn || !ts.isPropertyAccessExpression(left) || left.expression.kind !== ts.SyntaxKind.ThisKeyword)
+            if (!fn)
                 continue;
             nested({ start: statement.getStart(sf), end: statement.end, kind: "method", name: left.name.text, parentName: owner, exported, signature: headUntil(statement.expression, fn, sf), namePos: left.name.getStart(sf) });
         }
     };
-    /** Top-level object literals returned by a factory: its API. */
-    const returnedMembers = (body, owner) => {
-        if (ts.isObjectLiteralExpression(unwrap(body)))
-            return objectMembers(unwrap(body), owner, true);
-        if (!ts.isBlock(body))
-            return;
-        for (const statement of body.statements) {
-            if (ts.isReturnStatement(statement) && statement.expression && ts.isObjectLiteralExpression(unwrap(statement.expression))) {
-                objectMembers(unwrap(statement.expression), owner, true);
-            }
-        }
+    /** Object literals a function returns at its top level (a factory's API, a deps object): their function-valued members. */
+    const returnedMembers = (body, owner, exported) => {
+        if (body)
+            for (const obj of returnedObjects(body))
+                objectMembers(obj, owner, exported);
     };
     const topLevelExported = (name) => raws.find((r) => r.qualifiedName === name && r.parentName === undefined)?.exported ?? false;
     const isConstructorName = (name) => /^[A-Z]/.test(name);
@@ -389,10 +422,14 @@ export function collectDeclarations(sf, file) {
             bindingMembers(arg, name);
             return;
         }
-        const fn = registeredFunction(arg);
-        if (!fn)
+        const inline = registeredFunction(arg);
+        // By identifier: namePos is the function's own name, which links the two Declarations (`registrationOf`).
+        const byName = inline ? undefined : functionByIdentifier(call, arg);
+        const fn = inline ?? byName?.fn;
+        if (!fn || !fn.body)
             return;
-        const inject = arg && ts.isArrayLiteralExpression(arg) ? ` [${arg.elements.slice(0, -1).map((e) => e.getText(sf)).join(", ")}]` : "";
+        const injectList = arg && ts.isArrayLiteralExpression(arg) ? arg.elements.slice(0, -1) : (byName?.inject?.elements ?? []);
+        const inject = injectList.length > 0 || (arg && ts.isArrayLiteralExpression(arg)) ? ` [${injectList.map((e) => e.getText(sf)).join(", ")}]` : "";
         nested({
             start,
             end: arg.end,
@@ -402,21 +439,27 @@ export function collectDeclarations(sf, file) {
             parentName: verb,
             exported: true,
             signature: `${verb} ${name}${paramsText(fn, sf)}`,
-            namePos: (ts.isFunctionExpression(fn) && fn.name ? fn.name : fn).getStart(sf),
+            namePos: (byName ? byName.name : ts.isFunctionExpression(fn) && fn.name ? fn.name : fn).getStart(sf),
             nameless: true,
         });
         // The DI array is compared, not displayed: reordering injections is a contract change.
         if (inject)
             raws[raws.length - 1].signature += `\n${inject.trim()}`;
+        const from = raws.length;
         if (CONSTRUCTOR_VERBS.has(verb))
             thisMembers(fn.body, name, true);
         if (verb === "factory" || verb === "service")
-            returnedMembers(fn.body, name);
+            returnedMembers(fn.body, name, true);
         if (verb === "directive")
             for (const obj of returnedObjects(fn.body))
                 bindingMembers(obj, name);
         if (verb === "config" || verb === "run")
             routerBody(fn.body);
+        if (byName) {
+            for (const r of raws.slice(from))
+                r.registered = true;
+            registeredBodies.push([fn.body.getStart(sf), fn.body.end]);
+        }
     };
     /** Object literals a function returns at its top level (a directive definition object). */
     const returnedObjects = (body) => {
@@ -628,18 +671,26 @@ export function collectDeclarations(sf, file) {
         if (target === "module.exports") {
             if (ts.isObjectLiteralExpression(right))
                 objectMembers(right, "exports", true);
+            else if (asFunction(right))
+                returnedMembers(asFunction(right).body, "exports", true);
             else
                 stateArray(right);
             return;
         }
-        if (target === `exports.${left.name.text}` || target === `module.exports.${left.name.text}`)
-            stateArray(right);
+        if (target === `exports.${left.name.text}` || target === `module.exports.${left.name.text}`) {
+            if (ts.isObjectLiteralExpression(right))
+                objectMembers(right, left.name.text, true);
+            else
+                stateArray(right);
+        }
         const owner = left.expression;
         if (ts.isPropertyAccessExpression(owner) && owner.name.text === "prototype" && ts.isIdentifier(owner.expression)) {
             const cls = owner.expression.text;
             const fn = asFunction(right);
-            if (fn)
+            if (fn) {
                 nested({ start: statement.getStart(sf), end: statement.end, kind: "method", name: left.name.text, parentName: cls, exported: topLevelExported(cls), signature: headUntil(expr, fn, sf), namePos: left.name.getStart(sf) });
+                returnedMembers(fn.body, left.name.text, topLevelExported(cls));
+            }
             return;
         }
         if (ts.isIdentifier(left.name) && left.name.text === "prototype" && ts.isIdentifier(owner) && ts.isObjectLiteralExpression(right)) {
@@ -654,6 +705,7 @@ export function collectDeclarations(sf, file) {
             return;
         const exported = holder === "exports" || topLevelExported(holder);
         nested({ start: statement.getStart(sf), end: statement.end, kind: "method", name: left.name.text, parentName: holder, exported, signature: headUntil(expr, fn, sf), namePos: left.name.getStart(sf) });
+        returnedMembers(fn.body, left.name.text, exported);
     };
     /** Script-style patterns of one module-level statement; `inIife` adds the IIFE's own functions. */
     const scriptStatement = (statement, inIife) => {
@@ -662,8 +714,10 @@ export function collectDeclarations(sf, file) {
                 return;
             if (inIife)
                 add(statement, statement.name, statement.name.text, false);
+            const exported = inIife ? false : topLevelExported(statement.name.text);
             if (isConstructorName(statement.name.text))
-                thisMembers(statement.body, statement.name.text, inIife ? false : topLevelExported(statement.name.text));
+                thisMembers(statement.body, statement.name.text, exported);
+            returnedMembers(statement.body, statement.name.text, exported);
             if (takesRouter(statement))
                 routerBody(statement.body);
         }
@@ -680,6 +734,8 @@ export function collectDeclarations(sf, file) {
                 const exported = inIife ? false : topLevelExported(name);
                 const init = unwrap(decl.initializer);
                 stateArray(init);
+                if (fn)
+                    returnedMembers(fn.body, name, exported);
                 if (ts.isObjectLiteralExpression(init))
                     objectMembers(init, name, exported);
                 else if (fn && isConstructorName(name))
@@ -704,7 +760,11 @@ export function collectDeclarations(sf, file) {
                 callChain(expr);
         }
         else if (ts.isExportAssignment(statement)) {
-            stateArray(statement.expression);
+            const value = unwrap(statement.expression);
+            if (ts.isObjectLiteralExpression(value))
+                objectMembers(value, "default", true);
+            else
+                stateArray(statement.expression);
         }
         else if (ts.isIfStatement(statement)) {
             scriptStatement(statement.thenStatement, inIife);
@@ -787,8 +847,11 @@ export function collectDeclarations(sf, file) {
         }
     };
     visitStatements(sf.statements, undefined, true);
-    // Nested declarations are found after their holder statement; source order is start order.
-    const ordered = raws.map((r, i) => ({ r, i })).sort((a, b) => a.r.start - b.r.start || a.i - b.i);
+    // A registered function's members belong to its registered name; the generic pass (returned objects, `this.x`) is dropped.
+    const kept = registeredBodies.length === 0
+        ? raws
+        : raws.filter((r) => r.registered || !registeredBodies.some(([s, e]) => r.namePos >= s && r.namePos < e));
+    const ordered = kept.map((r, i) => ({ r, i })).sort((a, b) => a.r.start - b.r.start || a.i - b.i);
     return ordered.map(({ r }) => {
         const startLc = sf.getLineAndCharacterOfPosition(r.start);
         const full = r.signature;
@@ -812,6 +875,12 @@ export function collectDeclarations(sf, file) {
         };
     });
 }
+/** The string registration of a function registered by its identifier (`.directive('fancyBox', fancyBox)`): same namePos. */
+export function registrationOf(decl, fileDecls) {
+    if (decl.nameless)
+        return undefined;
+    return fileDecls.find((d) => d.nameless === true && d.namePos === decl.namePos && d.file === decl.file && d.kind === "function");
+}
 /** Declarations sharing file and qualified name (overloads, merging) are one Symbol. */
 export function symbolKey(decl) {
     return `${decl.file}#${decl.qualifiedName}`;

package/dist/src/templates.js

@@ -2,6 +2,7 @@
 // elements/attributes, their bindings as attributes, controllers in `ng-controller`, filters
 // after `|`. One regex pass per template line, no HTML parsing.
 import { sourceFs } from "./fs.js";
+import { registrationOf } from "./symbols.js";
 import { listFiles, toRel } from "./walk.js";
 export const TEMPLATE_EXTENSIONS = [".html", ".htm", ".ejs", ".hbs", ".njk", ".pug"];
 export function isTemplatePath(path) {
@@ -20,6 +21,12 @@ function elementOrAttribute(name) {
 }
 /** A Declaration's template form; undefined when templates cannot name it. */
 export function templateTarget(decl, fileDecls) {
+    const registered = registrationOf(decl, fileDecls);
+    // A function registered by identifier uses the registered name; the row keeps the function's name.
+    if (registered) {
+        const target = templateTarget(registered, fileDecls);
+        return target && { ...target, symbol: decl.qualifiedName };
+    }
     const isComponent = (d) => d !== undefined && d.nameless === true && d.signature.startsWith("component ");
     if (decl.nameless && (decl.parentName === "directive" || isComponent(decl)))
         return { symbol: decl.qualifiedName, pattern: elementOrAttribute(decl.name) };
@@ -29,7 +36,8 @@ export function templateTarget(decl, fileDecls) {
     if (decl.nameless && decl.parentName === "filter")
         return { symbol: decl.qualifiedName, pattern: new RegExp(`(?<!\\|)\\|\\s*${escape(decl.name)}(?![\\w$])`, "g") };
     if (decl.kind === "property" && decl.parentName !== undefined) {
-        const owner = fileDecls.find((d) => d.qualifiedName === decl.parentName && d.parentName !== decl.parentName);
+        const owners = fileDecls.filter((d) => d.qualifiedName === decl.parentName && d.parentName !== decl.parentName);
+        const owner = owners.find((d) => d.nameless) ?? owners[0];
         if (owner && owner.nameless && (owner.parentName === "directive" || isComponent(owner))) {
             return {
                 symbol: decl.qualifiedName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-axi",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "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": [

package/skills/ts-axi/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ts-axi
-description: "Navigate TypeScript and JavaScript code and measure change impact through the ts-axi CLI - find where a symbol is declared, list its references and callers, outline a file, and see which other code a diff affects. Use before reading many files to find callers or usages of a function, class or type; use `ts-axi impact` when reviewing a diff, a pull request or your own uncommitted changes."
+description: "Navigate TypeScript and JavaScript code and measure change impact through the ts-axi CLI - find where a symbol is declared, list its references and callers, outline a file, and see which other code a diff affects. Use before reading many files to find callers or usages of a function, class or type; use `ts-axi impact` when reviewing a diff, a pull request or your own uncommitted changes, and `ts-axi anchor` to check that review-comment file:line anchors are in the diff before posting them."
 user-invocable: false
 ---