knip 5.50.0 → 5.50.2

package/dist/CacheConsultant.d.ts

@@ -0,0 +1,14 @@
+import { type FileDescriptor } from './util/file-entry-cache.js';
+type CacheOptions = {
+    name: string;
+    isEnabled: boolean;
+    cacheLocation: string;
+};
+export declare class CacheConsultant<T> {
+    private isEnabled;
+    private cache;
+    constructor(options: CacheOptions);
+    getFileDescriptor(file: string): FileDescriptor<T>;
+    reconcile(): void;
+}
+export {};

package/dist/ConfigurationChief.d.ts

@@ -0,0 +1,183 @@
+import type { Configuration, IgnorePatterns, WorkspaceConfiguration } from './types/config.js';
+import type { PackageJson, WorkspacePackage } from './types/package-json.js';
+import { type WorkspaceGraph } from './util/create-workspace-graph.js';
+import { type CLIArguments } from './util/get-included-issue-types.js';
+type ConfigurationManagerOptions = {
+    cwd: string;
+    isProduction: boolean;
+    isStrict: boolean;
+    isIncludeEntryExports: boolean;
+    workspace: string | undefined;
+};
+export type Workspace = {
+    name: string;
+    pkgName: string;
+    dir: string;
+    ancestors: string[];
+    config: WorkspaceConfiguration;
+    manifestPath: string;
+    manifestStr: string;
+    ignoreMembers: IgnorePatterns;
+    srcDir?: string;
+    outDir?: string;
+};
+export declare class ConfigurationChief {
+    cwd: string;
+    isProduction: boolean;
+    isStrict: boolean;
+    isIncludeEntryExports: boolean;
+    config: Configuration;
+    workspace: string | undefined;
+    manifestPath?: string;
+    manifest?: PackageJson;
+    ignoredWorkspacePatterns: string[];
+    workspacePackages: Map<string, WorkspacePackage>;
+    workspacesByPkgName: Map<string, Workspace>;
+    workspacesByName: Map<string, Workspace>;
+    additionalWorkspaceNames: Set<string>;
+    availableWorkspaceNames: string[];
+    availableWorkspacePkgNames: Set<string>;
+    availableWorkspaceDirs: string[];
+    workspaceGraph: WorkspaceGraph;
+    includedWorkspaces: Workspace[];
+    resolvedConfigFilePath?: string;
+    rawConfig?: any;
+    constructor({ cwd, isProduction, isStrict, isIncludeEntryExports, workspace }: ConfigurationManagerOptions);
+    init(): Promise<void>;
+    private loadResolvedConfigurationFile;
+    getRules(): import("./types/issues.js").Rules;
+    getFilters(): {
+        dir: string;
+    } | {
+        dir?: undefined;
+    };
+    private normalize;
+    private setWorkspaces;
+    private getListedWorkspaces;
+    private getIgnoredWorkspacePatterns;
+    private getConfiguredWorkspaceKeys;
+    private getAdditionalWorkspaceNames;
+    private getAvailableWorkspaceNames;
+    private getIncludedWorkspaces;
+    getManifestForWorkspace(name: string): PackageJson | undefined;
+    getWorkspaces(): Workspace[];
+    private getDescendentWorkspaces;
+    getIgnoredWorkspacesFor(name: string): string[];
+    getNegatedWorkspacePatterns(name: string): string[];
+    private getConfigKeyForWorkspace;
+    getWorkspaceConfig(workspaceName: string): any;
+    getIgnores(workspaceName: string): {
+        ignoreBinaries: any[];
+        ignoreDependencies: any[];
+        ignoreUnresolved: any[];
+    };
+    getConfigForWorkspace(workspaceName: string, extensions?: string[]): {
+        node?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        angular?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        astro?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        ava?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        babel?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        c8?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        capacitor?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        changesets?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        commitizen?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        commitlint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "create-typescript-app"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        cspell?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        cucumber?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        cypress?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "dependency-cruiser"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        dotenv?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        drizzle?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        eleventy?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        eslint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        expo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        gatsby?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "github-action"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "github-actions"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        glob?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "graphql-codegen"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        husky?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "i18next-parser"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        jest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        karma?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        ladle?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        lefthook?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "lint-staged"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        linthtml?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "lockfile-lint"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "lost-pixel"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        markdownlint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        metro?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        mocha?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        moonrepo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        msw?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        netlify?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        next?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nodemon?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "npm-package-json-lint"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nuxt?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nx?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nyc?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        oclif?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        playwright?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "playwright-ct"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "playwright-test"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        plop?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        postcss?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        preconstruct?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        prettier?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "react-cosmos"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "react-router"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "release-it"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        remark?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        remix?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        rollup?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        rsbuild?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        rspack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "semantic-release"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        sentry?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "simple-git-hooks"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "size-limit"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        sst?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        starlight?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        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;
+        syncpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        tailwind?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "tanstack-router"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        travis?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "ts-node"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        tsup?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        tsx?: (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;
+        unocss?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "vercel-og"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        vike?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        vite?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        vitest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        vue?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "webdriver-io"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        webpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        wireit?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        wrangler?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        xo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        yarn?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        yorkie?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        entry: string[];
+        project: string[];
+        paths: any;
+        ignore: string[];
+        isIncludeEntryExports: any;
+    };
+    getIncludedIssueTypes(cliArgs: CLIArguments): import("./types/issues.js").Report;
+    findWorkspaceByFilePath(filePath: string): Workspace | undefined;
+    getUnusedIgnoredWorkspaces(): string[];
+    getTags(): import("./types/cli.js").Tags;
+}
+export {};

package/dist/ConsoleStreamer.d.ts

@@ -0,0 +1,12 @@
+export declare class ConsoleStreamer {
+    isEnabled: boolean;
+    private lines;
+    constructor({ isEnabled }: {
+        isEnabled?: boolean | undefined;
+    });
+    private clearLines;
+    private resetLines;
+    private update;
+    cast(message: string | string[]): void;
+    clear(): void;
+}

package/dist/DependencyDeputy.d.ts

@@ -0,0 +1,78 @@
+import type { Workspace } from './ConfigurationChief.js';
+import type { ConfigurationHints, Counters, Issue, Issues, SymbolIssueType } from './types/issues.js';
+import type { PackageJson } from './types/package-json.js';
+import type { DependencyArray, DependencySet, HostDependencies, InstalledBinaries, WorkspaceManifests } from './types/workspace.js';
+type Options = {
+    isProduction: boolean;
+    isStrict: boolean;
+};
+export declare class DependencyDeputy {
+    isProduction: boolean;
+    isStrict: boolean;
+    _manifests: WorkspaceManifests;
+    referencedDependencies: Map<string, Set<string>>;
+    referencedBinaries: Map<string, Set<string>>;
+    hostDependencies: Map<string, HostDependencies>;
+    installedBinaries: Map<string, InstalledBinaries>;
+    hasTypesIncluded: Map<string, Set<string>>;
+    constructor({ isProduction, isStrict }: Options);
+    addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ignoreDependencies, ignoreBinaries, ignoreUnresolved, }: {
+        name: string;
+        cwd: string;
+        dir: string;
+        manifestPath: string;
+        manifestStr: string;
+        manifest: PackageJson;
+        ignoreDependencies: (string | RegExp)[];
+        ignoreBinaries: (string | RegExp)[];
+        ignoreUnresolved: (string | RegExp)[];
+    }): void;
+    getWorkspaceManifest(workspaceName: string): {
+        workspaceDir: string;
+        manifestPath: string;
+        manifestStr: string;
+        dependencies: DependencyArray;
+        devDependencies: DependencyArray;
+        peerDependencies: DependencySet;
+        optionalPeerDependencies: DependencyArray;
+        allDependencies: DependencySet;
+        ignoreDependencies: (string | RegExp)[];
+        ignoreBinaries: (string | RegExp)[];
+        ignoreUnresolved: (string | RegExp)[];
+        usedIgnoreDependencies: Set<string | RegExp>;
+        usedIgnoreBinaries: Set<string | RegExp>;
+        usedIgnoreUnresolved: Set<string | RegExp>;
+    } | undefined;
+    getProductionDependencies(workspaceName: string): DependencyArray;
+    getDevDependencies(workspaceName: string): DependencyArray;
+    getDependencies(workspaceName: string): DependencySet;
+    setInstalledBinaries(workspaceName: string, installedBinaries: Map<string, Set<string>>): void;
+    getInstalledBinaries(workspaceName: string): InstalledBinaries | undefined;
+    setHasTypesIncluded(workspaceName: string, hasTypesIncluded: Set<string>): void;
+    getHasTypesIncluded(workspaceName: string): Set<string> | undefined;
+    addReferencedDependency(workspaceName: string, packageName: string): void;
+    addReferencedBinary(workspaceName: string, binaryName: string): void;
+    setHostDependencies(workspaceName: string, hostDependencies: HostDependencies): void;
+    getHostDependenciesFor(workspaceName: string, dependency: string): {
+        name: string;
+        isPeerOptional: boolean;
+    }[];
+    getOptionalPeerDependencies(workspaceName: string): DependencyArray;
+    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string): boolean;
+    maybeAddReferencedBinary(workspace: Workspace, binaryName: string): boolean;
+    private isInDependencies;
+    settleDependencyIssues(): {
+        dependencyIssues: Issue[];
+        devDependencyIssues: Issue[];
+        optionalPeerDependencyIssues: Issue[];
+    };
+    handleIgnoredDependencies(issues: Issues, counters: Counters, type: SymbolIssueType): void;
+    handleIgnoredBinaries(issues: Issues, counters: Counters, type: SymbolIssueType): void;
+    handleIgnoredUnresolved(issues: Issues, counters: Counters): void;
+    removeIgnoredIssues({ issues, counters }: {
+        issues: Issues;
+        counters: Counters;
+    }): void;
+    getConfigurationHints(): ConfigurationHints;
+}
+export {};

