knip 5.9.0 → 5.9.2

package/dist/ConfigurationChief.d.ts

@@ -1,5 +1,5 @@
 import { createPkgGraph } from '@pnpm/workspace.pkgs-graph';
-import type { Configuration, WorkspaceConfiguration, IgnorePatterns } from './types/config.js';
+import type { Configuration, IgnorePatterns, WorkspaceConfiguration } from './types/config.js';
 import type { PackageJson } from './types/package-json.js';
 type ConfigurationManagerOptions = {
     cwd: string;
@@ -41,7 +41,7 @@ export declare class ConfigurationChief {
     constructor({ cwd, isProduction, isStrict, isIncludeEntryExports }: ConfigurationManagerOptions);
     init(): Promise<void>;
     private loadResolvedConfigurationFile;
-    getRules(): import("#p/types/issues.ts").Rules;
+    getRules(): import("./types/issues.js").Rules;
     getFilters(): {
         dir: string;
     } | {
@@ -70,10 +70,8 @@ export declare class ConfigurationChief {
         ignoreDependencies: (string | RegExp)[];
     };
     getConfigForWorkspace(workspaceName: string, extensions?: string[]): {
-        astro?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        svelte?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
-        vue?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         moonrepo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        astro?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         angular?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         ava?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         babel?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -107,11 +105,13 @@ export declare class ConfigurationChief {
         storybook?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         stryker?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         stylelint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        svelte?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tailwind?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tsup?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         typedoc?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         typescript?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         unbuild?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        vue?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         vite?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         vitest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         webpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -134,7 +134,7 @@ export declare class ConfigurationChief {
         ignore: string[];
         isIncludeEntryExports: any;
     };
-    getIncludedIssueTypes(): import("#p/types/issues.ts").Report;
+    getIncludedIssueTypes(): import("./types/issues.js").Report;
     findWorkspaceByFilePath(filePath: string): Workspace | undefined;
     findWorkspaceByName(name: string): Workspace | undefined;
     getUnusedIgnoredWorkspaces(): string[];

package/dist/ConfigurationChief.js

@@ -2,9 +2,9 @@ import { existsSync } from 'node:fs';
 import mapWorkspaces from '@npmcli/map-workspaces';
 import { createPkgGraph } from '@pnpm/workspace.pkgs-graph';
 import micromatch from 'micromatch';
-import { partitionCompilers } from './compilers/index.js';
 import { ConfigurationValidator } from './ConfigurationValidator.js';
-import { ROOT_WORKSPACE_NAME, DEFAULT_EXTENSIONS, KNIP_CONFIG_LOCATIONS } from './constants.js';
+import { partitionCompilers } from './compilers/index.js';
+import { DEFAULT_EXTENSIONS, KNIP_CONFIG_LOCATIONS, ROOT_WORKSPACE_NAME } from './constants.js';
 import { defaultRules } from './issues/initializers.js';
 import * as plugins from './plugins/index.js';
 import { arrayify } from './util/array.js';
@@ -75,7 +75,7 @@ export class ConfigurationChief {
     async init() {
         const manifestPath = findFile(this.cwd, 'package.json');
         const manifest = manifestPath && (await loadJSON(manifestPath));
-        if (!manifestPath || !manifest) {
+        if (!(manifestPath && manifest)) {
             throw new ConfigurationError('Unable to find package.json');
         }
         this.manifestPath = manifestPath;
@@ -239,7 +239,7 @@ export class ConfigurationChief {
         const getAncestors = (name) => (ancestors, ancestorName) => {
             if (name === ancestorName)
                 return ancestors;
-            if (ancestorName === ROOT_WORKSPACE_NAME || name.startsWith(ancestorName + '/'))
+            if (ancestorName === ROOT_WORKSPACE_NAME || name.startsWith(`${ancestorName}/`))
                 ancestors.push(ancestorName);
             return ancestors;
         };
@@ -264,10 +264,12 @@ export class ConfigurationChief {
                 deps.filter(dir => !seen.has(dir)).forEach(addDependents);
             };
             this.availableWorkspaceNames.map(name => join(this.cwd, name)).forEach(addDependents);
-            workspaceDirsWithDependents.forEach(dir => ws.add(relative(this.cwd, dir) || ROOT_WORKSPACE_NAME));
+            for (const dir of workspaceDirsWithDependents)
+                ws.add(relative(this.cwd, dir) || ROOT_WORKSPACE_NAME);
         }
         else {
-            workspaceNames.forEach(name => ws.add(name));
+            for (const name of workspaceNames)
+                ws.add(name);
         }
         return Array.from(ws)
             .sort(byPathDepth)
@@ -296,7 +298,7 @@ export class ConfigurationChief {
     getDescendentWorkspaces(name) {
         return this.availableWorkspaceNames
             .filter(workspaceName => workspaceName !== name)
-            .filter(workspaceName => name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(name + '/'));
+            .filter(workspaceName => name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(`${name}/`));
     }
     getIgnoredWorkspacesFor(name) {
         return this.ignoredWorkspacePatterns
@@ -365,7 +367,7 @@ export class ConfigurationChief {
         return getIncludedIssueTypes(cliArgs, config);
     }
     findWorkspaceByFilePath(filePath) {
-        const workspaceDir = this.availableWorkspaceDirs.find(workspaceDir => filePath.startsWith(workspaceDir + '/'));
+        const workspaceDir = this.availableWorkspaceDirs.find(workspaceDir => filePath.startsWith(`${workspaceDir}/`));
         return this.includedWorkspaces.find(workspace => workspace.dir === workspaceDir);
     }
     findWorkspaceByName(name) {

package/dist/ConsoleStreamer.js

@@ -18,7 +18,7 @@ export class ConsoleStreamer {
     }
     update(messages) {
         this.resetLines();
-        process.stdout.write(messages.join('\n') + '\n');
+        process.stdout.write(`${messages.join('\n')}\n`);
         this.lines = messages.length;
     }
     cast(message) {

package/dist/DependencyDeputy.d.ts

@@ -1,7 +1,7 @@
 import type { Workspace } from './ConfigurationChief.js';
 import type { ConfigurationHints, Issue } from './types/issues.js';
 import type { PackageJson } from './types/package-json.js';
-import type { WorkspaceManifests, HostDependencies, InstalledBinaries, DependencySet, DependencyArray } from './types/workspace.js';
+import type { DependencyArray, DependencySet, HostDependencies, InstalledBinaries, WorkspaceManifests } from './types/workspace.js';
 type Options = {
     isProduction: boolean;
     isStrict: boolean;

package/dist/DependencyDeputy.js

@@ -1,8 +1,8 @@
 import { isBuiltin } from 'node:module';
-import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, IGNORED_RUNTIME_DEPENDENCIES, ROOT_WORKSPACE_NAME, } from './constants.js';
+import { IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, IGNORED_RUNTIME_DEPENDENCIES, IGNORE_DEFINITELY_TYPED, ROOT_WORKSPACE_NAME, } from './constants.js';
 import { getDependencyMetaData } from './manifest/index.js';
-import { isDefinitelyTyped, getDefinitelyTypedFor, getPackageFromDefinitelyTyped } from './util/modules.js';
-import { hasMatch, hasMatchInSet, toRegexOrString, findKey } from './util/regex.js';
+import { getDefinitelyTypedFor, getPackageFromDefinitelyTyped, isDefinitelyTyped } from './util/modules.js';
+import { findKey, hasMatch, hasMatchInSet, toRegexOrString } from './util/regex.js';
 export class DependencyDeputy {
     isProduction;
     isStrict;
@@ -141,9 +141,7 @@ export class DependencyDeputy {
             closestWorkspaceNameForTypes && this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
             return true;
         }
-        else {
-            this.addReferencedDependency(workspace.name, packageName);
-        }
+        this.addReferencedDependency(workspace.name, packageName);
         if (hasMatch(this.getWorkspaceManifest(workspace.name)?.ignoreDependencies, packageName))
             return true;
         if (hasMatch(this.ignoreDependencies, packageName))
@@ -160,7 +158,8 @@ export class DependencyDeputy {
             if (binaries?.has(binaryName)) {
                 const dependencies = binaries.get(binaryName);
                 if (dependencies?.size) {
-                    dependencies.forEach(dependency => this.addReferencedDependency(name, dependency));
+                    for (const dependency of dependencies)
+                        this.addReferencedDependency(name, dependency);
                     return true;
                 }
             }
@@ -226,7 +225,12 @@ export class DependencyDeputy {
                     return referencedDependencies.has(typedPackageName);
                 }
                 const hostDependencies = this.getHostDependenciesFor(workspaceName, dependency);
-                hostDependencies.forEach(({ name }) => (!peerDepRecs[name] ? (peerDepRecs[name] = 1) : peerDepRecs[name]++));
+                for (const { name } of hostDependencies) {
+                    if (!peerDepRecs[name])
+                        peerDepRecs[name] = 1;
+                    else
+                        peerDepRecs[name]++;
+                }
                 return hostDependencies.some(hostDependency => (isPeerDep === false || !hostDependency.isPeerOptional) && isReferencedDependency(hostDependency.name, true));
             };
             const isNotReferencedDependency = (dependency) => !isReferencedDependency(dependency, false);
@@ -259,28 +263,28 @@ export class DependencyDeputy {
             const installedBinaryNames = new Set(installedBinaries?.keys() ?? []);
             const ignoredBinaries = this._manifests.get(workspaceName)?.ignoreBinaries ?? [];
             const ignoredDependencies = this._manifests.get(workspaceName)?.ignoreDependencies ?? [];
-            referencedDependencies?.forEach(pkg => {
+            for (const pkg of referencedDependencies ?? []) {
                 for (const key of [...ignoredDependencies, ...rootIgnoreDependencies.keys()]) {
                     if ((typeof key === 'string' && key === pkg) || (key instanceof RegExp && key.test(pkg))) {
                         const rootKey = typeof key === 'string' ? key : findKey(rootIgnoreDependencies, key);
                         if (rootKey && rootIgnoreDependencies.has(rootKey)) {
                             rootIgnoreDependencies.set(rootKey, rootIgnoreDependencies.get(rootKey) + 1);
-                            return;
+                            break;
                         }
                     }
                 }
-            });
-            referencedBinaries?.forEach(binaryName => {
+            }
+            for (const binaryName of referencedBinaries ?? []) {
                 for (const key of [...ignoredBinaries, ...rootIgnoreBinaries.keys()]) {
                     if ((typeof key === 'string' && key === binaryName) || (key instanceof RegExp && key.test(binaryName))) {
                         const rootKey = typeof key === 'string' ? key : findKey(rootIgnoreBinaries, key);
                         if (rootKey && rootIgnoreBinaries.has(rootKey)) {
                             rootIgnoreBinaries.set(rootKey, rootIgnoreBinaries.get(rootKey) + 1);
-                            return;
+                            break;
                         }
                     }
                 }
-            });
+            }
             if (workspaceName === ROOT_WORKSPACE_NAME)
                 continue;
             const dependencies = this.getDependencies(workspaceName);
@@ -293,7 +297,7 @@ export class DependencyDeputy {
                     return true;
                 const isReferenced = hasMatchInSet(referencedDependencies, packageName);
                 const isListed = hasMatchInSet(dependencies, packageName) && !hasMatchInSet(peerDependencies, packageName);
-                return (isListed && isReferenced) || (!this.isProduction && !isReferenced && !isListed);
+                return (isListed && isReferenced) || !(this.isProduction || isReferenced || isListed);
             })
                 .forEach(identifier => {
                 configurationHints.add({ workspaceName, identifier, type: 'ignoreDependencies' });
@@ -306,7 +310,7 @@ export class DependencyDeputy {
                     return true;
                 const isReferenced = hasMatchInSet(referencedBinaries, binaryName);
                 const isInstalled = hasMatchInSet(installedBinaryNames, binaryName);
-                return (isReferenced && isInstalled) || (!this.isProduction && !isInstalled && !isReferenced);
+                return (isReferenced && isInstalled) || !(this.isProduction || isInstalled || isReferenced);
             })
                 .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreBinaries' }));
         }
@@ -319,7 +323,7 @@ export class DependencyDeputy {
                 return true;
             const isReferenced = rootIgnoreDependencies.get(packageName) !== 0;
             const isListed = hasMatchInSet(dependencies, packageName) && !hasMatchInSet(peerDependencies, packageName);
-            return (isReferenced && isListed) || (!this.isProduction && !isReferenced && !isListed);
+            return (isReferenced && isListed) || !(this.isProduction || isReferenced || isListed);
         })
             .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreDependencies' }));
         Array.from(rootIgnoreBinaries.keys())
@@ -328,7 +332,7 @@ export class DependencyDeputy {
                 return true;
             const isReferenced = rootIgnoreBinaries.get(binaryName) !== 0;
             const isInstalled = hasMatchInSet(installedBinaryNames, binaryName);
-            return (isReferenced && isInstalled) || (!this.isProduction && !isReferenced && !isInstalled);
+            return (isReferenced && isInstalled) || !(this.isProduction || isReferenced || isInstalled);
         })
             .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreBinaries' }));
         return { configurationHints };

package/dist/IssueCollector.js

@@ -1,5 +1,5 @@
 import micromatch from 'micromatch';
-import { initIssues, initCounters } from './issues/initializers.js';
+import { initCounters, initIssues } from './issues/initializers.js';
 import { relative } from './util/path.js';
 const hasHint = (hints, hint) => Array.from(hints).some(item => item.identifier === hint.identifier && item.type === hint.type && item.workspaceName === hint.workspaceName);
 export class IssueCollector {
@@ -19,7 +19,8 @@ export class IssueCollector {
         this.isMatch = () => false;
     }
     addIgnorePatterns(patterns) {
-        patterns.forEach(pattern => this.ignorePatterns.add(pattern));
+        for (const pattern of patterns)
+            this.ignorePatterns.add(pattern);
         const p = [...this.ignorePatterns];
         this.isMatch = (filePath) => micromatch.isMatch(filePath, p, { dot: true });
     }
@@ -28,20 +29,20 @@ export class IssueCollector {
         this.counters.total += processed + unused;
     }
     addFilesIssues(filePaths) {
-        filePaths.forEach(filePath => {
-            if (this.filters.dir && !filePath.startsWith(this.filters.dir + '/'))
-                return;
+        for (const filePath of filePaths) {
+            if (this.filters.dir && !filePath.startsWith(`${this.filters.dir}/`))
+                continue;
             if (this.referencedFiles.has(filePath))
-                return;
+                continue;
             if (this.isMatch(filePath))
-                return;
+                continue;
             this.issues.files.add(filePath);
             this.counters.files++;
             this.counters.processed++;
-        });
+        }
     }
     addIssue(issue) {
-        if (this.filters.dir && !issue.filePath.startsWith(this.filters.dir + '/'))
+        if (this.filters.dir && !issue.filePath.startsWith(`${this.filters.dir}/`))
             return;
         if (this.isMatch(issue.filePath))
             return;

package/dist/IssueFixer.js

@@ -1,4 +1,4 @@
-import { readFile, writeFile } from 'fs/promises';
+import { readFile, writeFile } from 'node:fs/promises';
 import NPMCliPackageJson, {} from '@npmcli/package-json';
 import { dirname, join } from './util/path.js';
 export class IssueFixer {
@@ -20,7 +20,8 @@ export class IssueFixer {
         if (!fixes || fixes.length === 0)
             return;
         if (this.unusedTypeNodes.has(filePath))
-            fixes.forEach(fix => this.unusedTypeNodes.get(filePath).add(fix));
+            for (const fix of fixes)
+                this.unusedTypeNodes.get(filePath)?.add(fix);
         else
             this.unusedTypeNodes.set(filePath, new Set(fixes));
     }
@@ -28,7 +29,8 @@ export class IssueFixer {
         if (!fixes || fixes.length === 0)
             return;
         if (this.unusedExportNodes.has(filePath))
-            fixes.forEach(fix => this.unusedExportNodes.get(filePath).add(fix));
+            for (const fix of fixes)
+                this.unusedExportNodes.get(filePath)?.add(fix);
         else
             this.unusedExportNodes.set(filePath, new Set(fixes));
     }
@@ -60,16 +62,16 @@ export class IssueFixer {
             const manifest = await NPMCliPackageJson.load(dirname(join(this.cwd, filePath)));
             const pkg = manifest.content;
             if (filePath in issues.dependencies) {
-                Object.keys(issues.dependencies[filePath]).forEach(dependency => {
+                for (const dependency of Object.keys(issues.dependencies[filePath])) {
                     if (pkg.dependencies)
                         delete pkg.dependencies[dependency];
-                });
+                }
             }
             if (filePath in issues.devDependencies) {
-                Object.keys(issues.devDependencies[filePath]).forEach(dependency => {
+                for (const dependency of Object.keys(issues.devDependencies[filePath])) {
                     if (pkg.devDependencies)
                         delete pkg.devDependencies[dependency];
-                });
+                }
             }
             await manifest.save();
         }

package/dist/PrincipalFactory.d.ts

@@ -1,6 +1,6 @@
-import ts from 'typescript';
+import type ts from 'typescript';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
-import type { SyncCompilers, AsyncCompilers } from './compilers/types.js';
+import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
 type Paths = ts.CompilerOptions['paths'];
 type Principal = {
     principal: ProjectPrincipal;

package/dist/PrincipalFactory.js

@@ -1,4 +1,3 @@
-import ts from 'typescript';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import { debugLog } from './util/debug.js';
 import { toAbsolute, toRelative } from './util/path.js';
@@ -24,9 +23,7 @@ export class PrincipalFactory {
             this.linkPrincipal(principal, cwd, compilerOptions, pkgName, compilers);
             return principal.principal;
         }
-        else {
-            return this.addNewPrincipal(options);
-        }
+        return this.addNewPrincipal(options);
     }
     findReusablePrincipal(compilerOptions) {
         const workspacePaths = compilerOptions?.paths ? Object.keys(compilerOptions.paths) : [];
@@ -44,7 +41,8 @@ export class PrincipalFactory {
         const { pathsBasePath, paths } = compilerOptions;
         if (pathsBasePath)
             principal.principal.compilerOptions.pathsBasePath = pathsBasePath;
-        Object.keys(paths ?? {}).forEach(p => principal.pathKeys.add(p));
+        for (const p of Object.keys(paths ?? {}))
+            principal.pathKeys.add(p);
         principal.principal.addPaths(paths);
         principal.principal.addCompilers(compilers);
         principal.cwds.add(cwd);

package/dist/ProjectPrincipal.d.ts

@@ -1,13 +1,13 @@
 import ts from 'typescript';
-import { type GetImportsAndExportsOptions } from './typescript/getImportsAndExports.js';
-import { createCustomModuleResolver } from './typescript/resolveModuleNames.js';
-import { SourceFileManager } from './typescript/SourceFileManager.js';
-import type { SyncCompilers, AsyncCompilers } from './compilers/types.js';
 import type { PrincipalOptions } from './PrincipalFactory.js';
+import type { ReferencedDependencies } from './WorkspaceWorker.js';
+import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
 import type { SerializableExport, SerializableExportMember } from './types/exports.js';
 import type { UnresolvedImport } from './types/imports.js';
 import type { ProgramMaybe53 } from './typescript/SourceFile.js';
-import type { ReferencedDependencies } from './WorkspaceWorker.js';
+import type { SourceFileManager } from './typescript/SourceFileManager.js';
+import { type GetImportsAndExportsOptions } from './typescript/getImportsAndExports.js';
+import type { createCustomModuleResolver } from './typescript/resolveModuleNames.js';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
     projectPaths: Set<string>;
@@ -55,7 +55,7 @@ export declare class ProjectPrincipal {
         };
         exports: {
             exported: import("./types/exports.js").SerializableExports;
-            duplicate: import("#p/types/issues.ts").IssueSymbol[][];
+            duplicate: import("./types/issues.js").IssueSymbol[][];
         };
         scripts: Set<string>;
     };

package/dist/ProjectPrincipal.js

@@ -3,12 +3,10 @@ import { getCompilerExtensions } from './compilers/index.js';
 import { DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS } from './constants.js';
 import { createHosts } from './typescript/createHosts.js';
 import { _getImportsAndExports } from './typescript/getImportsAndExports.js';
-import { createCustomModuleResolver } from './typescript/resolveModuleNames.js';
-import { SourceFileManager } from './typescript/SourceFileManager.js';
+import { timerify } from './util/Performance.js';
 import { compact } from './util/array.js';
 import { isStartsLikePackageName, sanitizeSpecifier } from './util/modules.js';
 import { dirname, extname, isInNodeModules, join } from './util/path.js';
-import { timerify } from './util/Performance.js';
 const baseCompilerOptions = {
     allowJs: true,
     allowSyntheticDefaultImports: true,
@@ -96,7 +94,8 @@ export class ProjectPrincipal {
         }
     }
     addEntryPaths(filePaths, options) {
-        filePaths.forEach(filePath => this.addEntryPath(filePath, options));
+        for (const filePath of filePaths)
+            this.addEntryPath(filePath, options);
     }
     addProjectPath(filePath) {
         if (!isInNodeModules(filePath) && this.hasAcceptedExtension(filePath)) {
@@ -104,7 +103,8 @@ export class ProjectPrincipal {
         }
     }
     addReferencedDependencies(workspaceName, referencedDependencies) {
-        referencedDependencies.forEach(referencedDependency => this.referencedDependencies.add([...referencedDependency, workspaceName]));
+        for (const referencedDependency of referencedDependencies)
+            this.referencedDependencies.add([...referencedDependency, workspaceName]);
     }
     async runAsyncCompilers() {
         const add = timerify(this.backend.fileManager.compileAndAddSourceFile.bind(this.backend.fileManager));
@@ -128,6 +128,8 @@ export class ProjectPrincipal {
         return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
     }
     analyzeSourceFile(filePath, options) {
+        if (!this.backend.typeChecker)
+            throw new Error('Must initialize TypeChecker before source file analysis');
         const sourceFile = this.backend.fileManager.getSourceFile(filePath);
         if (!sourceFile)
             throw new Error(`Unable to find ${filePath}`);
@@ -138,10 +140,10 @@ export class ProjectPrincipal {
         const { imports, exports, scripts } = _getImportsAndExports(sourceFile, getResolvedModule, this.backend.typeChecker, { ...options, skipExports });
         const { internal, unresolved, external } = imports;
         const unresolvedImports = new Set();
-        unresolved.forEach(unresolvedImport => {
+        for (const unresolvedImport of unresolved) {
             const { specifier } = unresolvedImport;
             if (specifier.startsWith('http')) {
-                return;
+                continue;
             }
             const resolvedModule = this.resolveModule(specifier, filePath);
             if (resolvedModule) {
@@ -171,7 +173,7 @@ export class ProjectPrincipal {
                     }
                 }
             }
-        });
+        }
         return {
             imports: {
                 internal,
@@ -193,7 +195,7 @@ export class ProjectPrincipal {
         return members.filter(member => {
             if (member.jsDocTags.includes('@public'))
                 return false;
-            const referencedSymbols = this.findReferences(filePath, member.pos);
+            const referencedSymbols = this.findReferences?.(filePath, member.pos);
             const files = (referencedSymbols ?? [])
                 .flatMap(refs => refs.references)
                 .filter(ref => !ref.isDefinition)
@@ -210,7 +212,7 @@ export class ProjectPrincipal {
             const languageService = ts.createLanguageService(this.backend.languageServiceHost, ts.createDocumentRegistry());
             this.findReferences = timerify(languageService.findReferences);
         }
-        const referencedSymbols = this.findReferences(filePath, exportedItem.pos);
+        const referencedSymbols = this.findReferences?.(filePath, exportedItem.pos);
         const files = (referencedSymbols ?? [])
             .flatMap(refs => refs.references)
             .filter(ref => !ref.isDefinition)

package/dist/WorkspaceWorker.d.ts

@@ -27,7 +27,7 @@ export declare class WorkspaceWorker {
     isStrict: boolean;
     rootIgnore: Configuration['ignore'];
     negatedWorkspacePatterns: string[];
-    enabledPluginsMap: Record<"astro" | "svelte" | "vue" | "moonrepo" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eleventy" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "linthtml" | "markdownlint" | "mocha" | "msw" | "netlify" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "tsup" | "typedoc" | "typescript" | "unbuild" | "vite" | "vitest" | "webpack" | "wireit" | "wrangler" | "yorkie" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease" | "vercelOg", boolean>;
+    enabledPluginsMap: Record<"moonrepo" | "astro" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eleventy" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "linthtml" | "markdownlint" | "mocha" | "msw" | "netlify" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "svelte" | "tailwind" | "tsup" | "typedoc" | "typescript" | "unbuild" | "vue" | "vite" | "vitest" | "webpack" | "wireit" | "wrangler" | "yorkie" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease" | "vercelOg", boolean>;
     enabledPlugins: PluginName[];
     enabledPluginsInAncestors: string[];
     constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }: WorkspaceManagerOptions);
@@ -46,7 +46,7 @@ export declare class WorkspaceWorker {
         entryFilePatterns: Set<string>;
         productionEntryFilePatterns: Set<string>;
         referencedDependencies: ReferencedDependencies;
-        enabledPlugins: ("astro" | "svelte" | "vue" | "moonrepo" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eleventy" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "linthtml" | "markdownlint" | "mocha" | "msw" | "netlify" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "tsup" | "typedoc" | "typescript" | "unbuild" | "vite" | "vitest" | "webpack" | "wireit" | "wrangler" | "yorkie" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease" | "vercelOg")[];
+        enabledPlugins: ("moonrepo" | "astro" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eleventy" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "linthtml" | "markdownlint" | "mocha" | "msw" | "netlify" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "svelte" | "tailwind" | "tsup" | "typedoc" | "typescript" | "unbuild" | "vue" | "vite" | "vitest" | "webpack" | "wireit" | "wrangler" | "yorkie" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease" | "vercelOg")[];
     }>;
 }
 export {};

package/dist/WorkspaceWorker.js

@@ -1,6 +1,6 @@
 import { plugins } from './plugins.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
-import { _pureGlob, negate, hasProductionSuffix, hasNoProductionSuffix, prependDirToPattern } from './util/glob.js';
+import { _pureGlob, hasNoProductionSuffix, hasProductionSuffix, negate, prependDirToPattern } from './util/glob.js';
 import { get, getKeysByValue } from './util/object.js';
 import { basename, dirname, join, toPosix } from './util/path.js';
 import { getFinalEntryPaths, loadConfigForPlugin } from './util/plugin.js';
@@ -120,7 +120,7 @@ export class WorkspaceWorker {
         if (project.length === 0)
             return this.getProductionEntryFilePatterns(negatedTestFilePatterns);
         const _project = this.config.project.map(pattern => {
-            if (!pattern.endsWith('!') && !pattern.startsWith('!'))
+            if (!(pattern.endsWith('!') || pattern.startsWith('!')))
                 return negate(pattern);
             return pattern;
         });
@@ -196,21 +196,25 @@ export class WorkspaceWorker {
                         const config = await loadConfigForPlugin(configFilePath, plugin, opts, pluginName);
                         if (config) {
                             if (hasResolveEntryPaths) {
-                                const dependencies = await plugin.resolveEntryPaths(config, opts);
-                                dependencies.forEach(id => configEntryPaths.push(id));
+                                const dependencies = (await plugin.resolveEntryPaths?.(config, opts)) ?? [];
+                                for (const id of dependencies)
+                                    configEntryPaths.push(id);
                             }
                             if (shouldRunConfigResolver) {
-                                const dependencies = await plugin.resolveConfig(config, opts);
-                                dependencies.forEach(id => addDependency(id, configFilePath));
+                                const dependencies = (await plugin.resolveConfig?.(config, opts)) ?? [];
+                                for (const id of dependencies)
+                                    addDependency(id, configFilePath);
                             }
                         }
                     }
                 }
                 const finalEntryPaths = getFinalEntryPaths(plugin, options, configEntryPaths);
-                finalEntryPaths.forEach(id => addDependency(id));
+                for (const id of finalEntryPaths)
+                    addDependency(id);
                 if (hasResolve) {
-                    const dependencies = await plugin.resolve(options);
-                    dependencies.forEach(id => addDependency(id, join(cwd, 'package.json')));
+                    const dependencies = (await plugin.resolve?.(options)) ?? [];
+                    for (const id of dependencies)
+                        addDependency(id, join(cwd, 'package.json'));
                 }
                 debugLogArray([name, plugin.title], 'dependencies', pluginDependencies);
             }

package/dist/binaries/index.js

@@ -1,8 +1,8 @@
 import { FOREIGN_FILE_EXTENSIONS } from '../constants.js';
+import { timerify } from '../util/Performance.js';
 import { compact } from '../util/array.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { extname, isInternal } from '../util/path.js';
-import { timerify } from '../util/Performance.js';
 import { fromBinary, isBinary } from '../util/protocols.js';
 import { getBinariesFromScript } from './bash-parser.js';
 const getDependenciesFromScripts = (npmScripts, options) => {

package/dist/binaries/resolvers/bun.js

@@ -1,6 +1,6 @@
 import parseArgs from 'minimist';
 import { tryResolveFilePath } from '../util.js';
-const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'update'];
+const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'test', 'update'];
 export const resolve = (_binary, args, { manifestScriptNames, cwd, fromArgs }) => {
     const parsed = parseArgs(args);
     const [command, script] = parsed._;

package/dist/binaries/resolvers/index.d.ts

@@ -1,15 +1,15 @@
 declare const _default: {
-    bun: import("#p/binaries/types.ts").Resolver;
-    c8: import("#p/binaries/types.ts").Resolver;
-    dotenv: import("#p/binaries/types.ts").Resolver;
-    node: import("#p/binaries/types.ts").Resolver;
-    nodemon: import("#p/binaries/types.ts").Resolver;
-    npx: import("#p/binaries/types.ts").Resolver;
-    nx: import("#p/binaries/types.ts").Resolver;
-    pnpm: import("#p/binaries/types.ts").Resolver;
-    rollup: import("#p/binaries/types.ts").Resolver;
-    'ts-node': import("#p/binaries/types.ts").Resolver;
-    tsx: import("#p/binaries/types.ts").Resolver;
-    yarn: import("#p/binaries/types.ts").Resolver;
+    bun: import("../types.js").Resolver;
+    c8: import("../types.js").Resolver;
+    dotenv: import("../types.js").Resolver;
+    node: import("../types.js").Resolver;
+    nodemon: import("../types.js").Resolver;
+    npx: import("../types.js").Resolver;
+    nx: import("../types.js").Resolver;
+    pnpm: import("../types.js").Resolver;
+    rollup: import("../types.js").Resolver;
+    'ts-node': import("../types.js").Resolver;
+    tsx: import("../types.js").Resolver;
+    yarn: import("../types.js").Resolver;
 };
 export default _default;

package/dist/binaries/util.js

@@ -10,7 +10,7 @@ export const tryResolveFilePath = (cwd, specifier, acceptModuleSpecifier) => {
             if (resolvedFilePath) {
                 return resolvedFilePath;
             }
-            else if (acceptModuleSpecifier) {
+            if (acceptModuleSpecifier) {
                 return getPackageNameFromModuleSpecifier(specifier);
             }
         }