ts-axi 0.1.11 → 0.1.12

package/README.md

@@ -78,7 +78,7 @@ The hook runs `ts-axi` with no arguments: it reads only the file tree and git st
 | Command | What it does |
 | --- | --- |
 | `ts-axi` | Home view: project root, tsconfig used (or implicit), source file count, test-file glob and match counts, git branch and dirty count, next steps. Under a second, exit 0 everywhere |
-| `def <target>` | Declarations of a symbol by name (`save`, `User.save`, `path:line`): one match prints detail and body, several print a compact list, none prints `did_you_mean` |
+| `def <target>` | Declarations of a symbol by name (`save`, `User.save`, `path:line`): one match prints detail and body, several print a compact list, none prints `did_you_mean` and, when the name still occurs in the code, the `refs <name> --grep` that lists those textual matches |
 | `refs <target>` | References of one symbol, grouped by file, with test counts. A class member that implements an interface (or overrides a base) member counts only its direct References; calls through the interface are `via_interface: n (Iface.member)`, sibling implementations are dropped, and an interface member reports `implementations: n`. `--limit`, `--kind calls`, `--via` (via rows with a `via` column), `--implementations` |
 | `callers <target>` | Incoming calls of a function-like symbol, split the same way (`via_interface`, `--via`). `--depth 1..3` |
 | `outline <file>` | Top-level declarations in source order, class members nested: `{line,kind,name,signature}` (`{at,kind,name,signature}` over several files). `--exports`, `--fields exported` |
