@dep-radius/core 0.1.0

package/dist/usage/resolve-local.js

@@ -0,0 +1,340 @@
+import { join, posix } from "node:path";
+import { builtinModules } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import ts from "typescript";
+import { relPath } from "../inventory/manifests.js";
+import { packageNameOf, subpathOf } from "../inventory/specifiers.js";
+import { projectBoundary, resolveInstalled } from "../inventory/installed.js";
+const EXTS = [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".d.ts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".vue",
+    ".svelte",
+    ".astro",
+];
+const BUILTINS = new Set(builtinModules);
+export class LocalResolver {
+    fileSet;
+    boundary;
+    installCache = new Map();
+    configCache = new Map();
+    byName = new Map();
+    root;
+    inventory;
+    constructor(root, files, inventory) {
+        this.root = root;
+        this.inventory = inventory;
+        this.fileSet = new Set(files);
+        this.boundary = projectBoundary(root);
+        for (const d of inventory.installed) {
+            const list = this.byName.get(d.name) ?? [];
+            list.push(d);
+            this.byName.set(d.name, list);
+            for (const by of d.declaredBy) {
+                if (by.key !== d.name) {
+                    const alias = this.byName.get(by.key) ?? [];
+                    if (!alias.includes(d))
+                        alias.push(d);
+                    this.byName.set(by.key, alias);
+                }
+            }
+        }
+    }
+    async resolve(fromRel, specifier) {
+        if (specifier.startsWith("./") ||
+            specifier.startsWith("../") ||
+            specifier === "." ||
+            specifier === "..") {
+            const hit = this.tryFile(posix.join(posix.dirname(fromRel), specifier));
+            return hit ? { kind: "file", rel: hit } : { kind: "unresolved-local" };
+        }
+        if (specifier.startsWith("node:") ||
+            BUILTINS.has(specifier) ||
+            BUILTINS.has(specifier.split("/")[0])) {
+            return { kind: "builtin" };
+        }
+        const viaPaths = this.fromTsconfigPaths(fromRel, specifier);
+        if (viaPaths)
+            return { kind: "file", rel: viaPaths };
+        const pkg = packageNameOf(specifier);
+        if (!pkg) {
+            return looksLikeAlias(specifier)
+                ? { kind: "unresolved-local" }
+                : { kind: "unknown" };
+        }
+        const fromDir = join(this.root, posix.dirname(fromRel));
+        const key = `${fromDir}\0${pkg}`;
+        let p = this.installCache.get(key);
+        if (!p) {
+            p = resolveInstalled(fromDir, pkg, this.boundary);
+            this.installCache.set(key, p);
+        }
+        const found = await p;
+        if (found) {
+            if (found.local) {
+                const rel = this.workspaceEntry(found.realDir, subpathOf(specifier, pkg));
+                return rel ? { kind: "file", rel } : { kind: "unresolved-local" };
+            }
+            const dep = this.inventory.installed.find((d) => d.id === found.realDir);
+            return {
+                kind: "pkg",
+                installedId: found.realDir,
+                pkg: dep?.name ?? found.name,
+                entry: subpathOf(specifier, pkg),
+            };
+        }
+        // nothing on disk: attribute to the version the inventory read from a lockfile or a range
+        const candidates = this.byName.get(pkg);
+        if (candidates && candidates.length > 0) {
+            const dep = this.nearestDeclared(fromRel, candidates);
+            return {
+                kind: "pkg",
+                installedId: dep.id,
+                pkg: dep.name,
+                entry: subpathOf(specifier, pkg),
+            };
+        }
+        const ws = this.inventory.manifests.find((m) => m.name === pkg);
+        if (ws) {
+            const rel = this.workspaceEntry(ws.dir, subpathOf(specifier, pkg));
+            if (rel)
+                return { kind: "file", rel };
+        }
+        return looksLikeAlias(specifier)
+            ? { kind: "unresolved-local" }
+            : { kind: "unknown" };
+    }
+    nearestDeclared(fromRel, deps) {
+        let best = deps[0];
+        let bestLen = -1;
+        for (const d of deps) {
+            for (const by of d.declaredBy) {
+                const dir = posix.dirname(by.manifest);
+                const prefix = dir === "." ? "" : `${dir}/`;
+                if (fromRel.startsWith(prefix) && prefix.length > bestLen) {
+                    best = d;
+                    bestLen = prefix.length;
+                }
+            }
+        }
+        return best;
+    }
+    tryFile(rel) {
+        const norm = posix.normalize(rel).replace(/^\.\//, "");
+        if (this.fileSet.has(norm))
+            return norm;
+        for (const ext of EXTS)
+            if (this.fileSet.has(norm + ext))
+                return norm + ext;
+        // ESM TypeScript writes the emitted extension: ./a.js means ./a.ts
+        const swap = /\.(m|c)?jsx?$/.exec(norm);
+        if (swap) {
+            const base = norm.slice(0, -swap[0].length);
+            const m = swap[1] ?? "";
+            for (const ext of [`.${m}ts`, `.${m}tsx`, ".ts", ".tsx"])
+                if (this.fileSet.has(base + ext))
+                    return base + ext;
+        }
+        for (const ext of EXTS)
+            if (this.fileSet.has(`${norm}/index${ext}`))
+                return `${norm}/index${ext}`;
+        return undefined;
+    }
+    workspaceEntry(absDir, subpath) {
+        const dirRel = relPath(this.root, absDir);
+        if (dirRel.startsWith(".."))
+            return undefined;
+        const pjPath = join(absDir, "package.json");
+        let pj = {};
+        try {
+            pj = JSON.parse(readFileSync(pjPath, "utf8"));
+        }
+        catch {
+            // folder without a manifest: fall back to index files
+        }
+        const base = dirRel === "." ? "" : `${dirRel}/`;
+        const targets = [];
+        if (pj.exports !== undefined) {
+            const t = exportsTarget(pj.exports, subpath);
+            if (t)
+                targets.push(t);
+        }
+        else if (subpath === ".") {
+            for (const f of [pj.types, pj.module, pj.main])
+                if (f)
+                    targets.push(f);
+            targets.push("index");
+        }
+        else {
+            targets.push(subpath);
+        }
+        for (const t of targets) {
+            const hit = this.tryFile(base + t.replace(/^\.\//, ""));
+            if (hit)
+                return hit;
+            // a manifest pointing at dist/ that was never built: its sources are the next best answer
+            const src = t.replace(/^\.?\/?(dist|build|lib|out)\//, "src/");
+            const hit2 = src !== t ? this.tryFile(base + src.replace(/\.d\.ts$/, "")) : undefined;
+            if (hit2)
+                return hit2;
+        }
+        return undefined;
+    }
+    fromTsconfigPaths(fromRel, specifier) {
+        const cfg = this.pathsConfigFor(posix.dirname(fromRel));
+        if (!cfg)
+            return undefined;
+        for (const [pattern, subs] of cfg.paths) {
+            const star = pattern.indexOf("*");
+            let captured;
+            if (star < 0) {
+                if (pattern === specifier)
+                    captured = "";
+            }
+            else {
+                const pre = pattern.slice(0, star);
+                const post = pattern.slice(star + 1);
+                if (specifier.startsWith(pre) &&
+                    specifier.endsWith(post) &&
+                    specifier.length >= pre.length + post.length) {
+                    captured = specifier.slice(pre.length, specifier.length - post.length);
+                }
+            }
+            if (captured === undefined)
+                continue;
+            for (const sub of subs) {
+                const rel = posix.join(cfg.baseUrl ?? cfg.dir, sub.replace("*", captured));
+                const hit = this.tryFile(rel);
+                if (hit)
+                    return hit;
+            }
+        }
+        if (cfg.baseUrl &&
+            !specifier.startsWith("@") &&
+            !packageNameOf(specifier)?.includes(".")) {
+            const hit = this.tryFile(posix.join(cfg.baseUrl, specifier));
+            if (hit && !this.byName.has(packageNameOf(specifier) ?? ""))
+                return hit;
+        }
+        return undefined;
+    }
+    pathsConfigFor(dirRel) {
+        if (this.configCache.has(dirRel))
+            return this.configCache.get(dirRel);
+        let result;
+        for (const name of ["tsconfig.json", "jsconfig.json"]) {
+            const rel = dirRel === "." ? name : `${dirRel}/${name}`;
+            if (existsSync(join(this.root, rel))) {
+                result = this.readPathsConfig(rel, 0);
+                break;
+            }
+        }
+        if (!result && dirRel !== "." && dirRel !== "") {
+            const parent = posix.dirname(dirRel);
+            result = this.pathsConfigFor(parent === dirRel ? "." : parent);
+        }
+        this.configCache.set(dirRel, result);
+        return result;
+    }
+    readPathsConfig(rel, depth) {
+        if (depth > 5)
+            return undefined;
+        let json;
+        try {
+            json =
+                ts.parseConfigFileTextToJson(rel, readFileSync(join(this.root, rel), "utf8")).config ?? {};
+        }
+        catch {
+            return undefined;
+        }
+        const dir = posix.dirname(rel);
+        let inherited;
+        for (const ext of [json.extends].flat()) {
+            if (typeof ext !== "string" || !ext.startsWith("."))
+                continue;
+            const target = posix.join(dir, ext.endsWith(".json") ? ext : `${ext}.json`);
+            inherited = this.readPathsConfig(target, depth + 1) ?? inherited;
+        }
+        const co = json.compilerOptions ?? {};
+        const baseUrl = co.baseUrl !== undefined
+            ? posix.join(dir, co.baseUrl)
+            : inherited?.baseUrl;
+        const paths = co.paths
+            ? Object.entries(co.paths).map(([k, v]) => [k, v])
+            : (inherited?.paths ?? []);
+        // paths without baseUrl resolve against the config that declares them
+        const pathsDir = co.paths ? dir : (inherited?.dir ?? dir);
+        if (!baseUrl && paths.length === 0)
+            return undefined;
+        return { dir: pathsDir, ...(baseUrl ? { baseUrl } : {}), paths };
+    }
+}
+function looksLikeAlias(specifier) {
+    return /^(@\/|~\/|#|\$)/.test(specifier) || specifier.startsWith("@/");
+}
+export function exportsTarget(exp, subpath) {
+    const conditions = [
+        "types",
+        "import",
+        "module",
+        "default",
+        "require",
+        "node",
+        "browser",
+    ];
+    const pick = (v, star) => {
+        if (typeof v === "string")
+            return star !== undefined ? v.replace(/\*/g, star) : v;
+        if (Array.isArray(v)) {
+            for (const x of v) {
+                const r = pick(x, star);
+                if (r)
+                    return r;
+            }
+            return undefined;
+        }
+        if (v && typeof v === "object") {
+            const o = v;
+            for (const c of conditions)
+                if (c in o) {
+                    const r = pick(o[c], star);
+                    if (r)
+                        return r;
+                }
+            for (const [k, x] of Object.entries(o))
+                if (!k.startsWith(".") && !conditions.includes(k)) {
+                    const r = pick(x, star);
+                    if (r)
+                        return r;
+                }
+        }
+        return undefined;
+    };
+    if (typeof exp === "string" || Array.isArray(exp))
+        return subpath === "." ? pick(exp) : undefined;
+    if (!exp || typeof exp !== "object")
+        return undefined;
+    const map = exp;
+    const keys = Object.keys(map);
+    if (!keys.some((k) => k.startsWith(".")))
+        return subpath === "." ? pick(map) : undefined;
+    if (subpath in map)
+        return pick(map[subpath]);
+    for (const k of keys) {
+        const star = k.indexOf("*");
+        if (star < 0)
+            continue;
+        const pre = k.slice(0, star);
+        const post = k.slice(star + 1);
+        if (subpath.startsWith(pre) && subpath.endsWith(post))
+            return pick(map[k], subpath.slice(pre.length, subpath.length - post.length));
+    }
+    return undefined;
+}

package/dist/usage/scan.d.ts

@@ -0,0 +1,4 @@
+import type { Ctx } from "../options.ts";
+import type { Inventory, UsageMap } from "../model.ts";
+export declare function scanUsage(ctx: Ctx | undefined, root: string, files: string[], inventory: Inventory, onFile?: (done: number, total: number) => void): Promise<UsageMap>;
+//# sourceMappingURL=scan.d.ts.map

package/dist/usage/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../src/usage/scan.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAA;AAKxC,OAAO,KAAK,EAAE,SAAS,EAAoB,QAAQ,EAAE,MAAM,aAAa,CAAA;AAGxE,wBAAsB,SAAS,CAC7B,GAAG,EAAE,GAAG,GAAG,SAAS,EACpB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EAAE,EACf,SAAS,EAAE,SAAS,EACpB,MAAM,GAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAe,GACvD,OAAO,CAAC,QAAQ,CAAC,CAoFnB"}

package/dist/usage/scan.js

@@ -0,0 +1,92 @@
+import { sha1 } from "../infra/hash.js";
+import { findOpaque } from "./opaque.js";
+import { counted, link } from "./link.js";
+import { LocalResolver } from "./resolve-local.js";
+import { isScannable, readSource, skippedByLocation } from "./files.js";
+import { parseSource, SCANNER_VERSION } from "./parse.js";
+export async function scanUsage(ctx, root, files, inventory, onFile = () => { }) {
+    const facts = new Map();
+    const skipped = [];
+    const total = files.filter((f) => isScannable(f) && !skippedByLocation(f)).length;
+    let done = 0;
+    for (const rel of files) {
+        if (skippedByLocation(rel)) {
+            skipped.push({
+                file: rel,
+                line: 1,
+                col: 1,
+                typeOnly: false,
+                text: "generated folder",
+            });
+            continue;
+        }
+        if (!isScannable(rel))
+            continue;
+        if (++done % 25 === 0 || done === total)
+            onFile(done, total);
+        let src;
+        try {
+            src = await readSource(root, rel);
+        }
+        catch {
+            continue;
+        }
+        if ("reason" in src) {
+            skipped.push({
+                file: rel,
+                line: 1,
+                col: 1,
+                typeOnly: false,
+                text: src.reason,
+            });
+            continue;
+        }
+        const key = `facts/v${SCANNER_VERSION}/${sha1(rel + "\0" + src.blocks.map((b) => b.text).join("\0"))}.json`;
+        const cached = ctx ? await ctx.cache.getJson(key) : undefined;
+        if (cached) {
+            facts.set(rel, cached.value);
+            continue;
+        }
+        const f = parseSource(src);
+        facts.set(rel, f);
+        if (ctx)
+            await ctx.cache.setJson(key, f, ctx.now);
+    }
+    const resolver = new LocalResolver(root, files, inventory);
+    const linked = await link({
+        root,
+        facts,
+        resolver,
+        inventory,
+        globalSkipped: skipped,
+    });
+    const opaque = await findOpaque(root, files, facts, inventory, resolver);
+    const packages = linked.packages;
+    for (const [id, kinds] of opaque) {
+        const dep = inventory.installed.find((d) => d.id === id);
+        const existing = packages[id];
+        const merged = new Map();
+        for (const o of existing?.opaque ?? [])
+            merged.set(o.kind, [
+                ...(linked.acc.get(id)?.opaque.get(o.kind) ?? o.examples),
+            ]);
+        for (const [k, sites] of kinds) {
+            // a package named in a config string but also imported by name is visible (a lint rule naming
+            // a package is not that package configured by string); one known only by the string is not
+            if (k === "config-reference" && (existing?.refs.length ?? 0) > 0)
+                continue;
+            merged.set(k, [...(merged.get(k) ?? []), ...sites]);
+        }
+        packages[id] = {
+            installedId: id,
+            pkg: existing?.pkg ?? dep?.name ?? id,
+            refs: existing?.refs ?? [],
+            strongNames: existing?.strongNames ?? [],
+            weakNames: existing?.weakNames ?? [],
+            files: existing?.files ?? 0,
+            blindSpots: existing?.blindSpots ?? [],
+            opaque: counted(merged),
+        };
+    }
+    return { scannedFiles: linked.scannedFiles, packages, global: linked.global };
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@dep-radius/core",
+  "version": "0.1.0",
+  "description": "The engine behind radius: which changes in a dependency update land on code you actually wrote.",
+  "license": "MIT",
+  "author": "prakticode",
+  "homepage": "https://github.com/prakticode/dep-radius#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/prakticode/dep-radius.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/prakticode/dep-radius/issues"
+  },
+  "keywords": [
+    "dependencies",
+    "upgrade",
+    "semver",
+    "changelog",
+    "release-notes",
+    "renovate",
+    "dependabot",
+    "breaking-changes",
+    "typescript",
+    "library",
+    "static-analysis"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./render": {
+      "types": "./dist/render/index.d.ts",
+      "default": "./dist/render/index.js"
+    },
+    "./debug": {
+      "types": "./dist/debug.d.ts",
+      "default": "./dist/debug.js"
+    },
+    "./schema/brief-v1.schema.json": "./schema/brief-v1.schema.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "schema"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22.12"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "semver": "^7.8.0",
+    "typescript": "~6.0.3"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "0.0.0",
+    "@repo/typescript-config": "0.0.0",
+    "@types/node": "^24.0.0",
+    "@types/semver": "^7.7.0",
+    "eslint": "^9.39.5",
+    "vitest": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint --max-warnings 0",
+    "lint:fix": "eslint --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "backtest": "node scripts/backtest.ts",
+    "clean": "rm -rf dist .turbo"
+  }
+}