knip 0.0.0-angular.0

package/dist/ConfigurationValidator.js

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+const globSchema = z.union([z.string(), z.array(z.string())]);
+const pathsSchema = z.record(z.string(), z.array(z.string()));
+const syncCompilerSchema = z.function().args(z.string()).returns(z.string());
+const asyncCompilerSchema = z.function().args(z.string()).returns(z.promise(z.string()));
+const compilerSchema = z.union([syncCompilerSchema, asyncCompilerSchema]);
+const compilersSchema = z.record(z.string(), compilerSchema);
+const issueTypeSchema = z.union([
+    z.literal('files'),
+    z.literal('dependencies'),
+    z.literal('devDependencies'),
+    z.literal('unlisted'),
+    z.literal('binaries'),
+    z.literal('unresolved'),
+    z.literal('exports'),
+    z.literal('types'),
+    z.literal('nsExports'),
+    z.literal('nsTypes'),
+    z.literal('duplicates'),
+    z.literal('enumMembers'),
+    z.literal('classMembers'),
+]);
+const rulesSchema = z.record(issueTypeSchema, z.enum(['error', 'warn', 'off']));
+const ignoreExportsUsedInFileSchema = z.union([
+    z.boolean(),
+    z.record(z.union([
+        z.literal('class'),
+        z.literal('enum'),
+        z.literal('function'),
+        z.literal('interface'),
+        z.literal('member'),
+        z.literal('type'),
+    ]), z.boolean()),
+]);
+const rootConfigurationSchema = z.object({
+    rules: rulesSchema.optional(),
+    entry: globSchema.optional(),
+    project: globSchema.optional(),
+    paths: pathsSchema.optional(),
+    ignore: globSchema.optional(),
+    ignoreBinaries: z.array(z.string()).optional(),
+    ignoreExportsUsedInFile: ignoreExportsUsedInFileSchema.optional(),
+    ignoreDependencies: z.array(z.string()).optional(),
+    ignoreWorkspaces: z.array(z.string()).optional(),
+    compilers: compilersSchema.optional(),
+    syncCompilers: z.record(z.string(), syncCompilerSchema).optional(),
+    asyncCompilers: z.record(z.string(), asyncCompilerSchema).optional(),
+});
+const reportConfigSchema = z.object({
+    include: z.array(z.string()).optional(),
+    exclude: z.array(z.string()).optional(),
+});
+const pluginSchema = z.union([
+    z.literal(false),
+    globSchema,
+    z.object({
+        config: globSchema.optional(),
+        entry: globSchema.optional(),
+        project: globSchema.optional(),
+    }),
+]);
+const pluginsSchema = z.object({
+    angular: pluginSchema,
+    ava: pluginSchema,
+    babel: pluginSchema,
+    capacitor: pluginSchema,
+    changesets: pluginSchema,
+    commitizen: pluginSchema,
+    commitlint: pluginSchema,
+    cspell: pluginSchema,
+    cypress: pluginSchema,
+    eslint: pluginSchema,
+    gatsby: pluginSchema,
+    'github-actions': pluginSchema,
+    husky: pluginSchema,
+    jest: pluginSchema,
+    lefthook: pluginSchema,
+    'lint-staged': pluginSchema,
+    markdownlint: pluginSchema,
+    mocha: pluginSchema,
+    next: pluginSchema,
+    'npm-package-json-lint': pluginSchema,
+    nx: pluginSchema,
+    nyc: pluginSchema,
+    playwright: pluginSchema,
+    postcss: pluginSchema,
+    prettier: pluginSchema,
+    'release-it': pluginSchema,
+    remark: pluginSchema,
+    remix: pluginSchema,
+    rollup: pluginSchema,
+    'semantic-release': pluginSchema,
+    sentry: pluginSchema,
+    storybook: pluginSchema,
+    stryker: pluginSchema,
+    stylelint: pluginSchema,
+    tailwind: pluginSchema,
+    typedoc: pluginSchema,
+    typescript: pluginSchema,
+    vite: pluginSchema,
+    vitest: pluginSchema,
+    webpack: pluginSchema,
+});
+const baseWorkspaceConfigurationSchema = z.object({
+    entry: globSchema.optional(),
+    project: globSchema.optional(),
+    paths: pathsSchema.optional(),
+    ignore: globSchema.optional(),
+    ignoreBinaries: z.array(z.string()).optional(),
+    ignoreDependencies: z.array(z.string()).optional(),
+});
+const workspaceConfigurationSchema = baseWorkspaceConfigurationSchema.merge(pluginsSchema.partial());
+const workspacesConfigurationSchema = z.object({
+    workspaces: z.record(z.string(), workspaceConfigurationSchema).optional(),
+});
+export const ConfigurationValidator = rootConfigurationSchema
+    .merge(reportConfigSchema)
+    .merge(workspacesConfigurationSchema)
+    .merge(pluginsSchema.partial());

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): void;
+    clear(): void;
+}

