@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.21

package/README.md

@@ -4,7 +4,7 @@
 
 deadset-ts finds dead code in TypeScript projects, down to class members, type members and dead stores inside functions, and writes a report your CI can fail on.
 
-It reads your `tsconfig.json` projects, `allowJs` JavaScript and Vue, Svelte and Astro scripts included, with the type information of TypeScript 7.1.0-dev.20261010.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
+It reads your `tsconfig.json` and `jsconfig.json` projects, a JavaScript package with neither, and Vue, Svelte and Astro scripts, with the type information of TypeScript 7.1.0-dev.20261014.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
 
 ## Why use it
 
@@ -116,3 +116,5 @@ This project was built with AI-assisted tooling using [Claude](https://claude.co
 ## License
 
 GPL-3.0-or-later. See [LICENSE](LICENSE).
+
+Third-party attributions are in [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,27 @@
+# Third-party notices
+
+deadset-ts includes source code from the following project.
+
+## unbash
+
+- Source: <https://github.com/webpro-nl/unbash>, release 6.0.0, commit `968c14992a43dc06ce29c9f51858abd4a87851ea`
+- Location: `src/vendor/unbash/` (see `VENDORED.md` there)
+- License: ISC
+
+```text
+ISC License
+
+Copyright (c) Lars Kappert
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+```

package/dist/bin/mapper-connection.js

@@ -7,6 +7,7 @@
  */
 import { componentModule } from "../src/component-files.js";
 import { extensionOf } from "../src/paths.js";
+import { PRODUCT } from "../src/product.js";
 /** The JSON-RPC code of a method this mapper does not serve. */
 const METHOD_NOT_FOUND = -32601;
 /** The JSON-RPC code of a request whose parameters are not the protocol's. */
@@ -37,7 +38,7 @@ function answer(message) {
     });
     switch (message.method) {
         case "initialize":
-            return reply({ positionEncoding: "utf-16", diagnosticSource: "deadset-ts" });
+            return reply({ positionEncoding: "utf-16", diagnosticSource: PRODUCT });
         case "openProject":
             return reply({});
         case "closeProject":

package/dist/bin/node-host.js

@@ -1,10 +1,11 @@
 import { randomBytes } from "node:crypto";
-import { closeSync, fchmodSync, fsyncSync, mkdtempSync, openSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeSync, } from "node:fs";
+import { closeSync, fchmodSync, fsyncSync, mkdtempSync, openSync, readdirSync, readFileSync, readSync, realpathSync, renameSync, rmSync, statSync, writeSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { PRODUCT } from "../src/product.js";
 /** The name the manifest of this package declares. */
-const PACKAGE_NAME = "@cplieger/deadset-ts";
+const PACKAGE_NAME = `@cplieger/${PRODUCT}`;
 /** The version the walk found, read once per process. */
 let found;
 /**
@@ -76,9 +77,24 @@ function writeAtomically(path, pieces) {
         throw error;
     }
 }
+/** The text of a file's first `limit` bytes, or of all of it where it holds fewer. */
+function readHead(path, limit) {
+    const bytes = Buffer.alloc(limit);
+    const fd = openSync(path, "r");
+    try {
+        let held = 0;
+        for (let got = -1; got !== 0 && held < limit; held += got) {
+            got = readSync(fd, bytes, held, limit - held, null);
+        }
+        return bytes.toString("utf8", 0, held);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 /** A new directory under the platform's temporary directory. */
 function temporaryDirectory() {
-    const path = mkdtempSync(join(tmpdir(), "deadset-ts-mapper-"));
+    const path = mkdtempSync(join(tmpdir(), `${PRODUCT}-mapper-`));
     return {
         path,
         remove: () => {
@@ -105,7 +121,7 @@ function componentMapperCommand() {
 export function nodeHost() {
     return {
         workingDirectory: () => process.cwd(),
-        readFile: (path) => readFileSync(path, "utf8"),
+        readFile: (path, limit) => limit === undefined ? readFileSync(path, "utf8") : readHead(path, limit),
         readDirectory: (path) => readdirSync(path, { withFileTypes: true }).map((entry) => ({
             name: entry.name,
             directory: entry.isDirectory(),
@@ -115,7 +131,10 @@ export function nodeHost() {
             if (stat === undefined) {
                 return "absent";
             }
-            return stat.isDirectory() ? "directory" : "file";
+            if (stat.isDirectory()) {
+                return "directory";
+            }
+            return stat.isFile() ? "file" : "other";
         },
         realPath: (path) => realpathSync(path),
         analyzerVersion: () => {

package/dist/src/alias-chain.js

@@ -1,12 +1,12 @@
 /**
  * Where an import or export chain leads in one project: from one symbol to each
  * declaration of the target it is, and along the chain of aliases it heads to each
- * declaration every link of that chain is.
+ * declaration every link of that chain is, and what a name resolves to through them.
  */
 import { isExportAssignment, isExportSpecifier, isIdentifier, isImportClause, isImportSpecifier, isNamespaceExport, isNamespaceImport, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { declarationsByName, isParameterProperty, nodeKey } from "./inventory.js";
-import { UNANSWERED } from "./query.js";
+import { isParameterProperty, nodeKey } from "./inventory.js";
+import { must, UNANSWERED } from "./query.js";
 /**
  * The chain walks over one project, against the declarations of `held`, the same
  * project's inventory.
@@ -19,7 +19,6 @@ export function aliasChains(project, held) {
     const ownFiles = project.ownPaths();
     const steps = new Map();
     const chains = new Map();
-    let asked = 0;
     const declarationsOf = (symbol) => {
         const ids = [];
         for (const handle of symbol.declarations) {
@@ -52,7 +51,6 @@ export function aliasChains(project, held) {
             return steps.get(symbol.id);
         }
         const next = project.aliasStepOf(symbol);
-        asked += 1;
         steps.set(symbol.id, next);
         return next;
     };
@@ -83,7 +81,7 @@ export function aliasChains(project, held) {
                 names.add(node.expression.text);
             }
         }
-        const byName = declarationsByName(held);
+        const byName = held.byName;
         const ids = [...names].flatMap((name) => byName.get(name) ?? []);
         return [...new Set([...ids, ...(module ? files : [])])].map((id) => ({
             id,
@@ -145,8 +143,36 @@ export function aliasChains(project, held) {
         declarationsOf,
         chainOf,
         nextDeclared,
-        get steps() {
-            return asked;
-        },
     };
 }
+/**
+ * What each of a batch of nodes resolves to, every alias followed to the declaration
+ * it stands for. A node the checker resolves to nothing, and an alias that resolves
+ * to nothing, are absent from the answer. Each alias is followed once. A question the
+ * checker does not answer stops the pass, as {@link must} stops.
+ */
+export function resolvedTargets(project, nodes) {
+    const followed = new Map();
+    const targets = new Map();
+    project
+        .symbolsAt(nodes.map((node) => project.handle(node)))
+        .map(must)
+        .forEach((symbol, index) => {
+        const node = nodes[index];
+        if (symbol === undefined || node === undefined) {
+            return;
+        }
+        let target = symbol;
+        if ((symbol.flags & SymbolFlags.Alias) !== 0) {
+            if (!followed.has(symbol.id)) {
+                const aliased = must(project.queries.aliased(symbol));
+                followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
+            }
+            target = followed.get(symbol.id);
+        }
+        if (target !== undefined) {
+            targets.set(node, target);
+        }
+    });
+    return targets;
+}

package/dist/src/amd.js

@@ -0,0 +1,81 @@
+/**
+ * AMD's module forms (references-ts.37), read from the syntax because the binder declares
+ * none of them: `define([<ids>], factory)`, `define("<name>", [<ids>], factory)` and
+ * `require([<ids>], callback)` (https://github.com/amdjs/amdjs-api/blob/master/AMD.md).
+ */
+import { isArrayLiteralExpression, isArrowFunction, isFunctionExpression, isCallExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/ast";
+import { hasURLScheme, isAbsolutePath, resolvePath, startsRelativePath } from "./paths.js";
+import { parenthesesRemoved } from "./unwrap.js";
+/** The ids AMD binds to the factory's CommonJS parameters, which load no module. */
+const FREE_VARIABLES = new Set(["require", "exports", "module"]);
+/** The platform function `callee` is written as. */
+export function amdPlatform(callee) {
+    return callee.text === "define" ? "define" : "require";
+}
+/**
+ * The dependency list one call writes, where it is a call of a bare `define` or `require` in
+ * one of AMD's forms. A `define` with no list, of a factory or a value alone, loads nothing;
+ * a `require` whose first argument is no array literal is CommonJS's.
+ */
+export function amdLoadOf(node) {
+    if (!isCallExpression(node)) {
+        return undefined;
+    }
+    const callee = parenthesesRemoved(node.expression);
+    if (!isIdentifier(callee) || (callee.text !== "define" && callee.text !== "require")) {
+        return undefined;
+    }
+    const written = node.arguments.map((one) => parenthesesRemoved(one));
+    const [first] = written;
+    if (first === undefined) {
+        return undefined;
+    }
+    const define = callee.text === "define";
+    const named = define && isLiteralText(first);
+    const list = written[named ? 1 : 0];
+    if (list !== undefined && isArrayLiteralExpression(list)) {
+        const elements = list.elements.map((one) => parenthesesRemoved(one));
+        const factory = written[named ? 2 : 1];
+        const ids = elements.flatMap((one, at) => isLiteralText(one) && !FREE_VARIABLES.has(one.text)
+            ? [{ id: one, received: receives(factory, at) }]
+            : []);
+        return { callee, ids, computed: elements.some((one) => !isLiteralText(one)) };
+    }
+    if (!define) {
+        return undefined;
+    }
+    // A factory after the list's place makes what stands there a list, here a computed one.
+    return { callee, ids: [], computed: written.length > (named ? 2 : 1) };
+}
+function isLiteralText(node) {
+    return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node);
+}
+/** Whether a factory may receive the dependency at place `at` of its list. */
+function receives(factory, at) {
+    if (factory === undefined) {
+        return false;
+    }
+    if (!isFunctionExpression(factory) && !isArrowFunction(factory)) {
+        return true;
+    }
+    const { parameters } = factory;
+    return at < parameters.length || parameters.some((one) => one.dotDotDotToken !== undefined);
+}
+/**
+ * The path a dependency id names against the calling file's directory: a relative module id,
+ * `./` or `../` with no `.js` ending, with `.js` appended. RequireJS reads any other id
+ * through its configuration or as a URL against the page, which the analysis does not know.
+ */
+export function amdPath(dir, id) {
+    return startsRelativePath(id) && !id.endsWith(".js") ? resolvePath(dir, `${id}.js`) : undefined;
+}
+/**
+ * Whether one call may load a file the analysis cannot name: a computed list, or an id that
+ * RequireJS reads as a URL, one ending in `.js`, starting with `/` or carrying a scheme. Any
+ * other id {@link amdPath} reads no path from is a package's.
+ */
+export function amdUnresolved(load) {
+    return (load.computed ||
+        load.ids.some(({ id }) => amdPath("/", id.text) === undefined &&
+            (id.text.endsWith(".js") || isAbsolutePath(id.text) || hasURLScheme(id.text))));
+}