ts-axi 0.1.6 → 0.1.7

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,8 +231,11 @@ 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);
@@ -246,6 +249,8 @@ export function textualMatches(opened, semantic, names, known, skipLines, change
         const declared = new Set(projectSet.has(abs) ? opened.index.declarations(abs).map((d) => d.nameLine) : []);
         const lines = new Set();
         for (const name of names) {
+            if (localTo.has(name) && localTo.get(name) !== abs)
+                continue;
             for (const m of wordMatches(text, name)) {
                 if (known.has(`${rel}:${m.line}`) || skipLines.has(`${rel}:${m.line}`) || declared.has(m.line) || inRanges(changeSet.get(rel), m.line))
                     continue;
@@ -267,11 +272,18 @@ export function isUntyped(opened, decl, file) {
         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, name, changeSet = new Map(), onlyFile) {
     let matches = 0;
     let files = 0;
-    for (const abs of opened.index.files) {
+    for (const abs of onlyFile !== undefined ? [onlyFile] : opened.index.files) {
         const text = opened.index.text(abs);
         if (text === undefined || !text.includes(name))
             continue;
@@ -282,10 +294,10 @@ export function textualCount(opened, name, changeSet = new Map()) {
         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 +541,10 @@ 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;
+        row.textual = textualCount(opened, row.live.name, 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, [row.live.name], known, new Set(), changeSet, localTo).length;
     }
     // Template usages: directives, components, bindings, controllers and filters named in .html and friends.
     let templateFiles;
@@ -585,14 +598,25 @@ export async function impactCommand(args, ctx) {
     };
     // --- Blind spots, textual matches, deeper callers ---
     const names = 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;
+        const decl = r.change.after ?? r.change.before;
+        const name = decl.name;
         if (!names.has(name))
             names.set(name, r.symbol);
+        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, [...names.keys()], 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, isUntyped, textualCount, 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); '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,7 +150,8 @@ 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 textual = declaredFile !== undefined && isUntyped(opened, decl, declaredFile) ? textualCount(opened, symbol.split(".").pop(), 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 } : {}) };
@@ -241,7 +242,7 @@ 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());
+    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(), 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

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. */
@@ -460,40 +462,99 @@ export function collectDeclarations(sf, file) {
             }
         }
     };
-    /** 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)

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