package/dist/ConsoleStreamer.js

@@ -0,0 +1,34 @@
+export class ConsoleStreamer {
+    isEnabled = false;
+    lines = 0;
+    constructor({ isEnabled = false }) {
+        this.isEnabled = isEnabled;
+    }
+    clearLines(count) {
+        if (count > 0) {
+            for (let i = 0; i < count; i++) {
+                process.stdout.moveCursor(0, -1);
+                process.stdout.clearLine(1);
+            }
+        }
+        process.stdout.cursorTo(0);
+    }
+    resetLines() {
+        this.clearLines(this.lines);
+    }
+    update(messages) {
+        this.resetLines();
+        process.stdout.write(messages.join('\n') + '\n');
+        this.lines = messages.length;
+    }
+    cast(message) {
+        if (!this.isEnabled)
+            return;
+        this.update([message]);
+    }
+    clear() {
+        if (!this.isEnabled)
+            return;
+        this.resetLines();
+    }
+}

package/dist/DependencyDeputy.d.ts

@@ -0,0 +1,64 @@
+/// <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 { PackageJson } from '@npmcli/package-json';
+type Options = {
+    isStrict: boolean;
+};
+export declare class DependencyDeputy {
+    isStrict: boolean;
+    _manifests: WorkspaceManifests;
+    referencedDependencies: Map<string, Set<string>>;
+    referencedBinaries: Map<string, Set<string>>;
+    peerDependencies: Map<string, PeerDependencies>;
+    installedBinaries: Map<string, InstalledBinaries>;
+    ignoreBinaries: string[];
+    ignoreDependencies: string[];
+    constructor({ isStrict }: Options);
+    addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries, }: {
+        name: string;
+        dir: string;
+        manifestPath: string;
+        manifest: PackageJson;
+        ignoreDependencies: string[];
+        ignoreBinaries: string[];
+    }): void;
+    addIgnored(ignoreBinaries: string[], ignoreDependencies: string[]): void;
+    getWorkspaceManifest(workspaceName: string): {
+        workspaceDir: string;
+        manifestPath: string;
+        scripts: string[];
+        dependencies: string[];
+        peerDependencies: string[];
+        optionalPeerDependencies: string[];
+        optionalDependencies: string[];
+        devDependencies: string[];
+        allDependencies: string[];
+        ignoreDependencies: string[];
+        ignoreBinaries: string[];
+    } | undefined;
+    getProductionDependencies(workspaceName: string): string[];
+    getDevDependencies(workspaceName: string): string[];
+    setInstalledBinaries(workspaceName: string, installedBinaries: Map<string, Set<string>>): void;
+    getInstalledBinaries(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[];
+    getPeerDependencies(workspaceName: string): string[];
+    getOptionalPeerDependencies(workspaceName: string): string[];
+    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string): boolean;
+    maybeAddReferencedBinary(workspace: Workspace, binaryName: string): boolean;
+    private isInDependencies;
+    settleDependencyIssues(): {
+        dependencyIssues: Issue[];
+        devDependencyIssues: Issue[];
+        optionalPeerDependencyIssues: Issue[];
+    };
+    getConfigurationHints(): {
+        configurationHints: ConfigurationHints;
+    };
+}
+export {};

package/dist/DependencyDeputy.js

