ts-axi 0.1.6 → 0.1.8

package/README.md

@@ -175,7 +175,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. 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`. 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/impact.js

@@ -29,7 +29,7 @@ flags[7]:
 output:
   base, head, changes (count), changed[n]{symbol,kind,change,exported,at,refs_total,refs_outside,via,files,tests}
   change = signature | removed | type | added | body | modified (before unavailable) - riskiest first
-  textual = column added only when an untyped (JavaScript; implicit project) Symbol has more whole-word matches outside the change set than refs_outside - those are uses the checker cannot resolve; - for typed rows; such a Change is never local_only
+  textual = column added only when an untyped (JavaScript; implicit project) Symbol has more whole-word matches outside the change set than refs_outside - those are uses the checker cannot resolve (declaring file only for a non-exported local); - for typed rows; such a Change is never local_only
   refs_* / files / tests count direct References only; via = References outside the change set that reach the Symbol through an interface or base member it implements (or name an override of it) - they MAY call it
   refs[n]{symbol,file,line,context} = References outside the change set; truncated + refs_shown + refs_outside_total when cut
   notes[n]{symbol,note} = a signature change of a member that implements an interface or base member (the contract may break)
@@ -231,22 +231,27 @@ function blindSpots(semantic, names, changeSet) {
 function walkExtra(dir, outFiles) {
     outFiles.push(...walkFiles(dir, { accept: (name) => GREP_EXTRA.some((ext) => name.endsWith(ext)) }).files);
 }
-/** Whole-word matches of `names` in Project files and templates that are not `known` References. */
-export function textualMatches(opened, semantic, names, known, skipLines, changeSet) {
+/**
+ * Whole-word matches of `names` in Project files and templates that are not `known` References;
+ * a name in `localTo` (name → absolute file) is searched in that file only.
+ */
+export function textualMatches(opened, semantic, names, known, skipLines, changeSet, localTo = new Map()) {
     const files = [...semantic.projectFiles];
     const projectSet = new Set(files);
     walkExtra(opened.root, files);
     const rows = [];
     for (const abs of files) {
         const text = opened.index.text(abs);
-        if (text === undefined || !names.some((n) => text.includes(n)))
+        if (text === undefined || !names.some((n) => text.includes(n.text)))
             continue;
         const rel = opened.index.rel(abs);
         // A Declaration of another Symbol with the same name is provably not a use.
         const declared = new Set(projectSet.has(abs) ? opened.index.declarations(abs).map((d) => d.nameLine) : []);
         const lines = new Set();
-        for (const name of names) {
-            for (const m of wordMatches(text, name)) {
+        for (const { text: name, token } of names) {
+            if (localTo.has(name) && localTo.get(name) !== abs)
+                continue;
+            for (const m of wordMatches(text, name, token)) {
                 if (known.has(`${rel}:${m.line}`) || skipLines.has(`${rel}:${m.line}`) || declared.has(m.line) || inRanges(changeSet.get(rel), m.line))
                     continue;
                 if (lines.has(m.line))
@@ -258,34 +263,65 @@ export function textualMatches(opened, semantic, names, known, skipLines, change
     }
     return rows.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
 }
+/** 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;
+}
 /**
- * The checker may miss uses: JS declaring file, a string-registered name, or no tsconfig at all.
- * A state's hooks (`onEnter`, inline `controller`) are called by the router, never by name: no textual count.
+ * The textual needle of a Symbol: a state's full name without the `states.`/`routes.` prefix (a token, so
+ * `ui-sref="a.b"` counts and `a.b.c` does not match `a.b`; none when it still holds `*`), else the last
+ * segment of the qualified name.
  */
+export function textualNeedle(subject, kind) {
+    const symbol = typeof subject === "string" ? subject : subject.qualifiedName;
+    if ((kind ?? (typeof subject === "string" ? undefined : subject.kind)) === "state") {
+        const name = symbol.replace(/^(states|routes)\./, "");
+        return name.includes("*") || name === "" ? undefined : { text: name, token: true };
+    }
+    return { text: symbol.split(".").pop(), token: false };
+}
+/** Whether `any`-typed property accesses of the name can be uses of the Symbol: same rule as `isTextualCandidate`. */
+export function isBlindSpotCandidate(decl) {
+    return decl?.injected !== true;
+}
+/** The checker may miss uses: JS declaring file, a string-registered name, or no tsconfig at all. */
 export function isUntyped(opened, decl, file) {
-    if (decl?.parentName !== undefined && /^(states|routes)\./.test(decl.parentName) && !decl.parentName.endsWith(".resolve"))
+    if (!isTextualCandidate(decl))
         return false;
     return decl?.nameless === true || opened.index.project.implicit || (file !== undefined && /\.[mc]?jsx?$/.test(file));
 }
-/** Whole-word occurrences of `name` in Project files outside `changeSet`; lines declaring a `name` excluded. */
-export function textualCount(opened, name, changeSet = new Map()) {
+/** 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;
+}
+/**
+ * Whole-word occurrences of `name` in Project files outside `changeSet`; lines declaring a `name` excluded.
+ * With `onlyFile` (absolute), that file alone.
+ */
+export function textualCount(opened, needle, changeSet = new Map(), onlyFile) {
+    const { text: name, token } = needle;
     let matches = 0;
     let files = 0;
-    for (const abs of opened.index.files) {
+    const project = new Set(opened.index.files);
+    // State names are also written in templates (`ui-sref`), which the Project does not list.
+    const candidates = onlyFile !== undefined ? [onlyFile] : [...project];
+    if (token && onlyFile === undefined)
+        walkExtra(opened.root, candidates);
+    for (const abs of new Set(candidates)) {
         const text = opened.index.text(abs);
         if (text === undefined || !text.includes(name))
             continue;
         const rel = opened.index.rel(abs);
-        const declared = new Set(opened.index.declarations(abs).filter((d) => d.name === name).map((d) => d.nameLine));
-        const n = wordMatches(text, name).filter((m) => !declared.has(m.line) && !inRanges(changeSet.get(rel), m.line)).length;
+        const declared = new Set(project.has(abs) ? opened.index.declarations(abs).filter((d) => d.name === name).map((d) => d.nameLine) : []);
+        const n = wordMatches(text, name, token).filter((m) => !declared.has(m.line) && !inRanges(changeSet.get(rel), m.line)).length;
         matches += n;
         if (n > 0)
             files++;
     }
-    return { matches, files };
+    return { matches, files, ...(onlyFile !== undefined ? { fileScoped: true } : {}) };
 }
 export function textualLine(count) {
-    return `${count.matches} matches in ${count.files} files`;
+    return count.fileScoped ? `${count.matches} matches in this file` : `${count.matches} matches in ${count.files} files`;
 }
 export function textualHint(command, gap) {
     return `Run \`${command}\` for the ${gap} textual matches the checker cannot resolve (untyped JavaScript)`;
