knip 0.0.0-angular.0 → 0.0.0-graph.0

package/README.md

@@ -253,6 +253,7 @@ Knip contains a growing list of plugins:
 - [commitlint][plugin-commitlint]
 - [cspell][plugin-cspell]
 - [Cypress][plugin-cypress]
+- [Drizzle][plugin-drizzle]
 - [ESLint][plugin-eslint]
 - [Gatsby][plugin-gatsby]
 - [GitHub Actions][plugin-github-actions]
@@ -267,6 +268,7 @@ Knip contains a growing list of plugins:
 - [Nx][plugin-nx]
 - [nyc][plugin-nyc]
 - [Playwright][plugin-playwright]
+- [Playwright for components][plugin-playwright-ct]
 - [PostCSS][plugin-postcss]
 - [Prettier][plugin-prettier]
 - [Release It][plugin-release-it]
@@ -321,6 +323,21 @@ has them at `e2e-tests/*.spec.ts`. Here's how to configure this:
 }
 ```
 
+When overriding any plugin's configuration, the options object is fully replaced. Look at the plugin's page to find the
+default configuration and use that as a basis. Here's another example to override the test file pattern for Vitest:
+
+```json
+{
+  "vitest": {
+    "config": ["vitest.config.ts"],
+    "entry": ["**/*.vitest.ts"]
+  }
+}
+```
+
+This plugin configuration can be set on root and workspace level. If set on root level, it can be disabled on workspace
+level by setting it to `false` there.
+
 #### Multi-project repositories
 
 Some repositories have a single `package.json`, but consist of multiple projects with configuration files across the
@@ -663,6 +680,7 @@ Knip takes the following JSDoc/TSDoc tags into account:
       --include-entry-exports  Include entry files when reporting unused exports
       -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)
       --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated
+      --preprocessor-options   Pass extra options to the preprocessor (as JSON string, see --reporter-options example)
       --reporter               Select reporter: symbols, compact, codeowners, json, can be repeated (default: symbols)
       --reporter-options       Pass extra options to the reporter (as JSON string, see example)
       --no-config-hints        Suppress configuration hints
@@ -800,7 +818,7 @@ Special thanks to the wonderful people who have contributed to this project:
 [7]: #jsdoc-tags
 [8]: https://labs.openai.com/s/xZQACaLepaKya0PRUPtIN5dC
 [9]: ./assets/cow-with-orange-scissors-van-gogh-style.webp
-[10]: https://discord.gg/ya5yktTq
+[10]: https://discord.gg/r5uXTtbTpc
 [11]: https://twitter.com/webprolific
 [12]: https://fosstodon.org/@webpro
 [13]: https://github.com/webpro/knip/issues
@@ -873,6 +891,7 @@ Special thanks to the wonderful people who have contributed to this project:
 [plugin-commitlint]: ./src/plugins/commitlint
 [plugin-cspell]: ./src/plugins/cspell
 [plugin-cypress]: ./src/plugins/cypress
+[plugin-drizzle]: ./src/plugins/drizzle
 [plugin-eslint]: ./src/plugins/eslint
 [plugin-gatsby]: ./src/plugins/gatsby
 [plugin-github-actions]: ./src/plugins/github-actions
@@ -887,6 +906,7 @@ Special thanks to the wonderful people who have contributed to this project:
 [plugin-nx]: ./src/plugins/nx
 [plugin-nyc]: ./src/plugins/nyc
 [plugin-playwright]: ./src/plugins/playwright
+[plugin-playwright-ct]: ./src/plugins/playwright-ct
 [plugin-postcss]: ./src/plugins/postcss
 [plugin-prettier]: ./src/plugins/prettier
 [plugin-release-it]: ./src/plugins/release-it

package/dist/ConfigurationChief.d.ts

@@ -1,29 +1,36 @@
-/// <reference types="npmcli__package-json" />
+import { createPkgGraph } from '@pnpm/workspace.pkgs-graph';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
 import type { Configuration, WorkspaceConfiguration } from './types/config.js';
-import type { PackageJson } from '@npmcli/package-json';
+import type { PackageJsonWithPlugins } from './types/plugins.js';
 type ConfigurationManagerOptions = {
     cwd: string;
     isProduction: boolean;
 };
 export type Workspace = {
     name: string;
-    pkgName?: string;
+    pkgName: string;
     dir: string;
     ancestors: string[];
     config: WorkspaceConfiguration;
+    manifestPath: string;
+    manifest: PackageJsonWithPlugins;
 };
 export declare class ConfigurationChief {
     cwd: string;
     isProduction: boolean;
     config: Configuration;
     manifestPath?: string;
-    manifest?: PackageJson;
+    manifest?: PackageJsonWithPlugins;
     ignoredWorkspacePatterns: string[];
     manifestWorkspaces: Map<string, string>;
     additionalWorkspaceNames: Set<string>;
     availableWorkspaceNames: string[];
     availableWorkspaceDirs: string[];
+    availableWorkspaceManifests: {
+        dir: string;
+        manifest: PackageJsonWithPlugins;
+    }[];
+    workspacesGraph: ReturnType<typeof createPkgGraph> | undefined;
     enabledWorkspaces: Workspace[];
     localWorkspaces: Set<string>;
     resolvedConfigFilePath?: string;
@@ -38,6 +45,7 @@ export declare class ConfigurationChief {
     private getManifestWorkspaces;
     private getAdditionalWorkspaceNames;
     private getAvailableWorkspaceNames;
+    private getAvailableWorkspaceManifests;
     private getEnabledWorkspaces;
     getWorkspaces(): Workspace[];
     private getDescendentWorkspaces;

package/dist/ConfigurationChief.js

@@ -1,5 +1,6 @@
 import { existsSync } from 'node:fs';
 import mapWorkspaces from '@npmcli/map-workspaces';
+import { createPkgGraph } from '@pnpm/workspace.pkgs-graph';
 import micromatch from 'micromatch';
 import { ConfigurationValidator } from './ConfigurationValidator.js';
 import { ROOT_WORKSPACE_NAME, DEFAULT_EXTENSIONS, KNIP_CONFIG_LOCATIONS } from './constants.js';
@@ -8,14 +9,15 @@ import * as plugins from './plugins/index.js';
 import { arrayify, compact } from './util/array.js';
 import parsedArgValues from './util/cli-arguments.js';
 import { partitionCompilers } from './util/compilers.js';
-import { ConfigurationError } from './util/errors.js';
+import { ConfigurationError, LoaderError } from './util/errors.js';
 import { findFile, loadJSON } from './util/fs.js';
 import { getIncludedIssueTypes } from './util/get-included-issue-types.js';
 import { _dirGlob } from './util/glob.js';
 import { _load } from './util/loader.js';
 import { getKeysByValue } from './util/object.js';
 import { join, relative, toPosix } from './util/path.js';
-import { toCamelCase } from './util/plugin.js';
+import { normalizePluginConfig, toCamelCase } from './util/plugin.js';
+import { _require } from './util/require.js';
 import { byPathDepth } from './util/workspace.js';
 const { config: rawConfigArg, workspace: rawWorkspaceArg, include = [], exclude = [], dependencies = false, exports = false, } = parsedArgValues;
 const workspaceArg = rawWorkspaceArg ? toPosix(rawWorkspaceArg).replace(/^\.\//, '').replace(/\/$/, '') : undefined;
@@ -57,6 +59,8 @@ export class ConfigurationChief {
     additionalWorkspaceNames = new Set();
     availableWorkspaceNames = [];
     availableWorkspaceDirs = [];
+    availableWorkspaceManifests = [];
+    workspacesGraph;
     enabledWorkspaces = [];
     localWorkspaces = new Set();
     resolvedConfigFilePath;
@@ -116,6 +120,13 @@ export class ConfigurationChief {
         const { syncCompilers, asyncCompilers } = rawLocalConfig;
         const extensions = [...Object.keys(syncCompilers ?? {}), ...Object.keys(asyncCompilers ?? {})];
         const defaultWorkspaceConfig = getDefaultWorkspaceConfig(extensions);
+        const rootPluginConfigs = {};
+        for (const [name, pluginConfig] of Object.entries(rawLocalConfig)) {
+            const pluginName = toCamelCase(name);
+            if (PLUGIN_NAMES.includes(pluginName)) {
+                rootPluginConfigs[pluginName] = normalizePluginConfig(pluginConfig);
+            }
+        }
         const workspaces = Object.entries(initialWorkspaces)
             .filter(([workspaceName]) => !ignoreWorkspaces.includes(workspaceName))
             .reduce((workspaces, workspace) => {
@@ -131,23 +142,15 @@ export class ConfigurationChief {
                 ignoreBinaries: arrayify(workspaceConfig.ignoreBinaries),
                 ignoreDependencies: arrayify(workspaceConfig.ignoreDependencies),
             };
+            for (const [name, pluginConfig] of Object.entries(rootPluginConfigs)) {
+                const pluginName = toCamelCase(name);
+                if (pluginConfig)
+                    workspaces[workspaceName][pluginName] = pluginConfig;
+            }
             for (const [name, pluginConfig] of Object.entries(workspaceConfig)) {
                 const pluginName = toCamelCase(name);
                 if (PLUGIN_NAMES.includes(pluginName)) {
-                    if (pluginConfig === false) {
-                        workspaces[workspaceName][pluginName] = false;
-                    }
-                    else {
-                        const isObject = typeof pluginConfig !== 'string' && !Array.isArray(pluginConfig);
-                        const config = isObject ? arrayify(pluginConfig.config) : pluginConfig ? arrayify(pluginConfig) : null;
-                        const entry = isObject && 'entry' in pluginConfig ? arrayify(pluginConfig.entry) : null;
-                        const project = isObject && 'project' in pluginConfig ? arrayify(pluginConfig.project) : entry;
-                        workspaces[workspaceName][pluginName] = {
-                            config,
-                            entry,
-                            project,
-                        };
-                    }
+                    workspaces[workspaceName][pluginName] = normalizePluginConfig(pluginConfig);
                 }
             }
             return workspaces;
@@ -175,6 +178,8 @@ export class ConfigurationChief {
             .sort(byPathDepth)
             .reverse()
             .map(dir => join(this.cwd, dir));
+        this.availableWorkspaceManifests = this.getAvailableWorkspaceManifests(this.availableWorkspaceDirs);
+        this.workspacesGraph = createPkgGraph(this.availableWorkspaceManifests);
         this.enabledWorkspaces = this.getEnabledWorkspaces();
         this.localWorkspaces = new Set(compact(this.enabledWorkspaces.map(w => w.pkgName)));
     }
@@ -214,6 +219,14 @@ export class ConfigurationChief {
     getAvailableWorkspaceNames() {
         return [ROOT_WORKSPACE_NAME, ...this.manifestWorkspaces.keys(), ...this.additionalWorkspaceNames].filter(name => !micromatch.isMatch(name, this.ignoredWorkspacePatterns));
     }
+    getAvailableWorkspaceManifests(availableWorkspaceDirs) {
+        return availableWorkspaceDirs.map(dir => {
+            const manifest = _require(join(dir, 'package.json'));
+            if (!manifest)
+                throw new LoaderError(`Unable to load package.json for ${dir}`);
+            return { dir, manifest };
+        });
+    }
     getEnabledWorkspaces() {
         if (workspaceArg && !existsSync(workspaceArg)) {
             throw new ConfigurationError(`Directory does not exist: ${workspaceArg}`);
@@ -231,13 +244,29 @@ export class ConfigurationChief {
                 ...this.availableWorkspaceNames.filter(name => name === workspaceArg),
             ]
             : this.availableWorkspaceNames;
-        return workspaceNames.sort(byPathDepth).map((name) => ({
-            name,
-            pkgName: this.manifestWorkspaces.get(name) ?? this.manifest?.name,
-            dir: join(this.cwd, name),
-            config: this.getConfigForWorkspace(name),
-            ancestors: this.availableWorkspaceNames.reduce(getAncestors(name), []),
-        }));
+        const graph = this.workspacesGraph;
+        function getDeps(dir) {
+            const node = graph?.graph[dir];
+            return [dir, ...(node?.dependencies ?? []), ...(node?.dependencies.flatMap(getDeps) ?? [])];
+        }
+        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) => {
+            const dir = join(this.cwd, name);
+            return {
+                name,
+                pkgName: this.manifestWorkspaces.get(name) ?? this.manifest?.name ?? `NOT_FOUND_${name}`,
+                dir,
+                config: this.getConfigForWorkspace(name),
+                ancestors: this.availableWorkspaceNames.reduce(getAncestors(name), []),
+                manifestPath: join(dir, 'package.json'),
+                manifest: this.availableWorkspaceManifests?.find(item => item.dir === dir)?.manifest ?? {},
+            };
+        });
     }
     getWorkspaces() {
         return this.enabledWorkspaces;

package/dist/ConfigurationValidator.d.ts

@@ -1,4 +1,17 @@
 import { z } from 'zod';
+export declare const pluginSchema: z.ZodUnion<[z.ZodLiteral<false>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+    config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+}, "strip", z.ZodTypeAny, {
+    config?: string | string[] | undefined;
+    entry?: string | string[] | undefined;
+    project?: string | string[] | undefined;
+}, {
+    config?: string | string[] | undefined;
+    entry?: string | string[] | undefined;
+    project?: string | string[] | undefined;
+}>]>;
 export declare const ConfigurationValidator: z.ZodObject<{
     exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     rules: z.ZodOptional<z.ZodRecord<z.ZodUnion<[z.ZodLiteral<"files">, z.ZodLiteral<"dependencies">, z.ZodLiteral<"devDependencies">, z.ZodLiteral<"unlisted">, z.ZodLiteral<"binaries">, z.ZodLiteral<"unresolved">, z.ZodLiteral<"exports">, z.ZodLiteral<"types">, z.ZodLiteral<"nsExports">, z.ZodLiteral<"nsTypes">, z.ZodLiteral<"duplicates">, z.ZodLiteral<"enumMembers">, z.ZodLiteral<"classMembers">]>, z.ZodEnum<["error", "warn", "off"]>>>;

package/dist/ConfigurationValidator.js

@@ -50,7 +50,7 @@ const reportConfigSchema = z.object({
     include: z.array(z.string()).optional(),
     exclude: z.array(z.string()).optional(),
 });
-const pluginSchema = z.union([
+export const pluginSchema = z.union([
     z.literal(false),
     globSchema,
     z.object({

package/dist/DependencyDeputy.d.ts

@@ -1,8 +1,7 @@
 /// <reference types="npmcli__package-json" />
 import type { Workspace } from './ConfigurationChief.js';
 import type { ConfigurationHints, Issue } from './types/issues.js';
-import type { WorkspaceManifests } from './types/workspace.js';
-import type { PeerDependencies, InstalledBinaries } from './types/workspace.js';
+import type { WorkspaceManifests, HostDependencies, InstalledBinaries } from './types/workspace.js';
 import type { PackageJson } from '@npmcli/package-json';
 type Options = {
     isStrict: boolean;
@@ -12,8 +11,9 @@ export declare class DependencyDeputy {
     _manifests: WorkspaceManifests;
     referencedDependencies: Map<string, Set<string>>;
     referencedBinaries: Map<string, Set<string>>;
-    peerDependencies: Map<string, PeerDependencies>;
+    hostDependencies: Map<string, HostDependencies>;
     installedBinaries: Map<string, InstalledBinaries>;
+    hasTypesIncluded: Map<string, Set<string>>;
     ignoreBinaries: string[];
     ignoreDependencies: string[];
     constructor({ isStrict }: Options);
@@ -43,10 +43,12 @@ export declare class DependencyDeputy {
     getDevDependencies(workspaceName: string): string[];
     setInstalledBinaries(workspaceName: string, installedBinaries: Map<string, Set<string>>): void;
     getInstalledBinaries(workspaceName: string): InstalledBinaries | undefined;
+    setHasTypesIncluded(workspaceName: string, hasTypesIncluded: Set<string>): void;
+    getHasTypesIncluded(workspaceName: string): InstalledBinaries | undefined;
     addReferencedDependency(workspaceName: string, packageName: string): void;
     addReferencedBinary(workspaceName: string, binaryName: string): void;
-    addPeerDependencies(workspaceName: string, peerDependencies: Map<string, Set<string>>): void;
-    getPeerDependenciesOf(workspaceName: string, dependency: string): string[];
+    addHostDependencies(workspaceName: string, hostDependencies: HostDependencies): void;
+    getHostDependenciesFor(workspaceName: string, dependency: string): string[];
     getPeerDependencies(workspaceName: string): string[];
     getOptionalPeerDependencies(workspaceName: string): string[];
     maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string): boolean;

package/dist/DependencyDeputy.js

@@ -6,16 +6,18 @@ export class DependencyDeputy {
     _manifests = new Map();
     referencedDependencies;
     referencedBinaries;
-    peerDependencies;
+    hostDependencies;
     installedBinaries;
+    hasTypesIncluded;
     ignoreBinaries = [];
     ignoreDependencies = [];
     constructor({ isStrict }) {
         this.isStrict = isStrict;
         this.referencedDependencies = new Map();
         this.referencedBinaries = new Map();
-        this.peerDependencies = new Map();
+        this.hostDependencies = new Map();
         this.installedBinaries = new Map();
+        this.hasTypesIncluded = new Map();
     }
     addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries, }) {
         const scripts = Object.values(manifest.scripts ?? {});
@@ -67,6 +69,12 @@ export class DependencyDeputy {
     getInstalledBinaries(workspaceName) {
         return this.installedBinaries.get(workspaceName);
     }
+    setHasTypesIncluded(workspaceName, hasTypesIncluded) {
+        this.hasTypesIncluded.set(workspaceName, hasTypesIncluded);
+    }
+    getHasTypesIncluded(workspaceName) {
+        return this.installedBinaries.get(workspaceName);
+    }
     addReferencedDependency(workspaceName, packageName) {
         if (!this.referencedDependencies.has(workspaceName)) {
             this.referencedDependencies.set(workspaceName, new Set());
@@ -79,11 +87,11 @@ export class DependencyDeputy {
         }
         this.referencedBinaries.get(workspaceName)?.add(binaryName);
     }
-    addPeerDependencies(workspaceName, peerDependencies) {
-        this.peerDependencies.set(workspaceName, peerDependencies);
+    addHostDependencies(workspaceName, hostDependencies) {
+        this.hostDependencies.set(workspaceName, hostDependencies);
     }
-    getPeerDependenciesOf(workspaceName, dependency) {
-        return Array.from(this.peerDependencies.get(workspaceName)?.get(dependency) ?? []);
+    getHostDependenciesFor(workspaceName, dependency) {
+        return Array.from(this.hostDependencies.get(workspaceName)?.get(dependency) ?? []);
     }
     getPeerDependencies(workspaceName) {
         const manifest = this._manifests.get(workspaceName);
@@ -155,6 +163,7 @@ export class DependencyDeputy {
         for (const [workspaceName, { manifestPath, ignoreDependencies, ignoreBinaries }] of this._manifests.entries()) {
             const referencedDependencies = this.referencedDependencies.get(workspaceName);
             const installedBinaries = this.getInstalledBinaries(workspaceName);
+            const hasTypesIncluded = this.getHasTypesIncluded(workspaceName);
             const ignoreBins = [...IGNORED_GLOBAL_BINARIES, ...this.ignoreBinaries, ...ignoreBinaries];
             const ignoreDeps = [...IGNORED_DEPENDENCIES, ...this.ignoreDependencies, ...ignoreDependencies];
             const isNotIgnoredDependency = (packageName) => !ignoreDeps.includes(packageName);
@@ -176,20 +185,24 @@ export class DependencyDeputy {
                     return false;
                 const [scope, typedDependency] = dependency.split('/');
                 if (scope === '@types') {
+                    if (hasTypesIncluded?.has(typedDependency))
+                        return false;
                     const typedPackageName = getPackageFromDefinitelyTyped(typedDependency);
                     if (IGNORE_DEFINITELY_TYPED.includes(typedPackageName))
                         return true;
-                    const peerDependencies = this.getPeerDependenciesOf(workspaceName, typedPackageName);
-                    if (peerDependencies.length) {
-                        return !!peerDependencies.find(peerDependency => isReferencedDependency(peerDependency, true));
-                    }
+                    const hostDependencies = [
+                        ...this.getHostDependenciesFor(workspaceName, dependency),
+                        ...this.getHostDependenciesFor(workspaceName, typedPackageName),
+                    ];
+                    if (hostDependencies.length)
+                        return !!hostDependencies.find(host => isReferencedDependency(host, true));
                     if (!referencedDependencies)
                         return false;
                     return referencedDependencies.has(typedPackageName);
                 }
-                const peerDependenciesOf = this.getPeerDependenciesOf(workspaceName, dependency);
-                peerDependenciesOf.forEach(dep => (!peerDepRecs[dep] ? (peerDepRecs[dep] = 1) : peerDepRecs[dep]++));
-                return peerDependenciesOf.some(peerDependency => isReferencedDependency(peerDependency, true));
+                const hostDependencies = this.getHostDependenciesFor(workspaceName, dependency);
+                hostDependencies.forEach(dep => (!peerDepRecs[dep] ? (peerDepRecs[dep] = 1) : peerDepRecs[dep]++));
+                return hostDependencies.some(peerDependency => isReferencedDependency(peerDependency, true));
             };
             const isNotReferencedDependency = (dependency) => !isReferencedDependency(dependency);
             const pd = this.getProductionDependencies(workspaceName);

package/dist/PrincipalFactory.d.ts

@@ -6,6 +6,7 @@ type Principal = {
     principal: ProjectPrincipal;
     cwds: Set<string>;
     pathKeys: Set<string>;
+    pkgNames: Set<string>;
 };
 type Principals = Set<Principal>;
 type Options = {
@@ -13,6 +14,7 @@ type Options = {
     compilerOptions: ts.CompilerOptions;
     paths: Paths;
     compilers: [SyncCompilers, AsyncCompilers];
+    pkgName: string;
 };
 export declare class PrincipalFactory {
     principals: Principals;
@@ -21,5 +23,6 @@ export declare class PrincipalFactory {
     private linkPrincipal;
     private addNewPrincipal;
     getPrincipals(): ProjectPrincipal[];
+    getPrincipalByPackageName(packageName: string): ProjectPrincipal | undefined;
 }
 export {};

package/dist/PrincipalFactory.js

@@ -12,11 +12,11 @@ const mergePaths = (cwd, compilerOptions, paths = {}) => {
 export class PrincipalFactory {
     principals = new Set();
     getPrincipal(options) {
-        const { cwd, compilerOptions, paths } = options;
+        const { cwd, compilerOptions, paths, pkgName } = options;
         options.compilerOptions = mergePaths(cwd, compilerOptions, paths);
         const principal = this.findReusablePrincipal(compilerOptions);
         if (principal) {
-            this.linkPrincipal(principal, cwd, compilerOptions);
+            this.linkPrincipal(principal, cwd, compilerOptions, pkgName);
             return principal.principal;
         }
         else {
@@ -35,22 +35,26 @@ export class PrincipalFactory {
         });
         return principal;
     }
-    linkPrincipal(principal, cwd, compilerOptions) {
+    linkPrincipal(principal, cwd, compilerOptions, pkgName) {
         const { pathsBasePath, paths } = compilerOptions;
         if (pathsBasePath)
             principal.principal.compilerOptions.pathsBasePath = pathsBasePath;
         Object.keys(paths ?? {}).forEach(p => principal.pathKeys.add(p));
         principal.principal.compilerOptions.paths = { ...principal.principal.compilerOptions.paths, ...paths };
         principal.cwds.add(cwd);
+        principal.pkgNames.add(pkgName);
     }
     addNewPrincipal(options) {
-        const { cwd, compilerOptions } = options;
+        const { cwd, compilerOptions, pkgName } = options;
         const pathKeys = new Set(Object.keys(compilerOptions?.paths ?? {}));
         const principal = new ProjectPrincipal(options);
-        this.principals.add({ principal, cwds: new Set([cwd]), pathKeys });
+        this.principals.add({ principal, cwds: new Set([cwd]), pathKeys, pkgNames: new Set([pkgName]) });
         return principal;
     }
     getPrincipals() {
-        return Array.from(this.principals).map(p => p.principal);
+        return Array.from(this.principals, p => p.principal).reverse();
+    }
+    getPrincipalByPackageName(packageName) {
+        return Array.from(this.principals).find(principal => principal.pkgNames.has(packageName))?.principal;
     }
 }

package/dist/ProjectPrincipal.js

@@ -6,7 +6,7 @@ import { getJSDocTags, isInModuleBlock } from './typescript/ast-helpers.js';
 import { createHosts } from './typescript/createHosts.js';
 import { getImportsAndExports } from './typescript/getImportsAndExports.js';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
-import { isMaybePackageName } from './util/modules.js';
+import { isMaybePackageName, sanitizeSpecifier } from './util/modules.js';
 import { dirname, extname, isInNodeModules, join } from './util/path.js';
 import { timerify } from './util/Performance.js';
 const baseCompilerOptions = {
@@ -107,7 +107,7 @@ export class ProjectPrincipal {
         return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
     }
     analyzeSourceFile(filePath, { skipTypeOnly }) {
-        const sourceFile = this.backend.program?.getSourceFile(filePath);
+        const sourceFile = this.backend.fileManager.getSourceFile(filePath);
         if (!sourceFile)
             throw new Error(`Unable to find ${filePath}`);
         const skipExports = this.skipExportsAnalysis.has(filePath);
@@ -128,7 +128,7 @@ export class ProjectPrincipal {
                 }
             }
             else {
-                const sanitizedSpecifier = specifier.replace(/^([?!|-]+)?([^!?]+).*/, '$2');
+                const sanitizedSpecifier = sanitizeSpecifier(specifier);
                 if (isMaybePackageName(sanitizedSpecifier)) {
                     external.add(sanitizedSpecifier);
                 }
@@ -178,7 +178,7 @@ export class ProjectPrincipal {
     findUnusedMembers(filePath, members) {
         return members
             .filter(member => {
-            if (getJSDocTags(member.node).includes('@public'))
+            if (getJSDocTags(member.node).has('@public'))
                 return false;
             const referencedSymbols = this.findReferences(filePath, member.pos);
             const files = referencedSymbols
@@ -192,6 +192,11 @@ export class ProjectPrincipal {
             .map(member => member.identifier);
     }
     findReferences(filePath, pos) {
-        return this.backend.lsFindReferences(filePath, pos) ?? [];
+        try {
+            return this.backend.lsFindReferences(filePath, pos) ?? [];
+        }
+        catch {
+            return [];
+        }
     }
 }

package/dist/WorkspaceWorker.d.ts

@@ -1,6 +1,6 @@
 import type { Configuration, PluginName, WorkspaceConfiguration } from './types/config.js';
 import type { PackageJsonWithPlugins } from './types/plugins.js';
-import type { InstalledBinaries, PeerDependencies } from './types/workspace.js';
+import type { InstalledBinaries, HostDependencies } from './types/workspace.js';
 type WorkspaceManagerOptions = {
     name: string;
     dir: string;
@@ -28,8 +28,9 @@ export declare class WorkspaceWorker {
     enabled: Record<PluginName, boolean>;
     enabledPlugins: PluginName[];
     referencedDependencies: ReferencedDependencies;
-    peerDependencies: PeerDependencies;
+    hostDependencies: HostDependencies;
     installedBinaries: InstalledBinaries;
+    hasTypesIncluded: Set<string>;
     constructor({ name, dir, cwd, config, manifest, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private setEnabledPlugins;
@@ -47,10 +48,11 @@ export declare class WorkspaceWorker {
     getIgnorePatterns(): string[];
     private findDependenciesByPlugins;
     findAllDependencies(): Promise<{
-        peerDependencies: PeerDependencies;
+        hostDependencies: HostDependencies;
         installedBinaries: InstalledBinaries;
         referencedDependencies: ReferencedDependencies;
-        enabledPlugins: ("angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "releaseIt" | "semanticRelease" | "svelte")[];
+        hasTypesIncluded: Set<string>;
+        enabledPlugins: ("angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "drizzle" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease" | "svelte")[];
     }>;
 }
 export {};

package/dist/WorkspaceWorker.js

@@ -20,8 +20,9 @@ export class WorkspaceWorker {
     enabled;
     enabledPlugins = [];
     referencedDependencies = new Set();
-    peerDependencies = new Map();
+    hostDependencies = new Map();
     installedBinaries = new Map();
+    hasTypesIncluded = new Set();
     constructor({ name, dir, cwd, config, manifest, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }) {
         this.name = name;
         this.dir = dir;
@@ -59,7 +60,7 @@ export class WorkspaceWorker {
         debugLogObject(`Enabled plugins (${this.name})`, enabledPluginNames);
     }
     async initReferencedDependencies() {
-        const { dependencies, peerDependencies, installedBinaries } = await npm.findDependencies({
+        const { dependencies, hostDependencies, installedBinaries, hasTypesIncluded } = await npm.findDependencies({
             manifest: this.manifest,
             isProduction: this.isProduction,
             isStrict: this.isStrict,
@@ -68,8 +69,9 @@ export class WorkspaceWorker {
         });
         const filePath = join(this.dir, 'package.json');
         dependencies.forEach(dependency => this.referencedDependencies.add([filePath, dependency]));
-        this.peerDependencies = peerDependencies;
+        this.hostDependencies = hostDependencies;
         this.installedBinaries = installedBinaries;
+        this.hasTypesIncluded = hasTypesIncluded;
     }
     getConfigForPlugin(pluginName) {
         return this.config[pluginName] ?? { config: null, entry: null, project: null };
@@ -235,9 +237,10 @@ export class WorkspaceWorker {
     async findAllDependencies() {
         await this.findDependenciesByPlugins();
         return {
-            peerDependencies: this.peerDependencies,
+            hostDependencies: this.hostDependencies,
             installedBinaries: this.installedBinaries,
             referencedDependencies: this.referencedDependencies,
+            hasTypesIncluded: this.hasTypesIncluded,
             enabledPlugins: this.enabledPlugins,
         };
     }

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

@@ -3,6 +3,7 @@ export * as dotenv from './dotenv.js';
 export * as node from './node.js';
 export * as nodemon from './nodemon.js';
 export * as npx from './npx.js';
+export * as nx from './nx.js';
 export * as pnpm from './pnpm.js';
 export * as rollup from './rollup.js';
 export * as yarn from './yarn.js';

package/dist/binaries/resolvers/index.js

@@ -3,6 +3,7 @@ export * as dotenv from './dotenv.js';
 export * as node from './node.js';
 export * as nodemon from './nodemon.js';
 export * as npx from './npx.js';
+export * as nx from './nx.js';
 export * as pnpm from './pnpm.js';
 export * as rollup from './rollup.js';
 export * as yarn from './yarn.js';

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

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/nx.js

@@ -0,0 +1,9 @@
+import parseArgs from 'minimist';
+import { toBinary } from '../util.js';
+export const resolve = (binary, args, { fromArgs }) => {
+    const parsed = parseArgs(args);
+    const [command] = parsed._;
+    if (command === 'exec')
+        return [toBinary(binary), ...fromArgs(parsed._.slice(1))];
+    return [toBinary(binary)];
+};