package/dist/IssueCollector.d.ts

@@ -0,0 +1,39 @@
+import type { ConfigurationHint, Issue, Rules, TagHint } 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;
+    private tagHints;
+    private ignorePatterns;
+    private isMatch;
+    constructor({ cwd, rules, filters }: IssueCollectorOptions);
+    addIgnorePatterns(patterns: string[]): void;
+    addFileCounts({ processed, unused }: {
+        processed: number;
+        unused: number;
+    }): void;
+    addFilesIssues(filePaths: string[]): void;
+    addIssue(issue: Issue): Issue | undefined;
+    addConfigurationHint(issue: ConfigurationHint): void;
+    addTagHint(issue: TagHint): void;
+    purge(): import("./types/issues.js").IssueSet;
+    getIssues(): {
+        issues: import("./types/issues.js").Issues;
+        counters: import("./types/issues.js").Counters;
+        tagHints: Set<TagHint>;
+        configurationHints: Set<ConfigurationHint>;
+    };
+}
+export {};

package/dist/IssueFixer.d.ts

@@ -0,0 +1,27 @@
+import type { Fix, Fixes } from './types/exports.js';
+import type { Issues } from './types/issues.js';
+interface Fixer {
+    isEnabled: boolean;
+    cwd: string;
+    fixTypes: string[];
+    isRemoveFiles: boolean;
+}
+export declare class IssueFixer {
+    isEnabled: boolean;
+    cwd: string;
+    isFixFiles: boolean;
+    isFixDependencies: boolean;
+    isFixUnusedTypes: boolean;
+    isFixUnusedExports: boolean;
+    unusedTypeNodes: Map<string, Set<Fix>>;
+    unusedExportNodes: Map<string, Set<Fix>>;
+    constructor({ isEnabled, cwd, fixTypes, isRemoveFiles }: Fixer);
+    addUnusedTypeNode(filePath: string, fixes: Fixes | undefined): void;
+    addUnusedExportNode(filePath: string, fixes: Fixes | undefined): void;
+    fixIssues(issues: Issues): Promise<void>;
+    private markExportFixed;
+    private removeUnusedFiles;
+    private removeUnusedExports;
+    private removeUnusedDependencies;
+}
+export {};