@@ -0,0 +1,254 @@
+import { isBuiltin } from 'node:module';
+import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, ROOT_WORKSPACE_NAME, } from './constants.js';
+import { isDefinitelyTyped, getDefinitelyTypedFor, getPackageFromDefinitelyTyped } from './util/modules.js';
+export class DependencyDeputy {
+    isStrict;
+    _manifests = new Map();
+    referencedDependencies;
+    referencedBinaries;
+    peerDependencies;
+    installedBinaries;
+    ignoreBinaries = [];
+    ignoreDependencies = [];
+    constructor({ isStrict }) {
+        this.isStrict = isStrict;
+        this.referencedDependencies = new Map();
+        this.referencedBinaries = new Map();
+        this.peerDependencies = new Map();
+        this.installedBinaries = new Map();
+    }
+    addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries, }) {
+        const scripts = Object.values(manifest.scripts ?? {});
+        const dependencies = Object.keys(manifest.dependencies ?? {});
+        const peerDependencies = Object.keys(manifest.peerDependencies ?? {});
+        const optionalDependencies = Object.keys(manifest.optionalDependencies ?? {});
+        const optionalPeerDependencies = manifest.peerDependenciesMeta
+            ? peerDependencies.filter(peerDependency => manifest.peerDependenciesMeta &&
+                peerDependency in manifest.peerDependenciesMeta &&
+                manifest.peerDependenciesMeta[peerDependency].optional)
+            : [];
+        const devDependencies = Object.keys(manifest.devDependencies ?? {});
+        const allDependencies = [...dependencies, ...devDependencies, ...peerDependencies, ...optionalDependencies];
+        this._manifests.set(name, {
+            workspaceDir: dir,
+            manifestPath,
+            ignoreDependencies,
+            ignoreBinaries,
+            scripts,
+            dependencies,
+            peerDependencies,
+            optionalPeerDependencies,
+            optionalDependencies,
+            devDependencies,
+            allDependencies,
+        });
+    }
+    addIgnored(ignoreBinaries, ignoreDependencies) {
+        this.ignoreBinaries = ignoreBinaries;
+        this.ignoreDependencies = ignoreDependencies;
+    }
+    getWorkspaceManifest(workspaceName) {
+        return this._manifests.get(workspaceName);
+    }
+    getProductionDependencies(workspaceName) {
+        const manifest = this._manifests.get(workspaceName);
+        if (!manifest)
+            return [];
+        if (this.isStrict)
+            return [...manifest.dependencies, ...manifest.peerDependencies];
+        return manifest.dependencies;
+    }
+    getDevDependencies(workspaceName) {
+        return this._manifests.get(workspaceName)?.devDependencies ?? [];
+    }
+    setInstalledBinaries(workspaceName, installedBinaries) {
+        this.installedBinaries.set(workspaceName, installedBinaries);
+    }
+    getInstalledBinaries(workspaceName) {
+        return this.installedBinaries.get(workspaceName);
+    }
+    addReferencedDependency(workspaceName, packageName) {
+        if (!this.referencedDependencies.has(workspaceName)) {
+            this.referencedDependencies.set(workspaceName, new Set());
+        }
+        this.referencedDependencies.get(workspaceName)?.add(packageName);
+    }
+    addReferencedBinary(workspaceName, binaryName) {
+        if (!this.referencedBinaries.has(workspaceName)) {
+            this.referencedBinaries.set(workspaceName, new Set());
+        }
+        this.referencedBinaries.get(workspaceName)?.add(binaryName);
+    }
+    addPeerDependencies(workspaceName, peerDependencies) {
+        this.peerDependencies.set(workspaceName, peerDependencies);
+    }
+    getPeerDependenciesOf(workspaceName, dependency) {
+        return Array.from(this.peerDependencies.get(workspaceName)?.get(dependency) ?? []);
+    }
+    getPeerDependencies(workspaceName) {
+        const manifest = this._manifests.get(workspaceName);
+        if (!manifest)
+            return [];
+        return manifest.peerDependencies;
+    }
+    getOptionalPeerDependencies(workspaceName) {
+        const manifest = this._manifests.get(workspaceName);
+        if (!manifest)
+            return [];
+        return manifest.optionalPeerDependencies;
+    }
+    maybeAddReferencedExternalDependency(workspace, packageName) {
+        if (isBuiltin(packageName))
+            return true;
+        if (packageName === workspace.pkgName)
+            return true;
+        const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
+        const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName));
+        const typesPackageName = !isDefinitelyTyped(packageName) && getDefinitelyTypedFor(packageName);
+        const closestWorkspaceNameForTypes = typesPackageName && workspaceNames.find(name => this.isInDependencies(name, typesPackageName));
+        if (closestWorkspaceName || closestWorkspaceNameForTypes) {
+            closestWorkspaceName && this.addReferencedDependency(closestWorkspaceName, packageName);
+            closestWorkspaceNameForTypes && this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
+            return true;
+        }
+        else {
+            this.addReferencedDependency(workspace.name, packageName);
+        }
+        if (this.getWorkspaceManifest(workspace.name)?.ignoreDependencies.includes(packageName))
+            return true;
+        if (this.ignoreDependencies.includes(packageName))
+            return true;
+        return false;
+    }
+    maybeAddReferencedBinary(workspace, binaryName) {
+        if (IGNORED_GLOBAL_BINARIES.includes(binaryName))
+            return true;
+        this.addReferencedBinary(workspace.name, binaryName);
+        const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
+        for (const name of workspaceNames) {
+            const binaries = this.getInstalledBinaries(name);
+            if (binaries?.has(binaryName)) {
+                const dependencies = binaries.get(binaryName);
+                if (dependencies?.size) {
+                    dependencies.forEach(dependency => this.addReferencedDependency(name, dependency));
+                    return true;
+                }
+            }
+        }
+        if (this.getWorkspaceManifest(workspace.name)?.ignoreBinaries.includes(binaryName))
+            return true;
+        if (this.ignoreBinaries.includes(binaryName))
+            return true;
+        return false;
+    }
+    isInDependencies(workspaceName, packageName) {
+        const manifest = this._manifests.get(workspaceName);
+        if (!manifest)
+            return false;
+        const dependencies = this.isStrict ? this.getProductionDependencies(workspaceName) : manifest.allDependencies;
+        return dependencies.includes(packageName);
+    }
+    settleDependencyIssues() {
+        const dependencyIssues = [];
+        const devDependencyIssues = [];
+        const optionalPeerDependencyIssues = [];
+        for (const [workspaceName, { manifestPath, ignoreDependencies, ignoreBinaries }] of this._manifests.entries()) {
+            const referencedDependencies = this.referencedDependencies.get(workspaceName);
+            const installedBinaries = this.getInstalledBinaries(workspaceName);
+            const ignoreBins = [...IGNORED_GLOBAL_BINARIES, ...this.ignoreBinaries, ...ignoreBinaries];
+            const ignoreDeps = [...IGNORED_DEPENDENCIES, ...this.ignoreDependencies, ...ignoreDependencies];
+            const isNotIgnoredDependency = (packageName) => !ignoreDeps.includes(packageName);
+            const isNotIgnoredBinary = (packageName) => {
+                if (installedBinaries?.has(packageName)) {
+                    const binaryNames = installedBinaries.get(packageName);
+                    if (binaryNames) {
+                        if (ignoreBins.some(ignoredBinary => binaryNames.has(ignoredBinary)))
+                            return false;
+                    }
+                }
+                return true;
+            };
+            const peerDepRecs = {};
+            const isReferencedDependency = (dependency, isPeerDep) => {
+                if (referencedDependencies?.has(dependency))
+                    return true;
+                if (isPeerDep && peerDepRecs[dependency])
+                    return false;
+                const [scope, typedDependency] = dependency.split('/');
+                if (scope === '@types') {
+                    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));
+                    }
+                    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 isNotReferencedDependency = (dependency) => !isReferencedDependency(dependency);
+            const pd = this.getProductionDependencies(workspaceName);
+            const dd = this.getDevDependencies(workspaceName);
+            const od = this.getOptionalPeerDependencies(workspaceName);
+            pd.filter(isNotIgnoredDependency)
+                .filter(isNotIgnoredBinary)
+                .filter(isNotReferencedDependency)
+                .forEach(symbol => dependencyIssues.push({ type: 'dependencies', filePath: manifestPath, symbol }));
+            dd.filter(isNotIgnoredDependency)
+                .filter(isNotIgnoredBinary)
+                .filter(isNotReferencedDependency)
+                .forEach(symbol => devDependencyIssues.push({ type: 'devDependencies', filePath: manifestPath, symbol }));
+            od.filter(isNotIgnoredDependency)
+                .filter(isNotIgnoredBinary)
+                .filter(p => isReferencedDependency(p))
+                .forEach(symbol => optionalPeerDependencyIssues.push({ type: 'optionalPeerDependencies', filePath: manifestPath, symbol }));
+        }
+        return { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues };
+    }
+    getConfigurationHints() {
+        const configurationHints = new Set();
+        const rootIgnoreBinaries = Object.fromEntries(this.ignoreBinaries.map(key => [key, 0]));
+        const rootIgnoreDependencies = Object.fromEntries(this.ignoreDependencies.map(key => [key, 0]));
+        for (const [workspaceName, { ignoreDependencies, ignoreBinaries }] of this._manifests.entries()) {
+            const referencedDependencies = this.referencedDependencies.get(workspaceName);
+            const referencedBinaries = this.referencedBinaries.get(workspaceName);
+            const installedBinaries = this.getInstalledBinaries(workspaceName);
+            referencedDependencies?.forEach(pkg => pkg in rootIgnoreDependencies && rootIgnoreDependencies[pkg]++);
+            referencedBinaries?.forEach(binaryName => binaryName in rootIgnoreBinaries && rootIgnoreBinaries[binaryName]++);
+            const dependencies = this.isStrict
+                ? this.getProductionDependencies(workspaceName)
+                : [...this.getProductionDependencies(workspaceName), ...this.getDevDependencies(workspaceName)];
+            const peerDependencies = this.getPeerDependencies(workspaceName);
+            const isReferencedDep = (name) => referencedDependencies?.has(name) && dependencies.includes(name);
+            const isReferencedBin = (name) => referencedBinaries?.has(name) && installedBinaries?.has(name);
+            ignoreDependencies
+                .filter(packageName => IGNORED_DEPENDENCIES.includes(packageName) ||
+                (workspaceName !== ROOT_WORKSPACE_NAME && this.ignoreDependencies.includes(packageName)) ||
+                (!peerDependencies.includes(packageName) && isReferencedDep(packageName)))
+                .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreDependencies' }));
+            ignoreBinaries
+                .filter(binaryName => IGNORED_GLOBAL_BINARIES.includes(binaryName) ||
+                (workspaceName !== ROOT_WORKSPACE_NAME && this.ignoreBinaries.includes(binaryName)) ||
+                isReferencedBin(binaryName))
+                .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreBinaries' }));
+        }
+        const installedBinaries = this.getInstalledBinaries(ROOT_WORKSPACE_NAME);
+        const dependencies = this.isStrict
+            ? this.getProductionDependencies(ROOT_WORKSPACE_NAME)
+            : [...this.getProductionDependencies(ROOT_WORKSPACE_NAME), ...this.getDevDependencies(ROOT_WORKSPACE_NAME)];
+        const peerDependencies = this.getPeerDependencies(ROOT_WORKSPACE_NAME);
+        Object.keys(rootIgnoreBinaries)
+            .filter(key => IGNORED_GLOBAL_BINARIES.includes(key) || (rootIgnoreBinaries[key] !== 0 && installedBinaries?.has(key)))
+            .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreBinaries' }));
+        Object.keys(rootIgnoreDependencies)
+            .filter(key => IGNORED_DEPENDENCIES.includes(key) ||
+            (rootIgnoreDependencies[key] !== 0 && !peerDependencies.includes(key) && dependencies.includes(key)))
+            .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreDependencies' }));
+        return { configurationHints };
+    }
+}

