knip 0.0.0-graph.1 → 0.0.0-graph.3

package/dist/ConfigurationChief.d.ts

@@ -25,6 +25,7 @@ export declare class ConfigurationChief {
     manifestWorkspaces: Map<string, string>;
     additionalWorkspaceNames: Set<string>;
     availableWorkspaceNames: string[];
+    availableWorkspacePkgNames: Set<string | undefined>;
     availableWorkspaceDirs: string[];
     availableWorkspaceManifests: {
         dir: string;
@@ -32,12 +33,16 @@ export declare class ConfigurationChief {
     }[];
     workspacesGraph: ReturnType<typeof createPkgGraph> | undefined;
     enabledWorkspaces: Workspace[];
-    localWorkspaces: Set<string>;
     resolvedConfigFilePath?: string;
     constructor({ cwd, isProduction }: ConfigurationManagerOptions);
     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

@@ -6,7 +6,7 @@ import { ConfigurationValidator } from './ConfigurationValidator.js';
 import { ROOT_WORKSPACE_NAME, DEFAULT_EXTENSIONS, KNIP_CONFIG_LOCATIONS } from './constants.js';
 import { defaultRules } from './issues/initializers.js';
 import * as plugins from './plugins/index.js';
-import { arrayify, compact } from './util/array.js';
+import { arrayify } from './util/array.js';
 import parsedArgValues from './util/cli-arguments.js';
 import { partitionCompilers } from './util/compilers.js';
 import { ConfigurationError, LoaderError } from './util/errors.js';
@@ -58,11 +58,11 @@ export class ConfigurationChief {
     manifestWorkspaces = new Map();
     additionalWorkspaceNames = new Set();
     availableWorkspaceNames = [];
+    availableWorkspacePkgNames = new Set();
     availableWorkspaceDirs = [];
     availableWorkspaceManifests = [];
     workspacesGraph;
     enabledWorkspaces = [];
-    localWorkspaces = new Set();
     resolvedConfigFilePath;
     constructor({ cwd, isProduction }) {
         this.cwd = cwd;
@@ -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]: {
@@ -179,9 +184,9 @@ export class ConfigurationChief {
             .reverse()
             .map(dir => join(this.cwd, dir));
         this.availableWorkspaceManifests = this.getAvailableWorkspaceManifests(this.availableWorkspaceDirs);
+        this.availableWorkspacePkgNames = new Set(this.availableWorkspaceManifests.map(w => w.manifest.name));
         this.workspacesGraph = createPkgGraph(this.availableWorkspaceManifests);
         this.enabledWorkspaces = this.getEnabledWorkspaces();
-        this.localWorkspaces = new Set(compact(this.enabledWorkspaces.map(w => w.pkgName)));
     }
     getListedWorkspaces() {
         return this.manifest?.workspaces
@@ -245,14 +250,15 @@ export class ConfigurationChief {
         const ws = new Set();
         if (graph && workspaceArg) {
             const seen = new Set();
-            const workspaceDirsWithDependants = new Set(workspaceNames.map(name => join(this.cwd, name)));
+            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(workspaceDirsWithDependants).some(dir => deps.includes(dir))) {
+                if (deps.length > 0 && Array.from(initialWorkspaces).some(dir => deps.includes(dir))) {
                     workspaceDirsWithDependants.add(dir);
-                    deps.filter(dir => !seen.has(dir)).forEach(addDependents);
                 }
+                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));

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));
@@ -184,7 +186,7 @@ export const main = async (unresolvedConfiguration) => {
                     exportedSymbols.set(filePath, exported);
                 for (const [specifierFilePath, importItems] of internal.entries()) {
                     const packageName = getPackageNameFromModuleSpecifier(importItems.specifier);
-                    if (packageName && chief.localWorkspaces.has(packageName)) {
+                    if (packageName && chief.availableWorkspacePkgNames.has(packageName)) {
                         external.add(packageName);
                         if (_principal === principal) {
                             const workspace = chief.findWorkspaceByFilePath(specifierFilePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "0.0.0-graph.1",
+  "version": "0.0.0-graph.3",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",