package/dist/PackageJsonPeeker.d.ts

@@ -0,0 +1,13 @@
+export declare class PackageJsonPeeker {
+    private manifestStr;
+    private lines;
+    private sections;
+    private ready;
+    constructor(manifestStr: string);
+    private init;
+    getLocation(type: 'dependencies' | 'devDependencies' | 'optionalPeerDependencies', packageName: string): {
+        line: number;
+        col: number;
+        pos: number;
+    } | undefined;
+}

package/dist/PrincipalFactory.d.ts

@@ -0,0 +1,20 @@
+import { ProjectPrincipal } from './ProjectPrincipal.js';
+import type { PrincipalOptions } from './types/project.js';
+type Principal = {
+    principal: ProjectPrincipal;
+    wsDirs: Set<string>;
+    pathKeys: Set<string>;
+    pkgNames: Set<string>;
+};
+type Principals = Set<Principal>;
+export declare class PrincipalFactory {
+    principals: Principals;
+    createPrincipal(options: PrincipalOptions): ProjectPrincipal;
+    private findReusablePrincipal;
+    private linkPrincipal;
+    private addNewPrincipal;
+    getPrincipals(): ProjectPrincipal[];
+    getPrincipalByPackageName(packageName: string): ProjectPrincipal | undefined;
+    deletePrincipal(principal: ProjectPrincipal): void;
+}
+export {};