package/dist/IssueCollector.d.ts

@@ -0,0 +1,27 @@
+import type { ConfigurationHint, Issue, Rules } from './types/issues.js';
+type IssueCollectorOptions = {
+    cwd: string;
+    rules: Rules;
+};
+export declare class IssueCollector {
+    private cwd;
+    private rules;
+    private issues;
+    private counters;
+    private referencedFiles;
+    private configurationHints;
+    constructor({ cwd, rules }: IssueCollectorOptions);
+    addFileCounts({ processed, unused }: {
+        processed: number;
+        unused: number;
+    }): void;
+    addFilesIssues(filePaths: string[]): void;
+    addIssue(issue: Issue): void;
+    addConfigurationHint(issue: ConfigurationHint): void;
+    getIssues(): {
+        issues: import("./types/issues.js").Issues;
+        counters: import("./types/issues.js").Counters;
+        configurationHints: Set<ConfigurationHint>;
+    };
+}
+export {};

package/dist/IssueCollector.js

@@ -0,0 +1,52 @@
+import { initIssues, initCounters } from './issues/initializers.js';
+import { relative } from './util/path.js';
+function objectInSet(set, obj) {
+    const objJSON = JSON.stringify(obj);
+    return Array.from(set).some(item => JSON.stringify(item) === objJSON);
+}
+export class IssueCollector {
+    cwd;
+    rules;
+    issues = initIssues();
+    counters = initCounters();
+    referencedFiles = new Set();
+    configurationHints = new Set();
+    constructor({ cwd, rules }) {
+        this.cwd = cwd;
+        this.rules = rules;
+    }
+    addFileCounts({ processed, unused }) {
+        this.counters.processed += processed;
+        this.counters.total += processed + unused;
+    }
+    addFilesIssues(filePaths) {
+        filePaths.forEach(filePath => {
+            if (!this.referencedFiles.has(filePath)) {
+                this.issues.files.add(filePath);
+                this.counters.files++;
+                this.counters.processed++;
+            }
+        });
+    }
+    addIssue(issue) {
+        const key = relative(this.cwd, issue.filePath);
+        issue.severity = this.rules[issue.type];
+        this.issues[issue.type][key] = this.issues[issue.type][key] ?? {};
+        if (!this.issues[issue.type][key][issue.symbol]) {
+            this.issues[issue.type][key][issue.symbol] = issue;
+            this.counters[issue.type]++;
+        }
+    }
+    addConfigurationHint(issue) {
+        if (!objectInSet(this.configurationHints, issue)) {
+            this.configurationHints.add(issue);
+        }
+    }
+    getIssues() {
+        return {
+            issues: this.issues,
+            counters: this.counters,
+            configurationHints: this.configurationHints,
+        };
+    }
+}