@@ -180,7 +180,7 @@ decls[4]{line,kind,name,exported,signature}:
   17,function,cartBadge,true,directive cartBadge()
 ```
 
-An edit inside `CartCtrl` is reported by `impact` as `CartCtrl body`, not as a file-level change. Names registered by a string have no identifier the checker can follow; `refs` says so and offers `--grep`. ui-router and ngRoute states are Declarations of kind `state` (`states.cart`, with callbacks as `states.cart.resolve.items`), so an edit inside a `resolve` names that callback; state objects in exported arrays (`` module.exports = [{ name: `${base}.init`, url, resolve }] ``) count too, their template-literal names filled from same-file consts. Directives, components, their `scope`/`bindings` keys, controllers and filters also get `templates: <n> usages in <m> files` (kebab-case elements and attributes, `ng-controller`, `| filter` in `.html`/`.htm`/`.ejs`/`.hbs`/`.njk`/`.pug`), a `templates` column in `impact`, and a changed template that uses a changed directive or binding is listed under `template_changes` instead of `skipped`.
+An edit inside `CartCtrl` is reported by `impact` as `CartCtrl body`, not as a file-level change. Names registered by a string have no identifier the checker can follow; `refs` says so and offers `--grep`. A registration that names a same-file function (`.directive('fancyBox', fancyBox)`, `['$uibModal', fancyBox]`) links the two, so `refs` on the function reports the registration's template usages too. Function-valued members of an object a function returns (`return { canReadItem: async () => ... }`) are Declarations (`makeItemDeps.canReadItem`), so `def canReadItem` finds them; their `textual:` count covers the whole project, while a real local (a parameter, an IIFE helper, a CommonJS binding no `module.exports` hands out) says `in this file`. ui-router and ngRoute states are Declarations of kind `state` (`states.cart`, with callbacks as `states.cart.resolve.items`), so an edit inside a `resolve` names that callback; state objects in exported arrays (`` module.exports = [{ name: `${base}.init`, url, resolve }] ``) count too, their template-literal names filled from same-file consts. Directives, components, their `scope`/`bindings` keys, controllers and filters also get `templates: <n> usages in <m> files` (kebab-case elements and attributes, `ng-controller`, `| filter` in `.html`/`.htm`/`.ejs`/`.hbs`/`.njk`/`.pug`), a `templates` column in `impact`, and a changed template that uses a changed directive or binding is listed under `template_changes` instead of `skipped`.
 
 ## Monorepos
 

package/dist/src/commands/common.js

@@ -217,9 +217,27 @@ function identifiers(node, sf, outIds) {
     }
     ts.forEachChild(node, (child) => identifiers(child, sf, outIds));
 }
+function isFunctionValue(expr) {
+    let e = expr;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    return ts.isArrowFunction(e) || ts.isFunctionExpression(e);
+}
+/** Declares a name: a Declaration kind, a parameter, a binding element, or a function-valued property. */
 function isDeclarationName(id) {
     const parent = id.parent;
-    return parent !== undefined && parent.name === id && (kindOf(parent) !== undefined || ts.isParameter(parent) || ts.isBindingElement(parent));
+    if (parent === undefined || parent.name !== id)
+        return false;
+    if (ts.isPropertyAssignment(parent))
+        return isFunctionValue(parent.initializer);
+    return kindOf(parent) !== undefined || ts.isParameter(parent) || ts.isBindingElement(parent);
+}
+/** The node a declaration name owns, for nesting: `this.x = fn` → the whole assignment. */
+function declarationNode(id) {
+    const parent = id.parent;
+    if (ts.isPropertyAccessExpression(parent) && parent.name === id && ts.isBinaryExpression(parent.parent) && parent.parent.left === parent)
+        return parent.parent;
+    return parent;
 }
 /** The identifier a `path:line[:col]` target points at (see PLAN.md Targets). */
 export function resolvePosition(index, cwd, target) {
@@ -252,33 +270,41 @@ export function resolvePosition(index, cwd, target) {
         return hit ? pick(hit) : { kind: "none", abs, file, reason: `no identifier at ${file}:${target.line}:${target.col}` };
     }
     // A string-registered name has no identifier: its line stands for it.
-    const nameless = decls.find((d) => d.nameless && d.nameLine === target.line);
+    // The registration line too: `.directive('x', fancyBox)` has its name far from the function.
+    const nameless = decls.find((d) => d.nameless && d.nameLine === target.line) ?? decls.find((d) => d.nameless && d.line === target.line);
     if (nameless)
         return { kind: "decl", decl: nameless, abs };
     if (onLine.length === 0)
         return { kind: "none", abs, file, reason: `no identifier on ${file}:${target.line}` };
+    const ambiguous = (ids) => {
+        const distinct = new Map();
+        for (const id of ids)
+            if (!distinct.has(id.text))
+                distinct.set(id.text, id);
+        if (distinct.size === 1)
+            return pick(ids[0]);
+        return {
+            kind: "ambiguous",
+            abs,
+            file,
+            candidates: [...distinct.values()].map((id) => ({ name: id.text, line: target.line, col: id.getStart(sf) - lineStart + 1 })),
+        };
+    };
     const constructorDecl = decls.find((d) => d.nameLine === target.line && d.name === "constructor");
-    const declared = onLine.find((id) => declFor(id)) ?? onLine.find(isDeclarationName);
-    if (declared)
-        return pick(declared);
+    // The declaration that starts the line: names nested in another one's declaration (its parameters, its members) rank after it.
+    const declaring = onLine.filter((id) => declFor(id) !== undefined || isDeclarationName(id));
+    const owned = (inner, outer) => {
+        const node = declarationNode(outer);
+        const at = inner.getStart(sf);
+        return node !== declarationNode(inner) && node.getStart(sf) <= at && at < node.end;
+    };
+    const outer = declaring.filter((id) => !(constructorDecl && ts.isParameter(id.parent) && ts.isConstructorDeclaration(id.parent.parent)) &&
+        !declaring.some((other) => other !== id && owned(id, other)));
+    if (outer.length > 0)
+        return ambiguous(outer);
     if (constructorDecl)
         return { kind: "decl", decl: constructorDecl, abs };
-    const distinct = new Map();
-    for (const id of onLine)
-        if (!distinct.has(id.text))
-            distinct.set(id.text, id);
-    if (distinct.size === 1)
-        return pick(onLine[0]);
-    return {
-        kind: "ambiguous",
-        abs,
-        file,
-        candidates: [...distinct.values()].map((id) => ({
-            name: id.text,
-            line: target.line,
-            col: id.getStart(sf) - lineStart + 1,
-        })),
-    };
+    return ambiguous(onLine);
 }
 /** A Declaration for an arbitrary declaration name position (locals, parameters) not in the index. */
 export function declarationAt(index, abs, pos, fallbackKind) {

package/dist/src/commands/def.js

@@ -1,5 +1,6 @@
 import { bool, expectPositionals, flag, parseArgs } from "../args.js";
 import { semanticFor } from "../scope.js";
+import { textualScan, textualScanHint } from "./impact.js";
 import { block, fenced, helpBlock, out } from "../render.js";
 import { isFunctionLike, kindFromScriptElement, parseTarget } from "../symbols.js";
 import { BODY_LINES, declarationAt, filterSuffix, MATCH_ROWS, matchRows, narrowHints, numberedLines, open, positionStartDir, resolveNameTarget, resolvePosition, suggestions, TARGET_FLAGS, targetLabel, readFilters, useRef, } from "./common.js";
@@ -9,7 +10,7 @@ flags[8]:
 output:
   1 match = file, line, kind, exported, signature + body fenced with file line numbers
   several = matches[n]{at,kind,signature} (at = path:line) (at most ${MATCH_ROWS}; matches_total + truncated past that) + the narrowing forms (--in, --kind, Class.member, --exported) with how many each keeps
-  none = matches: 0 + did_you_mean
+  none = matches: 0 + did_you_mean; when the name still occurs in Project files, help gives the refs --grep that lists those textual matches
 examples[5]:
   ts-axi def User
   ts-axi def User.save
@@ -78,7 +79,8 @@ export async function defCommand(args, ctx) {
         return detail(opened, groups[0].decls, full, label);
     if (groups.length === 0) {
         const suggested = suggestions(opened, target);
-        const help = suggested.slice(0, 2).map((s) => `Run \`ts-axi def ${s}\``);
+        const text = f.fuzzy ? 0 : textualScan(opened, target.member ?? target.name).length;
+        const help = [...(text > 0 ? [textualScanHint(label, text)] : []), ...suggested.slice(0, 2).map((s) => `Run \`ts-axi def ${s}\``)];
         if (!f.fuzzy)
             help.push(`Run \`ts-axi def ${label} --fuzzy\` for substring matches`);
         if (f.kind || f.in.length > 0 || f.exported)