package/dist/ProjectPrincipal.d.ts

@@ -0,0 +1,58 @@
+import ts from 'typescript';
+import { CacheConsultant } from './CacheConsultant.js';
+import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
+import type { GetImportsAndExportsOptions } from './types/config.js';
+import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.js';
+import type { PrincipalOptions } from './types/project.js';
+import { SourceFileManager } from './typescript/SourceFileManager.js';
+import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
+import type { ToSourceFilePath } from './util/to-source-path.js';
+export declare class ProjectPrincipal {
+    entryPaths: Set<string>;
+    projectPaths: Set<string>;
+    nonEntryPaths: Set<string>;
+    skipExportsAnalysis: Set<string>;
+    cwd: string;
+    compilerOptions: ts.CompilerOptions;
+    extensions: Set<string>;
+    syncCompilers: SyncCompilers;
+    asyncCompilers: AsyncCompilers;
+    isSkipLibs: boolean;
+    isWatch: boolean;
+    cache: CacheConsultant<FileNode>;
+    toSourceFilePath: ToSourceFilePath;
+    backend: {
+        fileManager: SourceFileManager;
+        compilerHost?: ts.CompilerHost;
+        resolveModuleNames: ResolveModuleNames;
+        program?: ts.Program;
+        typeChecker?: ts.TypeChecker;
+        languageServiceHost: ts.LanguageServiceHost;
+    };
+    findReferences?: ts.LanguageService['findReferences'];
+    constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, }: PrincipalOptions);
+    init(): void;
+    addPaths(paths: ts.CompilerOptions['paths']): void;
+    addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
+    private createProgram;
+    private hasAcceptedExtension;
+    addEntryPath(filePath: string, options?: {
+        skipExportsAnalysis: boolean;
+    }): void;
+    addEntryPaths(filePaths: Set<string> | string[], options?: {
+        skipExportsAnalysis: boolean;
+    }): void;
+    addNonEntryPath(filePath: string): void;
+    addProjectPath(filePath: string): void;
+    deletedFiles: Set<unknown>;
+    removeProjectPath(filePath: string): void;
+    runAsyncCompilers(): Promise<void>;
+    getUsedResolvedFiles(): string[];
+    private getProgramSourceFiles;
+    getUnreferencedFiles(): string[];
+    analyzeSourceFile(filePath: string, options: Omit<GetImportsAndExportsOptions, 'skipExports'>, isGitIgnored: (filePath: string) => boolean, isInternalWorkspace: (packageName: string) => boolean, getPrincipalByFilePath: (filePath: string) => undefined | ProjectPrincipal): FileNode;
+    invalidateFile(filePath: string): void;
+    findUnusedMembers(filePath: string, members: ExportMember[]): ExportMember[];
+    hasExternalReferences(filePath: string, exportedItem: Export): boolean;
+    reconcileCache(graph: ModuleGraph): void;
+}

package/dist/WorkspaceWorker.d.ts