package/dist/PrincipalFactory.d.ts

@@ -0,0 +1,25 @@
+import ts from 'typescript';
+import { ProjectPrincipal } from './ProjectPrincipal.js';
+import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
+type Paths = ts.CompilerOptions['paths'];
+type Principal = {
+    principal: ProjectPrincipal;
+    cwds: Set<string>;
+    pathKeys: Set<string>;
+};
+type Principals = Set<Principal>;
+type Options = {
+    cwd: string;
+    compilerOptions: ts.CompilerOptions;
+    paths: Paths;
+    compilers: [SyncCompilers, AsyncCompilers];
+};
+export declare class PrincipalFactory {
+    principals: Principals;
+    getPrincipal(options: Options): ProjectPrincipal;
+    private findReusablePrincipal;
+    private linkPrincipal;
+    private addNewPrincipal;
+    getPrincipals(): ProjectPrincipal[];
+}
+export {};

package/dist/PrincipalFactory.js

@@ -0,0 +1,56 @@
+import ts from 'typescript';
+import { ProjectPrincipal } from './ProjectPrincipal.js';
+import { toAbsolute } from './util/path.js';
+const mergePaths = (cwd, compilerOptions, paths = {}) => {
+    const overridePaths = Object.keys(paths).reduce((overridePaths, key) => {
+        overridePaths[key] = paths[key].map(entry => toAbsolute(entry, cwd));
+        return overridePaths;
+    }, {});
+    compilerOptions.paths = { ...compilerOptions.paths, ...overridePaths };
+    return compilerOptions;
+};
+export class PrincipalFactory {
+    principals = new Set();
+    getPrincipal(options) {
+        const { cwd, compilerOptions, paths } = options;
+        options.compilerOptions = mergePaths(cwd, compilerOptions, paths);
+        const principal = this.findReusablePrincipal(compilerOptions);
+        if (principal) {
+            this.linkPrincipal(principal, cwd, compilerOptions);
+            return principal.principal;
+        }
+        else {
+            return this.addNewPrincipal(options);
+        }
+    }
+    findReusablePrincipal(compilerOptions) {
+        const workspacePaths = compilerOptions?.paths ? Object.keys(compilerOptions.paths) : [];
+        const principal = Array.from(this.principals).find(principal => {
+            if (compilerOptions.pathsBasePath && principal.principal.compilerOptions.pathsBasePath)
+                return false;
+            if (compilerOptions.baseUrl === principal.principal.compilerOptions.baseUrl) {
+                return workspacePaths.every(p => !principal.pathKeys.has(p));
+            }
+            return !compilerOptions.baseUrl;
+        });
+        return principal;
+    }
+    linkPrincipal(principal, cwd, compilerOptions) {
+        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);
+    }
+    addNewPrincipal(options) {
+        const { cwd, compilerOptions } = options;
+        const pathKeys = new Set(Object.keys(compilerOptions?.paths ?? {}));
+        const principal = new ProjectPrincipal(options);
+        this.principals.add({ principal, cwds: new Set([cwd]), pathKeys });
+        return principal;
+    }
+    getPrincipals() {
+        return Array.from(this.principals).map(p => p.principal);
+    }
+}