package/dist/src/commands/impact.js

@@ -270,6 +270,27 @@ export function textualMatches(opened, semantic, names, known, skipLines, change
     }
     return rows.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
 }
+/** Whole-word matches of `name` in the Project files, one row per line: the fallback when no Declaration matches. */
+export function textualScan(opened, name) {
+    const rows = [];
+    sourceFs().prefetch(opened.index.files);
+    for (const abs of opened.index.files) {
+        const text = opened.index.text(abs);
+        if (text === undefined || !text.includes(name))
+            continue;
+        let last = 0;
+        for (const m of wordMatches(text, name)) {
+            if (m.line === last)
+                continue;
+            last = m.line;
+            rows.push({ file: opened.index.rel(abs), line: m.line, context: contextOf(lineOf(text, m.line), m.col) });
+        }
+    }
+    return rows.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+}
+export function textualScanHint(label, matches) {
+    return `Run \`ts-axi refs ${label} --grep\` for ${matches} textual matches`;
+}
 /** Whether a whole-word count of the name says anything: not for router-called or by-name-injected members (`injected`). */
 export function isTextualCandidate(decl) {
     return decl?.injected !== true;
@@ -297,9 +318,66 @@ export function isUntyped(opened, decl, file) {
         return false;
     return decl?.nameless === true || opened.index.project.implicit || (file !== undefined && /\.[mc]?jsx?$/.test(file));
 }
-/** A non-exported, non-member, identifier-named Declaration: only its own file can name it. */
-export function isPlainLocal(decl) {
-    return decl !== undefined && !decl.exported && !decl.nameless && decl.parentName === undefined;
+/** The identifier starting at `pos`. */
+function identifierAt(node, pos, sf) {
+    if (ts.isIdentifier(node) && node.getStart(sf) === pos)
+        return node;
+    return ts.forEachChild(node, (child) => (child.pos <= pos && pos < child.end ? identifierAt(child, pos, sf) : undefined));
+}
+/** Names a CommonJS file hands out (`module.exports = { a, b: c }`, `exports.x = d`); undefined when not CommonJS. */
+function commonJsExports(sf) {
+    const names = new Set();
+    let cjs = /\brequire\s*\(/.test(sf.text);
+    // Values only: identifiers used inside exported function bodies do not leave the file.
+    const collect = (expr) => {
+        let e = expr;
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (ts.isIdentifier(e))
+            names.add(e.text);
+        else if (ts.isObjectLiteralExpression(e)) {
+            for (const p of e.properties) {
+                if (ts.isShorthandPropertyAssignment(p))
+                    names.add(p.name.text);
+                else if (ts.isPropertyAssignment(p))
+                    collect(p.initializer);
+                else if (ts.isSpreadAssignment(p))
+                    collect(p.expression);
+            }
+        }
+    };
+    for (const st of sf.statements) {
+        if (!ts.isExpressionStatement(st) || !ts.isBinaryExpression(st.expression) || st.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+            continue;
+        const left = st.expression.left.getText(sf).replace(/\s+/g, "");
+        if (!/^(module\.exports|exports)(\.|$)/.test(left))
+            continue;
+        cjs = true;
+        collect(st.expression.right);
+    }
+    return cjs ? names : undefined;
+}
+/**
+ * A Declaration only its own file can name: a parameter or function-scoped binding, or a non-exported top-level
+ * binding of an ES module, or of a CommonJS file whose exports never mention it. Members, object properties,
+ * string registrations and script globals are not.
+ */
+export function isPlainLocal(index, decl) {
+    if (decl === undefined || decl.exported || decl.nameless || decl.parentName !== undefined)
+        return false;
+    const sf = index.sourceFile(index.abs(decl.file));
+    const id = sf && identifierAt(sf, decl.namePos, sf);
+    if (!sf || !id)
+        return false;
+    const owner = id.parent;
+    if (ts.isPropertyAssignment(owner) || ts.isShorthandPropertyAssignment(owner) || ts.isMethodDeclaration(owner) || ts.isPropertyAccessExpression(owner))
+        return false;
+    for (let n = owner.parent; !ts.isSourceFile(n); n = n.parent)
+        if (ts.isFunctionLike(n))
+            return true;
+    if (ts.isExternalModule(sf))
+        return true;
+    return commonJsExports(sf)?.has(decl.name) === false;
 }
 /**
  * Whole-word occurrences of `name` in Project files outside `changeSet`; lines declaring a `name` excluded.
@@ -592,7 +670,7 @@ export async function impactCommand(args, ctx) {
     for (const row of rows) {
         if (!row.live || !isUntyped(opened, row.live, row.live.file))
             continue;
-        const localTo = isPlainLocal(row.live) ? new Map([[row.live.name, opened.index.abs(row.live.file)]]) : undefined;
+        const localTo = isPlainLocal(opened.index, row.live) ? new Map([[row.live.name, opened.index.abs(row.live.file)]]) : undefined;
         const needle = textualNeedle(row.live);
         if (!needle)
             continue;
@@ -667,7 +745,7 @@ export async function impactCommand(args, ctx) {
         if (!textNames.has(needle.text))
             textNames.set(needle.text, needle);
         const abs = opened.index.abs(decl.file);
-        if (!isPlainLocal(decl) || (localTo.has(name) && localTo.get(name) !== abs))
+        if (!isPlainLocal(opened.index, decl) || (localTo.has(name) && localTo.get(name) !== abs))
             wide.add(name);
         else
             localTo.set(name, abs);

package/dist/src/commands/refs.js

@@ -1,7 +1,7 @@
 import { relative, sep } from "node:path";
 import { bool, expectPositionals, flag, intFlag, parseArgs } from "../args.js";
 import { importerClosure } from "../importers.js";
-import { isPlainLocal, isTextualCandidate, isUntyped, textualCount, textualNeedle, textualHint, textualLine, textualMatches } from "./impact.js";
+import { isPlainLocal, isTextualCandidate, isUntyped, textualCount, textualNeedle, textualHint, textualLine, textualMatches, textualScan, textualScanHint } from "./impact.js";
 import { findOutsideProject, nearestTsconfig } from "../project.js";
 import { viaLine } from "../references.js";
 import { block, helpBlock, out } from "../render.js";
@@ -10,7 +10,7 @@ import { loadTemplates, templatesLine, templateTarget, templateUsages } from "..
 import { byDepthThenPath } from "../walk.js";
 import { detectWorkspace, isMultiProject } from "../workspace.js";
 import { isTestFile } from "../settings.js";
-import { isFunctionLike, kindFromScriptElement, parseTarget } from "../symbols.js";
+import { isFunctionLike, kindFromScriptElement, parseTarget, registrationOf } from "../symbols.js";
 import { contextOf, declarationAt, filterSuffix, lineOf, MATCH_ROWS, matchRows, narrowHints, open, positionStartDir, projectFields, readFilters, useRef, resolveNameTarget, resolvePosition, suggestions, TARGET_FLAGS, targetLabel, } from "./common.js";
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 500;
@@ -23,8 +23,8 @@ const VIA_DOC = `via_interface: n (Iface.member) = References through an interfa
   refs_total: 0 under -P in a workspace lists found_outside_project[n]{file,line} = importers outside that Project
   scope = in a monorepo without -P the program is the declaring file + its importers (scope_partial: true when the importer scan was capped)
   tsconfig: x (n referenced configs) = a references-only tsconfig expanded to the configs it references
-  textual: n matches in m files = whole-word count of the name in Project files (JavaScript declarations and implicit projects; a state counts its full dotted name as a whole token, templates included; not for a state's resolve keys and hooks - injected by name, not imported); 'n matches in this file' for a non-exported local; above refs_total = uses the checker cannot resolve - see refs --grep
-  templates: n usages in m files = template uses (.html .htm .ejs .hbs .njk .pug) of a directive or component (<wap-select / wap-select / data-wap-select), its bindings (fallback-display-property= on that tag), a controller (ng-controller) or a filter (| money); refs --grep lists them in unresolved`;
+  textual: n matches in m files = whole-word count of the name in Project files (JavaScript declarations and implicit projects; a state counts its full dotted name as a whole token, templates included; not for a state's resolve keys and hooks - injected by name, not imported); 'n matches in this file' only for a real local (a parameter, a binding inside a function or IIFE, a non-exported top-level binding of an ES module or of a CommonJS file whose module.exports never hands it out) - members, object properties and script globals count Project-wide; above refs_total = uses the checker cannot resolve - see refs --grep
+  templates: n usages in m files = template uses (.html .htm .ejs .hbs .njk .pug) of a directive or component (<wap-select / wap-select / data-wap-select), its bindings (fallback-display-property= on that tag), a controller (ng-controller) or a filter (| money) - also for a function registered by identifier (.directive('fancyBox', fancyBox)), under the registered name; refs --grep lists them in unresolved`;
 export const REFS_HELP = `usage: ts-axi refs <name | Class.member | path:line[:col]> [flags]
 flags[13]:
   ${SHARED_FLAGS}
@@ -34,7 +34,9 @@ flags[13]:
 output:
   symbol, kind, declared_at, refs_total, files, tests, refs[n]{file,line,context} (Declarations excluded), elapsed_ms
   ${VIA_DOC}
-  note = the name is registered by a string ('Name' in .controller('Name', fn)) - its uses are textual; add --grep
+  note = the name is registered by a string ('Name' in .controller('Name', fn), or fn a same-file function named by identifier) - its uses are textual; add --grep
+  matches: 0 = no Declaration of the name; help counts its whole-word matches in Project files, and --grep lists them in unresolved with note 'no declaration found - textual matches only'
+  path:line = the declaration that starts the line (a function before its parameters, a property before its value's parameters; siblings like 'const a = 1, b = 2' list identifiers - add :col)
   an ambiguous name lists matches[n] (at most ${MATCH_ROWS}; matches_total + truncated past that) + the narrowing forms; nothing is analysed
 examples[4]:
   ts-axi refs User.save
@@ -111,8 +113,23 @@ async function run(args, ctx, invoked) {
                     `Run \`ts-axi ${name} ${outside[0].file}:${outside[0].nameLine}\` to use the nearest tsconfig of that file`,
                 ]));
             }
+            // No Declaration, but the name may still be written: an untyped property set up elsewhere.
+            const text = f.fuzzy ? [] : textualScan(opened, target.member ?? target.name);
+            if (show.grep) {
+                return out(block({
+                    ...warning,
+                    matches: 0,
+                    note: "no declaration found - textual matches only",
+                    unresolved: text.length === 0 ? 0 : text.slice(0, limit),
+                    ...(text.length > limit ? { unresolved_total: text.length } : {}),
+                }), helpBlock([
+                    ...(text.length > limit ? [`Showing ${limit} of ${text.length}; run \`ts-axi refs ${label} --grep --limit ${Math.min(MAX_LIMIT, text.length)}\` for more`] : []),
+                    `Run \`ts-axi def ${label} --fuzzy\` for substring matches`,
+                ]));
+            }
             const suggested = suggestions(opened, target);
             return out(block({ ...warning, matches: 0, ...(suggested.length > 0 ? { did_you_mean: suggested } : {}) }), helpBlock([
+                ...(text.length > 0 ? [textualScanHint(label, text.length)] : []),
                 ...suggested.slice(0, 2).map((s) => `Run \`ts-axi ${name} ${s}\``),
                 ...(f.fuzzy ? [] : [`Run \`ts-axi def ${label} --fuzzy\` for substring matches`]),
             ]));
@@ -143,15 +160,17 @@ async function run(args, ctx, invoked) {
     }
     const { semantic, scope } = built;
     const def = semantic.definitionAt(resolved.absFile, resolved.pos);
-    const decl = resolved.decl ??
+    const found = resolved.decl ??
         (def && def.line > 0 ? declarationAt(opened.index, def.absFile, def.pos, kindFromScriptElement(def.kind)) : undefined);
+    // A function registered by identifier is its registration: templates, note and textual use the registered name.
+    const decl = (found && registrationOf(found, opened.index.declarations(opened.index.abs(found.file)))) ?? found;
     const kind = decl?.kind ?? kindFromScriptElement(def?.kind ?? semantic.quickInfo(resolved.absFile, resolved.pos)?.kind ?? "");
     const symbol = decl?.qualifiedName ?? def?.name ?? label;
     const declaredAt = decl ? `${decl.file}:${decl.nameLine}` : def && def.line > 0 ? `${def.file}:${def.line}` : "(outside the Project)";
     const header = { ...warning, ...projectFields(opened), symbol, kind, declared_at: declaredAt };
     const explicit = Boolean(project || opened.settings.project);
     const declaredFile = decl?.file ?? (def && def.line > 0 ? def.file : undefined);
-    const localFile = isPlainLocal(decl) ? opened.index.abs(decl.file) : undefined;
+    const localFile = isPlainLocal(opened.index, decl) ? opened.index.abs(decl.file) : undefined;
     const needle = textualNeedle(decl ?? symbol, kind);
     const textual = declaredFile !== undefined && needle && isUntyped(opened, decl, declaredFile) ? textualCount(opened, needle, new Map(), localFile) : undefined;
     const tplTarget = decl ? templateTarget(decl, opened.index.declarations(opened.index.abs(decl.file))) : undefined;
@@ -249,7 +268,7 @@ function unresolvedOf(opened, semantic, o, known) {
     const needle = isTextualCandidate(o.decl) ? textualNeedle(o.decl ?? o.symbol, o.kind) : undefined;
     if (!needle)
         return [];
-    return textualMatches(opened, semantic, [needle], new Set(known.map((r) => `${r.file}:${r.line}`)), new Set(o.decl ? [`${o.decl.file}:${o.decl.line}`, `${o.decl.file}:${o.decl.nameLine}`] : []), new Map(), isPlainLocal(o.decl) ? new Map([[o.decl.name, opened.index.abs(o.decl.file)]]) : new Map());
+    return textualMatches(opened, semantic, [needle], new Set(known.map((r) => `${r.file}:${r.line}`)), new Set(o.decl ? [`${o.decl.file}:${o.decl.line}`, `${o.decl.file}:${o.decl.nameLine}`] : []), new Map(), isPlainLocal(opened.index, o.decl) ? new Map([[o.decl.name, opened.index.abs(o.decl.file)]]) : new Map());
 }
 /**
  * `textual` field and, when the name occurs more often than refs_total and some matches sit on no

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.12",
   "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": [