@@ -529,9 +565,13 @@ export async function impactCommand(args, ctx) {
     for (const row of rows) {
         if (!row.live || !isUntyped(opened, row.live, row.live.file))
             continue;
-        row.textual = textualCount(opened, row.live.name, changeSet);
+        const localTo = isPlainLocal(row.live) ? new Map([[row.live.name, opened.index.abs(row.live.file)]]) : undefined;
+        const needle = textualNeedle(row.live);
+        if (!needle)
+            continue;
+        row.textual = textualCount(opened, needle, changeSet, localTo?.get(row.live.name));
         if (row.textual.matches > 0)
-            row.unresolved = textualMatches(opened, semantic, [row.live.name], known, new Set(), changeSet).length;
+            row.unresolved = textualMatches(opened, semantic, [needle], known, new Set(), changeSet, localTo).length;
     }
     // Template usages: directives, components, bindings, controllers and filters named in .html and friends.
     let templateFiles;
@@ -585,14 +625,31 @@ export async function impactCommand(args, ctx) {
     };
     // --- Blind spots, textual matches, deeper callers ---
     const names = new Map();
+    const textNames = new Map();
+    // A name is file-scoped only when every changed Declaration carrying it is a plain local of one file.
+    const localTo = new Map();
+    const wide = new Set();
     for (const r of rows) {
-        const name = (r.change.after ?? r.change.before).name;
-        if (!names.has(name))
+        const decl = r.change.after ?? r.change.before;
+        const name = decl.name;
+        if (isBlindSpotCandidate(decl) && !names.has(name))
             names.set(name, r.symbol);
+        const needle = isTextualCandidate(decl) ? textualNeedle(decl) : undefined;
+        if (!needle)
+            continue;
+        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))
+            wide.add(name);
+        else
+            localTo.set(name, abs);
     }
+    for (const name of wide)
+        localTo.delete(name);
     const spots = blindSpots(semantic, names, changeSet);
     const textRows = grep
