@cplieger/deadset-ts 1.1.0 → 2.0.0

package/dist/src/session.js

@@ -0,0 +1,101 @@
+import { API } from "@typescript/native/unstable/sync";
+import { isIdentifier } from "@typescript/native/unstable/ast";
+/**
+ * Opens the compiler client the analysis reads through.
+ *
+ * Closing twice releases once: a run that fails before its snapshot opens closes
+ * the client where it failed, and the outer release runs whatever happened, so the
+ * second call has nothing left to do.
+ */
+export function openEngine(options) {
+    const api = new API({ collectTiming: options.collectTiming });
+    let closed = false;
+    return {
+        parseConfigFile: (file) => api.parseConfigFile(file),
+        updateSnapshot: (openProjects) => api.updateSnapshot({ openProjects: [...openProjects] }),
+        getTimingInfo: () => api.getTimingInfo(),
+        close: () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            api.close();
+        },
+    };
+}
+function viewOf(project) {
+    // The snapshot is never updated, so a project's own file set is the same answer
+    // every time it is asked for. It is read once because the question is not free:
+    // deciding it consults the metadata of every file the program holds, the compiler's
+    // own library files included, and a run asks for the set once per pass.
+    let ownFiles;
+    return {
+        configFile: project.configFileName,
+        program: project.program,
+        checker: project.checker,
+        ownSourceFiles: () => {
+            ownFiles ??= project.program
+                .getSourceFileNames()
+                // The metadata decides which files belong to the target, and it is read by
+                // name. Fetching each file first and filtering afterwards costs one round
+                // trip per library file the answer then discards, and a program holds far
+                // more library files than target files.
+                .filter((name) => {
+                const metadata = project.program.getSourceFileMetadata(name);
+                return (metadata !== undefined && !metadata.isDefaultLibrary && !metadata.isFromExternalLibrary);
+            })
+                .map((name) => project.program.getSourceFile(name))
+                .filter((file) => file !== undefined);
+            return ownFiles;
+        },
+        handle: (node) => ({ node }),
+        symbolsAt: (handles) => project.checker.getSymbolAtLocation(handles.map(({ node }) => node)),
+        resolvedSymbolAt: ({ node }) => isIdentifier(node) ? project.checker.getResolvedSymbol(node) : undefined,
+        shorthandValueAt: ({ node }) => project.checker.getShorthandAssignmentValueSymbol(node),
+        aliasStepOf: (symbol) => {
+            const held = project.checker.getImmediateAliasedSymbol(symbol);
+            // An alias that resolves to nothing answers with the checker's own unknown
+            // symbol, which declares nothing; a symbol that is no alias answers with
+            // nothing at all.
+            return held === undefined || held.declarations.length === 0 ? undefined : held;
+        },
+        declarationAt: (handle) => {
+            const node = handle.resolve(project);
+            return node === undefined ? undefined : { node };
+        },
+    };
+}
+/** The three diagnostic sets one project carries, read before any analysis. */
+export function diagnosticsOf(project) {
+    return {
+        configFile: project.configFile,
+        syntactic: project.program.getSyntacticDiagnostics(),
+        semantic: project.program.getSemanticDiagnostics(),
+        configParsing: project.program.getConfigFileParsingDiagnostics(),
+    };
+}
+/**
+ * Runs `visit` over every project the compiler configurations name, inside one
+ * snapshot of one client.
+ *
+ * The snapshot is opened once with every configuration, so each becomes a project
+ * with its own program and checker; it is never updated, because the analysis
+ * reads and the tree does not change under it. It is disposed once when the last
+ * project has been visited, and the client is released after it, whether the visit
+ * completed or threw.
+ */
+export function runSession(engine, configFiles, visit) {
+    try {
+        const snapshot = engine.updateSnapshot(configFiles);
+        try {
+            const projects = snapshot.getProjects().map((project) => visit(viewOf(project)));
+            return { projects, timing: engine.getTimingInfo() };
+        }
+        finally {
+            snapshot.dispose();
+        }
+    }
+    finally {
+        engine.close();
+    }
+}

package/dist/src/version.js

@@ -0,0 +1,7 @@
+/**
+ * The Contract version this analyzer implements. It is the resolved value of
+ * `contract_version` when no configuration source supplies one, and it moves
+ * independently of the analyzer's own version, which is the one the host answers
+ * from the package the analyzer was installed from.
+ */
+export const CONTRACT_VERSION = "1.7.0";

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,20 +1,25 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
   "license": "GPL-3.0-or-later",
   "bin": {
-    "deadset-ts": "./bin/deadset-ts.ts"
+    "deadset-ts": "./dist/bin/deadset-ts.js"
   },
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/src/index.js"
+    }
   },
   "engines": {
     "node": ">=24"
   },
   "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
     "typecheck": "tsc -p tsconfig.json",
     "typecheck:tests": "tsc -p tsconfig.test.json",
     "test": "vitest --run",
@@ -29,6 +34,7 @@
     "@eslint/js": "10.0.1",
     "@types/node": "24.13.5",
     "eslint": "10.10.0",
+    "fast-check": "4.10.1",
     "prettier": "3.9.7",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "typescript-eslint": "8.70.0",
@@ -57,7 +63,7 @@
   "files": [
     "LICENSE",
     "NOTICE",
-    "bin/",
+    "dist/",
     "src/",
     "!src/**/*.test.ts",
     "jsr.json"

package/src/host.ts

@@ -8,8 +8,9 @@ export interface DirectoryEntry {
 }
 
 /**
- * The filesystem the analysis reads, and the directory it reads relative paths
- * against.
+ * The platform one run reads: the filesystem, the directory relative paths
+ * resolve against, and the version of the package this analyzer was installed
+ * from.
  *
  * It is a parameter rather than an import because a published module that reads
  * the filesystem directly carries the whole platform's type surface into every
@@ -26,4 +27,11 @@ export interface Host {
   readDirectory(path: string): readonly DirectoryEntry[];
   /** What one path names, `"absent"` where nothing is there. */
   kindOf(path: string): PathKind;
+  /**
+   * The version of the package this analyzer was installed from, or a throw
+   * naming why it cannot be known. It is a method rather than a value because
+   * locating that package is a filesystem walk, and a host that cannot do it
+   * says so at the one moment the value is asked for.
+   */
+  analyzerVersion(): string;
 }

package/src/index.ts

@@ -1,3 +1,41 @@
 export { run, SETTING_OPTIONS, type Writer } from "./run.ts";
 export type { DirectoryEntry, Host, PathKind } from "./host.ts";
-export { CONTRACT_VERSION, version } from "./version.ts";
+export {
+  inventory,
+  nodeKey,
+  type Inventory,
+  type InventoryCost,
+  type InventorySymbol,
+  type SymbolKind,
+  type Visibility,
+} from "./inventory.ts";
+export {
+  DEFAULT_BATCH_CAP,
+  references,
+  type Reference,
+  type ReferenceCost,
+  type ReferenceOptions,
+  type References,
+  type Resolution,
+  type TestFileRule,
+  type Use,
+} from "./references.ts";
+export {
+  byPosition,
+  positionKey,
+  PositionError,
+  renderPosition,
+  type Position,
+} from "./position.ts";
+export {
+  computedComponent,
+  isRef,
+  nameComponent,
+  REF_EXPRESSIONS,
+  renderRef,
+  type Component,
+  type DependencySection,
+  type Fragment,
+  type Module,
+} from "./ref.ts";
+export { CONTRACT_VERSION } from "./version.ts";