@@ -0,0 +1,71 @@
+import { CacheConsultant } from './CacheConsultant.js';
+import type { Workspace } from './ConfigurationChief.js';
+import type { PluginName } from './types/PluginNames.js';
+import type { Configuration, GetReferencedInternalFilePath, GetSourceFile, WorkspaceConfiguration } from './types/config.js';
+import type { PackageJson } from './types/package-json.js';
+import type { DependencySet } from './types/workspace.js';
+import { type Input } from './util/input.js';
+type WorkspaceManagerOptions = {
+    name: string;
+    dir: string;
+    cwd: string;
+    config: WorkspaceConfiguration;
+    manifest: PackageJson;
+    dependencies: DependencySet;
+    getReferencedInternalFilePath: GetReferencedInternalFilePath;
+    findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getSourceFile: GetSourceFile;
+    rootIgnore: Configuration['ignore'];
+    negatedWorkspacePatterns: string[];
+    ignoredWorkspacePatterns: string[];
+    enabledPluginsInAncestors: string[];
+    isProduction: boolean;
+    isStrict: boolean;
+    isCache: boolean;
+    cacheLocation: string;
+    extConfigFilesMap: Map<string, Map<PluginName, Set<string>>>;
+    configFilesMap: Map<PluginName, Set<string>>;
+};
+type CacheItem = {
+    resolveEntryPaths?: Input[];
+    resolveConfig?: Input[];
+    resolveFromAST?: Input[];
+};
+export declare class WorkspaceWorker {
+    name: string;
+    dir: string;
+    cwd: string;
+    config: WorkspaceConfiguration;
+    manifest: PackageJson;
+    dependencies: DependencySet;
+    getReferencedInternalFilePath: GetReferencedInternalFilePath;
+    findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getSourceFile: GetSourceFile;
+    isProduction: boolean;
+    isStrict: boolean;
+    rootIgnore: Configuration['ignore'];
+    negatedWorkspacePatterns: string[];
+    ignoredWorkspacePatterns: string[];
+    enabledPluginsMap: Record<PluginName, boolean>;
+    enabledPlugins: PluginName[];
+    enabledPluginsInAncestors: string[];
+    cache: CacheConsultant<CacheItem>;
+    extConfigFilesMap: Map<string, Map<PluginName, Set<string>>>;
+    configFilesMap: Map<PluginName, Set<string>>;
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, isCache, cacheLocation, extConfigFilesMap, configFilesMap, }: WorkspaceManagerOptions);
+    init(): Promise<void>;
+    private determineEnabledPlugins;
+    private getConfigForPlugin;
+    getEntryFilePatterns(): string[];
+    getProjectFilePatterns(projectFilePatterns: string[]): string[];
+    getPluginProjectFilePatterns(patterns?: string[]): string[];
+    getPluginConfigPatterns(): string[];
+    getPluginEntryFilePatterns(patterns: string[]): string[];
+    getProductionEntryFilePatterns(negatedTestFilePatterns: string[]): string[];
+    getProductionProjectFilePatterns(negatedTestFilePatterns: string[]): string[];
+    private getConfigurationFilePatterns;
+    getIgnorePatterns(): string[];
+    runPlugins(): Promise<Input[]>;
+    onDispose(): void;
+}
+export {};

package/dist/WorkspaceWorker.js