-        ? textualMatches(opened, semantic, [...names.keys()], known, new Set(spots.map((s) => `${s.file}:${s.line}`)), changeSet)
+        ? textualMatches(opened, semantic, [...textNames.values()], known, new Set(spots.map((s) => `${s.file}:${s.line}`)), changeSet, localTo)
         : [];
     const unresolved = grep ? withTemplateRows(textRows, rows, templateFiles ?? []) : [];
     const touched = [...new Set([...analysed.filter((f) => f.status !== "deleted").map((f) => f.path), ...listed.flatMap((r) => r.outside.map((e) => e.file))])];

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 { isUntyped, textualCount, textualHint, textualLine, textualMatches } from "./impact.js";
+import { isPlainLocal, isTextualCandidate, isUntyped, textualCount, textualNeedle, textualHint, textualLine, textualMatches } from "./impact.js";
 import { findOutsideProject, nearestTsconfig } from "../project.js";
 import { viaLine } from "../references.js";
 import { block, helpBlock, out } from "../render.js";
@@ -23,7 +23,7 @@ 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); above refs_total = uses the checker cannot resolve - see refs --grep
+  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`;
 export const REFS_HELP = `usage: ts-axi refs <name | Class.member | path:line[:col]> [flags]
 flags[12]:
@@ -150,10 +150,12 @@ async function run(args, ctx, invoked) {
     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 textual = declaredFile !== undefined && isUntyped(opened, decl, declaredFile) ? textualCount(opened, symbol.split(".").pop()) : undefined;
+    const localFile = isPlainLocal(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;
     const templates = tplTarget ? templateRows(loadTemplates(opened.root), tplTarget) : undefined;
-    const o = { started, symbol, declaredAt, show, scope, explicit, label, name, absFile: resolved.absFile, ...(decl ? { decl } : {}), ...(textual ? { textual } : {}), ...(templates ? { templates } : {}) };
+    const o = { started, symbol, kind, declaredAt, show, scope, explicit, label, name, absFile: resolved.absFile, ...(decl ? { decl } : {}), ...(textual ? { textual } : {}), ...(templates ? { templates } : {}) };
     return mode === "calls"
         ? renderCallers(semantic, opened, resolved, header, { ...o, limit, depth })
         : renderRefs(semantic, opened, resolved, header, { ...o, limit, kind });
@@ -196,7 +198,9 @@ function outsideImporters(opened, o) {
     const inProject = new Set(opened.index.files);
     const barrels = new Set(closure.barrels);
     const targets = [o.absFile, ...closure.barrels];
-    const needle = o.symbol.split(".").pop();
+    const needle = textualNeedle(o.symbol, o.kind)?.text;
+    if (!needle)
+        return { fields: {}, help: [] };
     const rows = closure.importers
         .filter((f) => !inProject.has(f) && !barrels.has(f) && (opened.index.text(f) ?? "").includes(needle))
         .map((f) => {
@@ -241,7 +245,10 @@ function viaFields(via, bases) {
 }
 /** Whole-word matches of the name on lines that hold no known position (what `--grep` lists). */
 function unresolvedOf(opened, semantic, o, known) {
-    return textualMatches(opened, semantic, [o.symbol.split(".").pop()], 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());
+    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());
 }
 /**
  * `textual` field and, when the name occurs more often than refs_total and some matches sit on no
@@ -281,7 +288,7 @@ function renderRefs(semantic, opened, resolved, header, o) {
         help.push(`Run \`ts-axi refs ${o.declaredAt} --implementations\` to list the ${impls.length} implementations`);
     const outside = rows.length === 0 ? outsideImporters(opened, o) : { fields: {}, help: [] };
     help.unshift(...outside.help);
-    const word = o.symbol.split(".").pop();
+    const word = textualNeedle(o.symbol, o.kind)?.text ?? "";
     const unresolved = o.show.grep || o.textual || o.templates ? unresolvedOf(opened, semantic, o, [...rows, ...via, ...impls]) : [];
     const grepRows = withTemplates(unresolved, o.templates);
     // The --grep hint counts what --grep lists: textual and template rows together.
@@ -289,7 +296,7 @@ function renderRefs(semantic, opened, resolved, header, o) {
     const tpl = templateFields(o, o.show.grep || text.help.length > 0);
     if (text.help.length > 0)
         help.unshift(...text.help);
-    else if (o.decl?.nameless && !o.show.grep && tpl.help.length === 0)
+    else if (o.decl?.nameless && word && !o.show.grep && tpl.help.length === 0)
         help.unshift(`Run \`ts-axi refs ${o.declaredAt} --grep\` for textual matches of '${word}'`);
     help.unshift(...tpl.help);
     if (isFunctionLike(o.kind))

package/dist/src/impact.js

@@ -222,10 +222,14 @@ export function localOnlyLine(entries, max = 10) {
     const rest = entries.length - shown.length;
     return `${entries.length} (${[...shown, ...(rest > 0 ? [`+${rest}`] : [])].join("; ")})`;
 }
-/** Whole-word occurrences of `name` in `text`: 1-based line and column. */
-export function wordMatches(text, name) {
-    const escaped = name.replace(/[$]/g, "\\$");
-    const re = new RegExp(`(?<![\\w$])${escaped}(?![\\w$])`, "g");
+/**
+ * Whole-word occurrences of `name` in `text`: 1-based line and column. With `token`, `name` is a dotted
+ * path (a state name): escaped literally, and neither `.` nor an identifier character may touch it.
+ */
+export function wordMatches(text, name, token = false) {
+    const re = token
+        ? new RegExp(`(?<![\\w$.])${name.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&")}(?![\\w$.])`, "g")
+        : new RegExp(`(?<![\\w$])${name.replace(/[$]/g, "\\$")}(?![\\w$])`, "g");
     const result = [];
     const lines = text.split("\n");
     lines.forEach((lineText, i) => {

package/dist/src/symbols.js

@@ -232,6 +232,8 @@ const CONSTRUCTOR_VERBS = new Set(["controller", "service", "provider"]);
 /** Router providers whose `.state(...)` / `.when(...)` calls declare a state (ui-router, ngRoute). */
 const STATE_PROVIDER = /^\$?stateProvider$/i;
 const ROUTE_PROVIDER = /^\$?routeProvider$/i;
+/** Keys that, next to a string `name`, make an array element a ui-router state object. */
+const STATE_KEYS = new Set(["url", "resolve", "component", "controller", "template", "templateUrl", "views", "abstract"]);
 /** Directive definition keys whose object literal lists the bindings. */
 const BINDING_KEYS = new Set(["scope", "bindToController", "bindings"]);
 /** `Template.x.<hook>(fn)` lifecycle callbacks. */
@@ -448,52 +450,111 @@ export function collectDeclarations(sf, file) {
             if (!name || !prop.name)
                 continue;
             if (ts.isMethodDeclaration(prop)) {
-                nested({ start: prop.getStart(sf), end: prop.end, kind: "method", name, parentName: holder, exported: true, signature: fullSignatureOf(prop, sf), namePos: prop.name.getStart(sf) });
+                nested({ start: prop.getStart(sf), end: prop.end, kind: "method", name, parentName: holder, exported: true, signature: fullSignatureOf(prop, sf), namePos: prop.name.getStart(sf), injected: true });
             }
             else if (ts.isPropertyAssignment(prop)) {
                 const value = unwrap(prop.initializer);
                 const fn = registeredFunction(value);
                 if (fn)
-                    nested({ start: prop.getStart(sf), end: prop.end, kind: "method", name, parentName: holder, exported: true, signature: `${name}${paramsText(fn, sf)}`, namePos: prop.name.getStart(sf) });
+                    nested({ start: prop.getStart(sf), end: prop.end, kind: "method", name, parentName: holder, exported: true, signature: `${name}${paramsText(fn, sf)}`, namePos: prop.name.getStart(sf), injected: true });
                 else if (ts.isObjectLiteralExpression(value) && depth < 3)
                     stateMembers(value, `${holder}.${name}`, depth + 1);
             }
         }
     };
-    /** One `.state('name', {...})`, `.state({ name, ... })` or `.when('/path', {...})` call. */
-    const stateCall = (call, route) => {
-        const [first, second] = call.arguments;
-        const obj = first && ts.isObjectLiteralExpression(first) && !route ? first : second && ts.isObjectLiteralExpression(second) ? second : undefined;
-        if (!obj)
-            return;
-        const literal = (key) => {
-            const prop = obj.properties.find((p) => ts.isPropertyAssignment(p) && nameText(p.name, sf) === key);
-            return prop && isStringName(prop.initializer) ? prop.initializer.text : undefined;
-        };
-        const name = isStringName(first) ? first.text : literal("name");
-        if (name === undefined)
-            return;
-        const url = literal("url");
+    /** Same-file string consts (`const base = 'main.x'`), for state names built from them; ambiguous names dropped. */
+    let stringConsts;
+    const constValue = (id, depth) => {
+        if (!stringConsts) {
+            stringConsts = new Map();
+            const visit = (node) => {
+                if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+                    const init = unwrap(node.initializer);
+                    if (isStringName(init) || ts.isTemplateExpression(init))
+                        stringConsts.set(node.name.text, stringConsts.has(node.name.text) ? null : init);
+                }
+                ts.forEachChild(node, visit);
+            };
+            visit(sf);
+        }
+        const init = stringConsts.get(id);
+        return init && depth < 3 ? stateNameOf(init, depth + 1) : undefined;
+    };
+    /** A literal, a template literal (`${...}` = a same-file string const, else `*`) or a const identifier. */
+    const stateNameOf = (expr, depth = 0) => {
+        const e = unwrap(expr);
+        if (isStringName(e))
+            return e.text;
+        if (ts.isTemplateExpression(e)) {
+            return e.head.text + e.templateSpans.map((s) => (ts.isIdentifier(s.expression) ? (constValue(s.expression.text, depth) ?? "*") : "*") + s.literal.text).join("");
+        }
+        if (ts.isIdentifier(e))
+            return constValue(e.text, depth) ?? e.text;
+        return undefined;
+    };
+    const propOf = (obj, key) => obj.properties.find((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) && nameText(p.name, sf) === key);
+    /** `name` of a state object literal: `name: 'x'`, `` name: `${base}.x` ``, `name: base` or `{ name }`. */
+    const stateObjectName = (obj) => {
+        const prop = propOf(obj, "name");
+        if (prop && ts.isPropertyAssignment(prop))
+            return stateNameOf(prop.initializer);
+        if (prop && ts.isShorthandPropertyAssignment(prop))
+            return stateNameOf(prop.name);
+        return undefined;
+    };
+    /** A ui-router state object (`.state()` argument or array element) or an ngRoute config as a `state` Declaration plus its callbacks. */
+    const stateFromObject = (obj, name, start, end, route) => {
+        const url = propOf(obj, "url");
+        const urlText = url && ts.isPropertyAssignment(url) && isStringName(url.initializer) ? url.initializer.text : undefined;
         const parent = route ? "routes" : "states";
         // Plain-literal options are compared, not displayed: a new controller or template is a contract change.
         const options = obj.properties
             .filter((p) => ts.isPropertyAssignment(p) && nameText(p.name, sf) !== "name" && nameText(p.name, sf) !== "url")
             .filter((p) => isStringName(p.initializer) || p.initializer.kind === ts.SyntaxKind.TrueKeyword || p.initializer.kind === ts.SyntaxKind.FalseKeyword)
             .map((p) => tokenText(p, sf, p.getStart(sf), p.end));
-        const callee = call.expression;
         nested({
-            start: callee.name.getStart(sf),
-            end: call.end,
+            start,
+            end,
             kind: "state",
             name,
             parentName: parent,
             exported: true,
-            signature: `${route ? "route" : "state"} ${name}${url !== undefined && !route ? ` (url ${url})` : ""}${options.length > 0 ? `\n${options.join("; ")}` : ""}`,
+            signature: `${route ? "route" : "state"} ${name}${urlText !== undefined && !route ? ` (url ${urlText})` : ""}${options.length > 0 ? `\n${options.join("; ")}` : ""}`,
             namePos: obj.getStart(sf),
             nameless: true,
         });
         stateMembers(obj, `${parent}.${name}`, 1);
     };
+    /** One `.state('name', {...})`, `.state({ name, ... })` or `.when('/path', {...})` call. */
+    const stateCall = (call, route) => {
+        const [first, second] = call.arguments;
+        const obj = first && ts.isObjectLiteralExpression(first) && !route ? first : second && ts.isObjectLiteralExpression(second) ? second : undefined;
+        if (!obj)
+            return;
+        const name = isStringName(first) ? first.text : route ? undefined : stateObjectName(obj);
+        if (name === undefined)
+            return;
+        stateFromObject(obj, name, call.expression.name.getStart(sf), call.end, route);
+    };
+    /** State objects among the elements of an array literal, or of `[...].concat([...], ...)`; other values ignored. */
+    const stateArray = (expr) => {
+        const e = unwrap(expr);
+        if (ts.isArrayLiteralExpression(e)) {
+            for (const el of e.elements) {
+                const obj = unwrap(el);
+                if (!ts.isObjectLiteralExpression(obj) || !obj.properties.some((p) => STATE_KEYS.has(nameText(p.name, sf) ?? "")))
+                    continue;
+                const name = stateObjectName(obj);
+                if (name !== undefined)
+                    stateFromObject(obj, name, obj.getStart(sf), obj.end, false);
+            }
+        }
+        else if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) && e.expression.name.text === "concat") {
+            stateArray(e.expression.expression);
+            for (const arg of e.arguments)
+                stateArray(arg);
+        }
+    };
     /** `$stateProvider.state(...).state(...)` and `$routeProvider.when(...)` chains; `.otherwise()` ignored. */
     const routerChain = (expr) => {
         const calls = [];
@@ -567,8 +628,12 @@ export function collectDeclarations(sf, file) {
         if (target === "module.exports") {
             if (ts.isObjectLiteralExpression(right))
                 objectMembers(right, "exports", true);
+            else
+                stateArray(right);
             return;
         }
+        if (target === `exports.${left.name.text}` || target === `module.exports.${left.name.text}`)
+            stateArray(right);
         const owner = left.expression;
         if (ts.isPropertyAccessExpression(owner) && owner.name.text === "prototype" && ts.isIdentifier(owner.expression)) {
             const cls = owner.expression.text;
@@ -614,6 +679,7 @@ export function collectDeclarations(sf, file) {
                     routerBody(fn.body);
                 const exported = inIife ? false : topLevelExported(name);
                 const init = unwrap(decl.initializer);
+                stateArray(init);
                 if (ts.isObjectLiteralExpression(init))
                     objectMembers(init, name, exported);
                 else if (fn && isConstructorName(name))
@@ -637,6 +703,9 @@ export function collectDeclarations(sf, file) {
             else
                 callChain(expr);
         }
+        else if (ts.isExportAssignment(statement)) {
+            stateArray(statement.expression);
+        }
         else if (ts.isIfStatement(statement)) {
             scriptStatement(statement.thenStatement, inIife);
             if (statement.elseStatement)
@@ -739,6 +808,7 @@ export function collectDeclarations(sf, file) {
             hasBody: r.hasBody,
             fullSignature: full,
             ...(r.nameless ? { nameless: true } : {}),
+            ...(r.injected ? { injected: true } : {}),
         };
     });
 }

package/dist/src/templates.js

@@ -53,6 +53,46 @@ export function loadTemplates(root) {
     }
     return files;
 }
+const TAG_SPAN_LINES = 40;
+/**
+ * Text of the tag open at `offset` (from its `<`), or undefined when `offset` is outside a tag or
+ * inside a quoted value. Forward scan from up to 40 lines back; `>` inside quotes does not close.
+ * Tolerant of broken markup: never throws, an unclosed quote just ends the tag at the scan point.
+ */
+function openTagBefore(text, offset, lineStarts) {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (lineStarts[mid] <= offset)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    let tagStart = -1;
+    let quote = "";
+    for (let i = lineStarts[Math.max(0, lo - TAG_SPAN_LINES)]; i < offset; i++) {
+        const c = text[i];
+        if (tagStart < 0) {
+            if (c === "<" && /[A-Za-z]/.test(text[i + 1] ?? ""))
+                tagStart = i;
+        }
+        else if (quote) {
+            if (c === quote)
+                quote = "";
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+        }
+        else if (c === ">") {
+            tagStart = -1;
+        }
+        else if (c === "<" && /[A-Za-z]/.test(text[i + 1] ?? "")) {
+            tagStart = i;
+        }
+    }
+    return tagStart < 0 || quote ? undefined : text.slice(tagStart, offset);
+}
 /** Usages of `target` in one template text: at most one per line. */
 export function usagesIn(text, target) {
     const result = [];
@@ -66,12 +106,11 @@ export function usagesIn(text, target) {
         const offset = (m.index ?? 0) + (/^[<\s"'|]/.test(m[0]) ? 1 : 0);
         if (target.owner) {
             // The attribute counts only inside a tag opened by (or carrying) the owner directive.
-            const tagStart = text.lastIndexOf("<", offset);
-            if (tagStart < 0)
+            const tag = openTagBefore(text, offset, lineStarts);
+            if (tag === undefined)
                 continue;
-            const tag = text.slice(tagStart, offset);
             target.owner.lastIndex = 0;
-            if (tag.includes(">") || !target.owner.test(tag))
+            if (!target.owner.test(tag))
                 continue;
         }
         let lo = 0;

package/package.json

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