knip 0.0.0-graph.0 → 0.0.0-graph.2

package/dist/ConfigurationChief.d.ts

@@ -38,6 +38,11 @@ export declare class ConfigurationChief {
     init(): Promise<void>;
     getCompilers(): [SyncCompilers, AsyncCompilers];
     getRules(): import("./types/issues.js").Rules;
+    getFilters(): {
+        dir: string;
+    } | {
+        dir?: undefined;
+    };
     private normalize;
     private setWorkspaces;
     private getListedWorkspaces;

package/dist/ConfigurationChief.js

@@ -103,6 +103,11 @@ export class ConfigurationChief {
     getRules() {
         return this.config.rules;
     }
+    getFilters() {
+        if (this.workspacesGraph?.graph && workspaceArg)
+            return { dir: join(this.cwd, workspaceArg) };
+        return {};
+    }
     normalize(rawLocalConfig) {
         const initialWorkspaces = rawLocalConfig.workspaces ?? {
             [ROOT_WORKSPACE_NAME]: {
@@ -239,23 +244,31 @@ export class ConfigurationChief {
             return ancestors;
         };
         const workspaceNames = workspaceArg
-            ? [
-                ...this.availableWorkspaceNames.reduce(getAncestors(workspaceArg), []),
-                ...this.availableWorkspaceNames.filter(name => name === workspaceArg),
-            ]
+            ? [...this.availableWorkspaceNames.reduce(getAncestors(workspaceArg), []), workspaceArg]
             : this.availableWorkspaceNames;
-        const graph = this.workspacesGraph;
-        function getDeps(dir) {
-            const node = graph?.graph[dir];
-            return [dir, ...(node?.dependencies ?? []), ...(node?.dependencies.flatMap(getDeps) ?? [])];
+        const graph = this.workspacesGraph?.graph;
+        const ws = new Set();
+        if (graph && workspaceArg) {
+            const seen = new Set();
+            const initialWorkspaces = new Set(workspaceNames.map(name => join(this.cwd, name)));
+            const workspaceDirsWithDependants = new Set(initialWorkspaces);
+            const addDependents = (dir) => {
+                seen.add(dir);
+                const deps = graph[dir]?.dependencies ?? [];
+                if (deps.length > 0 && Array.from(initialWorkspaces).some(dir => deps.includes(dir))) {
+                    workspaceDirsWithDependants.add(dir);
+                }
+                deps.filter(dir => !seen.has(dir)).forEach(addDependents);
+            };
+            this.availableWorkspaceNames.map(name => join(this.cwd, name)).forEach(addDependents);
+            workspaceDirsWithDependants.forEach(dir => ws.add(relative(this.cwd, dir) || ROOT_WORKSPACE_NAME));
         }
-        const workspaceNamesWithDependencies = workspaceArg
-            ? compact(workspaceNames
-                .map(name => join(this.cwd, name))
-                .flatMap(getDeps)
-                .map(dir => relative(this.cwd, dir)))
-            : workspaceNames;
-        return workspaceNamesWithDependencies.sort(byPathDepth).map((name) => {
+        else {
+            workspaceNames.forEach(name => ws.add(name));
+        }
+        return Array.from(ws)
+            .sort(byPathDepth)
+            .map((name) => {
             const dir = join(this.cwd, name);
             return {
                 name,

package/dist/IssueCollector.d.ts

@@ -1,16 +1,21 @@
 import type { ConfigurationHint, Issue, Rules } from './types/issues.js';
+type Filters = Partial<{
+    dir: string;
+}>;
 type IssueCollectorOptions = {
     cwd: string;
     rules: Rules;
+    filters: Filters;
 };
 export declare class IssueCollector {
     private cwd;
     private rules;
+    private filters;
     private issues;
     private counters;
     private referencedFiles;
     private configurationHints;
-    constructor({ cwd, rules }: IssueCollectorOptions);
+    constructor({ cwd, rules, filters }: IssueCollectorOptions);
     addFileCounts({ processed, unused }: {
         processed: number;
         unused: number;

package/dist/IssueCollector.js

@@ -7,13 +7,15 @@ function objectInSet(set, obj) {
 export class IssueCollector {
     cwd;
     rules;
+    filters;
     issues = initIssues();
     counters = initCounters();
     referencedFiles = new Set();
     configurationHints = new Set();
-    constructor({ cwd, rules }) {
+    constructor({ cwd, rules, filters }) {
         this.cwd = cwd;
         this.rules = rules;
+        this.filters = filters;
     }
     addFileCounts({ processed, unused }) {
         this.counters.processed += processed;
@@ -21,14 +23,18 @@ export class IssueCollector {
     }
     addFilesIssues(filePaths) {
         filePaths.forEach(filePath => {
-            if (!this.referencedFiles.has(filePath)) {
-                this.issues.files.add(filePath);
-                this.counters.files++;
-                this.counters.processed++;
-            }
+            if (this.filters.dir && !filePath.startsWith(this.filters.dir + '/'))
+                return;
+            if (this.referencedFiles.has(filePath))
+                return;
+            this.issues.files.add(filePath);
+            this.counters.files++;
+            this.counters.processed++;
         });
     }
     addIssue(issue) {
+        if (this.filters.dir && !issue.filePath.startsWith(this.filters.dir + '/'))
+            return;
         const key = relative(this.cwd, issue.filePath);
         issue.severity = this.rules[issue.type];
         this.issues[issue.type][key] = this.issues[issue.type][key] ?? {};

package/dist/index.js

@@ -28,13 +28,15 @@ export const main = async (unresolvedConfiguration) => {
     const workspaces = chief.getWorkspaces();
     const report = chief.getIssueTypesToReport();
     const rules = chief.getRules();
+    const filters = chief.getFilters();
     const isReportDependencies = report.dependencies || report.unlisted || report.unresolved;
     const isReportValues = report.exports || report.nsExports || report.classMembers;
     const isReportTypes = report.types || report.nsTypes || report.enumMembers;
-    const collector = new IssueCollector({ cwd, rules });
+    const collector = new IssueCollector({ cwd, rules, filters });
     const enabledPluginsStore = new Map();
     deputy.addIgnored(chief.config.ignoreBinaries, chief.config.ignoreDependencies);
-    debugLogObject('Included workspaces', workspaces);
+    debugLogObject('Included workspaces', workspaces.map(w => w.pkgName));
+    debugLogObject('Included workspace configs', workspaces.map(w => ({ name: w.name, pkgName: w.pkgName, config: w.config, ancestors: w.ancestors })));
     const handleReferencedDependency = ({ specifier, containingFilePath, principal, workspace, }) => {
         if (isInternal(specifier)) {
             const absSpecifier = toAbsolute(specifier, dirname(containingFilePath));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "0.0.0-graph.0",
+  "version": "0.0.0-graph.2",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",
@@ -44,6 +44,7 @@
   "dependencies": {
     "@ericcornelissen/bash-parser": "^0.5.2",
     "@npmcli/map-workspaces": "^3.0.4",
+    "@pnpm/logger": "5.0.0",
     "@pnpm/workspace.pkgs-graph": "2.0.6",
     "@snyk/github-codeowners": "^1.1.0",
     "chalk": "^5.2.0",