@@ -31,8 +31,9 @@ export class WorkspaceWorker {
     enabledPlugins = [];
     enabledPluginsInAncestors;
     cache;
+    extConfigFilesMap;
     configFilesMap;
-    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, isCache, cacheLocation, configFilesMap, }) {
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, isCache, cacheLocation, extConfigFilesMap, configFilesMap, }) {
         this.name = name;
         this.dir = dir;
         this.cwd = cwd;
@@ -45,6 +46,7 @@ export class WorkspaceWorker {
         this.negatedWorkspacePatterns = negatedWorkspacePatterns;
         this.ignoredWorkspacePatterns = ignoredWorkspacePatterns;
         this.enabledPluginsInAncestors = enabledPluginsInAncestors;
+        this.extConfigFilesMap = extConfigFilesMap;
         this.configFilesMap = configFilesMap;
         this.getReferencedInternalFilePath = getReferencedInternalFilePath;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
@@ -187,19 +189,19 @@ export class WorkspaceWorker {
                 inputs.push({ ...input, containingFilePath });
             }
         };
-        const configFilesMap = this.configFilesMap;
-        const configFiles = this.configFilesMap.get(wsName);
+        const extMap = this.extConfigFilesMap;
+        const configFiles = this.extConfigFilesMap.get(wsName);
         const handleConfigInput = (pluginName, input) => {
             const configFilePath = this.getReferencedInternalFilePath(input);
             if (configFilePath) {
                 const workspace = this.findWorkspaceByFilePath(configFilePath);
                 if (workspace) {
                     const name = this.name === ROOT_WORKSPACE_NAME ? workspace.name : this.name;
-                    if (!configFilesMap.has(name))
-                        configFilesMap.set(name, new Map());
-                    if (!configFilesMap.get(name)?.has(pluginName))
-                        configFilesMap.get(name)?.set(pluginName, new Set());
-                    configFilesMap.get(name)?.get(pluginName)?.add(configFilePath);
+                    if (!extMap.has(name))
+                        extMap.set(name, new Map());
+                    if (!extMap.get(name)?.has(pluginName))
+                        extMap.get(name)?.set(pluginName, new Set());
+                    extMap.get(name)?.get(pluginName)?.add(configFilePath);
                 }
             }
         };
@@ -220,7 +222,10 @@ export class WorkspaceWorker {
             if (!config)
                 return;
             const label = 'config file';
-            const configFilePaths = await _glob({ patterns, cwd: rootCwd, dir: cwd, gitignore: false, label });
+            const configFilePaths = await _glob({ patterns, cwd, dir: cwd, gitignore: false, label });
+            if (!this.configFilesMap.has(pluginName))
+                this.configFilesMap.set(pluginName, new Set());
+            const filteredFilePaths = configFilePaths.filter(filePath => !this.configFilesMap.get(pluginName)?.has(filePath));
             const options = {
                 ...baseScriptOptions,
                 config,
@@ -236,8 +241,8 @@ export class WorkspaceWorker {
             }
             else if ((!plugin.resolveEntryPaths && !plugin.resolveFromAST) ||
                 (configFilePaths.length === 0 &&
-                    (!this.configFilesMap.get(wsName)?.get(pluginName) ||
-                        this.configFilesMap.get(wsName)?.get(pluginName)?.size === 0))) {
+                    (!this.extConfigFilesMap.get(wsName)?.get(pluginName) ||
+                        this.extConfigFilesMap.get(wsName)?.get(pluginName)?.size === 0))) {
                 if (plugin.entry)
                     for (const id of plugin.entry)
                         addInput(toEntry(id));
@@ -245,7 +250,8 @@ export class WorkspaceWorker {
                     for (const id of plugin.production)
                         addInput(toProductionEntry(id));
             }
-            for (const configFilePath of configFilePaths) {
+            for (const configFilePath of filteredFilePaths) {
+                this.configFilesMap.get(pluginName)?.add(configFilePath);
                 const isManifest = basename(configFilePath) === 'package.json';
                 const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
                 if (fd?.meta?.data && !fd.changed) {
@@ -268,7 +274,7 @@ export class WorkspaceWorker {
                     configFileDir: dirname(configFilePath),
                     configFileName: basename(configFilePath),
                 };
-                const seen = this.configFilesMap.get(wsName)?.get(pluginName)?.has(configFilePath);
+                const seen = this.extConfigFilesMap.get(wsName)?.get(pluginName)?.has(configFilePath);
                 const cache = {};
                 let loadedConfig;
                 if (plugin.resolveEntryPaths && !seen) {
@@ -327,7 +333,7 @@ export class WorkspaceWorker {
             remainingPlugins.delete(pluginName);
         }
         {
-            const configFiles = this.configFilesMap.get(wsName);
+            const configFiles = this.extConfigFilesMap.get(wsName);
             if (configFiles) {
                 do {
                     for (const [pluginName, dependencies] of configFiles.entries()) {

package/dist/binaries/bash-parser.d.ts

@@ -0,0 +1,3 @@
+import type { GetInputsFromScriptsOptions } from '../types/config.js';
+import { type Input } from '../util/input.js';
+export declare const getDependenciesFromScript: (script: string, options: GetInputsFromScriptsOptions) => Input[];

package/dist/binaries/fallback.d.ts

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

package/dist/binaries/index.d.ts

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

package/dist/binaries/package-manager/bun.d.ts

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

package/dist/binaries/package-manager/bunx.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryResolver, BinaryResolverOptions } from '../../types/config.js';
+export declare const resolveX: (args: string[], options: BinaryResolverOptions) => import("../../util/input.js").Input[];
+export declare const resolve: BinaryResolver;