knip 5.68.0 → 5.69.1

package/dist/CatalogCounselor.d.ts

@@ -0,0 +1,18 @@
+import type { Issue } from './types/issues.js';
+import type { Catalog, Catalogs, PackageJson } from './types/package-json.js';
+import type { MainOptions } from './util/create-options.js';
+export type CatalogContainer = {
+    filePath: string;
+    catalog?: Catalog;
+    catalogs?: Catalogs;
+};
+export declare class CatalogCounselor {
+    private filePath;
+    private entries;
+    private referencedEntries;
+    private fileContent?;
+    constructor(options: MainOptions);
+    private addReferencedCatalogEntry;
+    addWorkspace(manifest: PackageJson): void;
+    settleCatalogIssues(options: MainOptions): Promise<Issue[]>;
+}

package/dist/CatalogCounselor.js

@@ -0,0 +1,50 @@
+import { readFile } from 'node:fs/promises';
+import { ROOT_WORKSPACE_NAME } from './constants.js';
+import { JsonCatalogPeeker } from './JsonCatalogPeeker.js';
+import { extractCatalogReferences, parseCatalog } from './util/catalog.js';
+import { extname } from './util/path.js';
+import { YamlCatalogPeeker } from './YamlCatalogPeeker.js';
+export class CatalogCounselor {
+    filePath;
+    entries = new Set();
+    referencedEntries = new Set();
+    fileContent;
+    constructor(options) {
+        this.filePath = options.catalog.filePath;
+        this.entries = parseCatalog(options.catalog);
+    }
+    addReferencedCatalogEntry(entryName) {
+        this.referencedEntries.add(entryName);
+    }
+    addWorkspace(manifest) {
+        if (this.entries.size === 0)
+            return;
+        const catalogReferences = extractCatalogReferences(manifest);
+        for (const catalogEntryName of catalogReferences)
+            this.addReferencedCatalogEntry(catalogEntryName);
+    }
+    async settleCatalogIssues(options) {
+        if (this.entries.size === 0)
+            return [];
+        const filePath = this.filePath;
+        const workspace = ROOT_WORKSPACE_NAME;
+        const catalogIssues = [];
+        if (this.entries.size > this.referencedEntries.size) {
+            this.fileContent = await readFile(filePath, 'utf-8');
+            const isYaml = ['.yml', '.yaml'].includes(extname(filePath));
+            const Peeker = isYaml ? YamlCatalogPeeker : JsonCatalogPeeker;
+            const peeker = new Peeker(this.fileContent);
+            for (const entry of this.entries.keys()) {
+                if (!this.referencedEntries.has(entry)) {
+                    const [parentSymbol, symbol] = entry.split(':');
+                    const pos = peeker.getLocation(parentSymbol, symbol);
+                    const fixes = [];
+                    if (options.isFix && isYaml && pos)
+                        fixes.push([pos.line, 0, 0]);
+                    catalogIssues.push({ type: 'catalog', filePath, workspace, symbol, parentSymbol, fixes, ...pos });
+                }
+            }
+        }
+        return catalogIssues;
+    }
+}

package/dist/ConfigurationChief.d.ts

@@ -277,6 +277,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        mdx?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         mdxlint?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -703,6 +708,7 @@ export declare class ConfigurationChief {
         "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;
+        mdx?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         mdxlint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         metro?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         mocha?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/ConfigurationChief.js

@@ -179,9 +179,11 @@ export class ConfigurationChief {
     }
     getAvailableWorkspaceNames(names) {
         const availableWorkspaceNames = [];
+        const [ignore, patterns] = partition(this.ignoredWorkspacePatterns, pattern => pattern.startsWith('!'));
         for (const name of names) {
-            if (!picomatch.isMatch(name, this.ignoredWorkspacePatterns))
+            if (!picomatch.isMatch(name, patterns, { ignore: ignore.map(pattern => pattern.slice(1)) })) {
                 availableWorkspaceNames.push(name);
+            }
         }
         return availableWorkspaceNames;
     }

package/dist/DependencyDeputy.js

@@ -213,15 +213,22 @@ export class DependencyDeputy {
             const isNotReferencedDependency = (dependency) => !isReferencedDependency(dependency, false);
             for (const symbol of this.getProductionDependencies(workspace).filter(isNotReferencedDependency)) {
                 const position = peeker.getLocation('dependencies', symbol);
-                dependencyIssues.push({ type: 'dependencies', workspace, filePath, symbol, ...position });
+                dependencyIssues.push({ type: 'dependencies', workspace, filePath, symbol, fixes: [], ...position });
             }
             for (const symbol of this.getDevDependencies(workspace).filter(isNotReferencedDependency)) {
                 const position = peeker.getLocation('devDependencies', symbol);
-                devDependencyIssues.push({ type: 'devDependencies', filePath, workspace, symbol, ...position });
+                devDependencyIssues.push({ type: 'devDependencies', filePath, workspace, symbol, fixes: [], ...position });
             }
             for (const symbol of this.getOptionalPeerDependencies(workspace).filter(d => isReferencedDependency(d))) {
                 const pos = peeker.getLocation('optionalPeerDependencies', symbol);
-                optionalPeerDependencyIssues.push({ type: 'optionalPeerDependencies', filePath, workspace, symbol, ...pos });
+                optionalPeerDependencyIssues.push({
+                    type: 'optionalPeerDependencies',
+                    filePath,
+                    workspace,
+                    symbol,
+                    fixes: [],
+                    ...pos,
+                });
             }
         }
         return { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues };

package/dist/IssueFixer.d.ts

@@ -1,16 +1,11 @@
-import type { Fix, Fixes } from './types/exports.js';
 import type { Issues } from './types/issues.js';
 import type { MainOptions } from './util/create-options.js';
 export declare class IssueFixer {
     options: MainOptions;
-    unusedTypeNodes: Map<string, Set<Fix>>;
-    unusedExportNodes: Map<string, Set<Fix>>;
     constructor(options: MainOptions);
-    addUnusedTypeNode(filePath: string, fixes: Fixes | undefined): void;
-    addUnusedExportNode(filePath: string, fixes: Fixes | undefined): void;
     fixIssues(issues: Issues): Promise<Set<string>>;
-    private markExportFixed;
     private removeUnusedFiles;
     private removeUnusedExports;
     private removeUnusedDependencies;
+    private removeUnusedCatalogEntries;
 }

package/dist/IssueFixer.js

@@ -1,32 +1,13 @@
 import { readFile, rm, writeFile } from 'node:fs/promises';
+import { DEFAULT_CATALOG } from './util/catalog.js';
 import { load, save } from './util/package-json.js';
-import { join, relative } from './util/path.js';
+import { extname, join } from './util/path.js';
 import { removeExport } from './util/remove-export.js';
 export class IssueFixer {
     options;
-    unusedTypeNodes = new Map();
-    unusedExportNodes = new Map();
     constructor(options) {
         this.options = options;
     }
-    addUnusedTypeNode(filePath, fixes) {
-        if (!fixes || fixes.length === 0)
-            return;
-        if (this.unusedTypeNodes.has(filePath))
-            for (const fix of fixes)
-                this.unusedTypeNodes.get(filePath)?.add(fix);
-        else
-            this.unusedTypeNodes.set(filePath, new Set(fixes));
-    }
-    addUnusedExportNode(filePath, fixes) {
-        if (!fixes || fixes.length === 0)
-            return;
-        if (this.unusedExportNodes.has(filePath))
-            for (const fix of fixes)
-                this.unusedExportNodes.get(filePath)?.add(fix);
-        else
-            this.unusedExportNodes.set(filePath, new Set(fixes));
-    }
     async fixIssues(issues) {
         const touchedFiles = new Set();
         await this.removeUnusedFiles(issues);
@@ -34,20 +15,10 @@ export class IssueFixer {
             touchedFiles.add(filePath);
         for (const filePath of await this.removeUnusedDependencies(issues))
             touchedFiles.add(filePath);
+        for (const filePath of await this.removeUnusedCatalogEntries(issues))
+            touchedFiles.add(filePath);
         return touchedFiles;
     }
-    markExportFixed(issues, filePath) {
-        const relPath = relative(this.options.cwd, filePath);
-        const types = [
-            ...(this.options.isFixUnusedTypes ? ['types', 'nsTypes', 'classMembers', 'enumMembers'] : []),
-            ...(this.options.isFixUnusedExports ? ['exports', 'nsExports'] : []),
-        ];
-        for (const type of types) {
-            for (const id in issues[type][relPath]) {
-                issues[type][relPath][id].isFixed = true;
-            }
-        }
-    }
     async removeUnusedFiles(issues) {
         if (!this.options.isFixFiles)
             return;
@@ -58,18 +29,33 @@ export class IssueFixer {
     }
     async removeUnusedExports(issues) {
         const touchedFiles = new Set();
-        const filePaths = new Set([...this.unusedTypeNodes.keys(), ...this.unusedExportNodes.keys()]);
-        for (const filePath of filePaths) {
-            const types = (this.options.isFixUnusedTypes && this.unusedTypeNodes.get(filePath)) || [];
-            const exports = (this.options.isFixUnusedExports && this.unusedExportNodes.get(filePath)) || [];
-            const exportPositions = [...types, ...exports]
-                .filter((fix) => fix !== undefined)
-                .sort((a, b) => b[0] - a[0]);
-            if (exportPositions.length > 0) {
-                const sourceFileText = exportPositions.reduce((text, [start, end, flags]) => removeExport({ text, start, end, flags }), await readFile(filePath, 'utf-8'));
-                await writeFile(filePath, sourceFileText);
-                touchedFiles.add(filePath);
-                this.markExportFixed(issues, filePath);
+        const types = [
+            ...(this.options.isFixUnusedTypes ? ['types', 'nsTypes', 'classMembers', 'enumMembers'] : []),
+            ...(this.options.isFixUnusedExports ? ['exports', 'nsExports'] : []),
+        ];
+        if (types.length === 0)
+            return touchedFiles;
+        const allFixes = new Map();
+        for (const type of types) {
+            for (const [filePath, issueMap] of Object.entries(issues[type])) {
+                const fixes = allFixes.get(filePath) ?? [];
+                for (const issue of Object.values(issueMap))
+                    fixes.push(...issue.fixes);
+                allFixes.set(filePath, fixes);
+            }
+        }
+        for (const [filePath, fixes] of allFixes) {
+            const absFilePath = join(this.options.cwd, filePath);
+            const sourceFileText = fixes
+                .sort((a, b) => b[0] - a[0])
+                .reduce((text, [start, end, flags]) => removeExport({ text, start, end, flags }), await readFile(absFilePath, 'utf-8'));
+            await writeFile(absFilePath, sourceFileText);
+            touchedFiles.add(absFilePath);
+            for (const type of types) {
+                const issueMap = issues[type]?.[filePath];
+                if (issueMap)
+                    for (const issue of Object.values(issueMap))
+                        issue.isFixed = true;
             }
         }
         return touchedFiles;
@@ -99,7 +85,50 @@ export class IssueFixer {
                 }
             }
             await save(absFilePath, pkg);
-            touchedFiles.add(filePath);
+            touchedFiles.add(absFilePath);
+        }
+        return touchedFiles;
+    }
+    async removeUnusedCatalogEntries(issues) {
+        const touchedFiles = new Set();
+        if (!this.options.isFixCatalog)
+            return touchedFiles;
+        const filePaths = new Set(Object.keys(issues.catalog));
+        for (const filePath of filePaths) {
+            if (['.yml', '.yaml'].includes(extname(filePath))) {
+                const absFilePath = join(this.options.cwd, filePath);
+                const fileContent = await readFile(absFilePath, 'utf-8');
+                const issuesForFile = Object.values(issues.catalog[filePath]);
+                const takeLine = (issue) => issue.fixes.map(fix => fix[0]);
+                const remove = new Set(issuesForFile.flatMap(takeLine));
+                const keep = (_, i) => !remove.has(i + 1);
+                await writeFile(absFilePath, fileContent.split('\n').filter(keep).join('\n'));
+                for (const issue of issuesForFile)
+                    issue.isFixed = true;
+                touchedFiles.add(filePath);
+            }
+            else {
+                const absFilePath = join(this.options.cwd, filePath);
+                const pkg = await load(absFilePath);
+                const catalog = pkg.catalog || (!Array.isArray(pkg.workspaces) && pkg.workspaces?.catalog);
+                const catalogs = pkg.catalogs || (!Array.isArray(pkg.workspaces) && pkg.workspaces?.catalogs);
+                for (const [key, issue] of Object.entries(issues.catalog[filePath])) {
+                    if (issue.parentSymbol === DEFAULT_CATALOG) {
+                        if (catalog) {
+                            delete catalog[issue.symbol];
+                            issues.catalog[filePath][key].isFixed = true;
+                        }
+                    }
+                    else {
+                        if (catalogs && issue.parentSymbol) {
+                            delete catalogs[issue.parentSymbol][issue.symbol];
+                            issues.catalog[filePath][key].isFixed = true;
+                        }
+                    }
+                }
+                await save(absFilePath, pkg);
+                touchedFiles.add(absFilePath);
+            }
         }
         return touchedFiles;
     }

package/dist/JsonCatalogPeeker.d.ts

@@ -0,0 +1,12 @@
+export declare class JsonCatalogPeeker {
+    private fileContent;
+    private lines;
+    private sections;
+    private ready;
+    constructor(fileContent: string);
+    private init;
+    getLocation(parentSymbol: string, symbol: string): {
+        line: number;
+        col: number;
+    } | undefined;
+}

package/dist/JsonCatalogPeeker.js

@@ -0,0 +1,68 @@
+import { DEFAULT_CATALOG } from './util/catalog.js';
+export class JsonCatalogPeeker {
+    fileContent;
+    lines = [];
+    sections = {};
+    ready = false;
+    constructor(fileContent) {
+        this.fileContent = fileContent;
+    }
+    init() {
+        this.lines = this.fileContent.split('\n');
+        let inCatalogs = false;
+        let catalogName;
+        let braceLevel = 0;
+        for (let i = 0; i < this.lines.length; i++) {
+            const line = this.lines[i];
+            const trimmedLine = line.trim();
+            if (catalogName) {
+                if (line.includes('{'))
+                    braceLevel++;
+                if (line.includes('}'))
+                    braceLevel--;
+                if (braceLevel === 0) {
+                    this.sections[catalogName].end = i;
+                    catalogName = undefined;
+                }
+            }
+            else if (trimmedLine.startsWith('"catalog":')) {
+                catalogName = DEFAULT_CATALOG;
+                this.sections[catalogName] = { start: i, end: 0 };
+                braceLevel = (line.match(/{/g) ?? []).length - (line.match(/}/g) ?? []).length;
+                if (braceLevel === 0) {
+                    this.sections[catalogName].end = i;
+                    catalogName = undefined;
+                }
+            }
+            else if (trimmedLine.startsWith('"catalogs":')) {
+                inCatalogs = true;
+            }
+            else if (inCatalogs) {
+                if (trimmedLine.startsWith('}')) {
+                    inCatalogs = false;
+                    continue;
+                }
+                const match = trimmedLine.match(/"(.*?)"/);
+                if (match) {
+                    catalogName = match[1];
+                    this.sections[catalogName] = { start: i, end: 0 };
+                    braceLevel = (line.match(/{/g) ?? []).length - (line.match(/}/g) ?? []).length;
+                }
+            }
+        }
+        this.ready = true;
+    }
+    getLocation(parentSymbol, symbol) {
+        if (!this.ready)
+            this.init();
+        const section = this.sections[parentSymbol];
+        if (!section)
+            return;
+        for (let i = section.start + 1; i < section.end; i++) {
+            const line = this.lines[i];
+            if (line.trim().startsWith(`"${symbol}":`)) {
+                return { line: i + 1, col: line.indexOf(`"${symbol}"`) + 1 };
+            }
+        }
+    }
+}

package/dist/PackagePeeker.js

@@ -22,6 +22,7 @@ export class PackagePeeker {
                 this.sections[section] = { startLine: i, startPos: pos };
             pos += line.length + 1;
         }
+        this.ready = true;
     }
     getLocation(type, packageName) {
         if (!this.ready)

package/dist/YamlCatalogPeeker.d.ts

@@ -0,0 +1,12 @@
+export declare class YamlCatalogPeeker {
+    private fileContent;
+    private lines;
+    private sections;
+    private ready;
+    constructor(fileContent: string);
+    private init;
+    getLocation(parentSymbol: string, symbol: string): {
+        line: number;
+        col: number;
+    } | undefined;
+}

package/dist/YamlCatalogPeeker.js

@@ -0,0 +1,66 @@
+import { DEFAULT_CATALOG } from './util/catalog.js';
+function matchesKey(line, indent, key) {
+    return (line.startsWith(`${indent}${key}:`) ||
+        line.startsWith(`${indent}"${key}":`) ||
+        line.startsWith(`${indent}'${key}':`));
+}
+export class YamlCatalogPeeker {
+    fileContent;
+    lines = [];
+    sections = {};
+    ready = false;
+    constructor(fileContent) {
+        this.fileContent = fileContent;
+    }
+    init() {
+        this.lines = this.fileContent.split('\n');
+        for (let i = 0; i < this.lines.length; i++) {
+            const line = this.lines[i];
+            if (line.startsWith('catalog:')) {
+                this.sections.catalog = i;
+            }
+            else if (line.startsWith('catalogs:')) {
+                this.sections.catalogs = i;
+            }
+        }
+        this.ready = true;
+    }
+    getLocation(parentSymbol, symbol) {
+        if (!this.ready)
+            this.init();
+        const isDefault = parentSymbol === DEFAULT_CATALOG;
+        const startLine = this.sections[isDefault ? 'catalog' : 'catalogs'];
+        if (typeof startLine === 'undefined')
+            return;
+        if (isDefault) {
+            for (let i = startLine + 1; i < this.lines.length; i++) {
+                const line = this.lines[i];
+                if (!line.startsWith('  '))
+                    break;
+                if (matchesKey(line, '  ', symbol)) {
+                    return { line: i + 1, col: line.indexOf(symbol) + 1 };
+                }
+            }
+        }
+        else {
+            let inTargetCatalog = false;
+            for (let i = startLine + 1; i < this.lines.length; i++) {
+                const line = this.lines[i];
+                if (!line.startsWith('  '))
+                    break;
+                if (matchesKey(line, '  ', parentSymbol)) {
+                    inTargetCatalog = true;
+                }
+                else if (inTargetCatalog) {
+                    if (!line.startsWith('    ')) {
+                        inTargetCatalog = false;
+                        continue;
+                    }
+                    if (matchesKey(line, '    ', symbol)) {
+                        return { line: i + 1, col: line.indexOf(symbol) + 1 };
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/binaries/bash-parser.js

@@ -17,7 +17,7 @@ export const getDependenciesFromScript = (script, options) => {
     if (!script)
         return [];
     const fromArgs = (args, opts) => {
-        if (args.length === 0 || !isValidBinary(args[0]))
+        if (args.length === 0 || !isValidBinary(args[0].split(' ')[0]))
             return [];
         return getDependenciesFromScript(args.filter(arg => arg !== '--').join(' '), {
             ...options,

package/dist/compilers/index.d.ts

@@ -229,6 +229,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    mdx?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     mdxlint?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -815,6 +820,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        mdx?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         mdxlint?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1186,10 +1196,10 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         ignoreUnresolved?: (string | RegExp)[] | undefined;
         includeEntryExports?: boolean | undefined;
     }> | undefined;
-    include?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates")[] | undefined;
-    exclude?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates")[] | undefined;
+    include?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates" | "catalog")[] | undefined;
+    exclude?: ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates" | "catalog")[] | undefined;
     $schema?: string | undefined;
-    rules?: Partial<Record<"files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates", "error" | "warn" | "off">> | undefined;
+    rules?: Partial<Record<"files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates" | "catalog", "error" | "warn" | "off">> | undefined;
     entry?: string | string[] | undefined;
     project?: string | string[] | undefined;
     paths?: Record<string, string[]> | undefined;
@@ -1200,7 +1210,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     ignoreMembers?: (string | RegExp)[] | undefined;
     ignoreUnresolved?: (string | RegExp)[] | undefined;
     ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
-    ignoreIssues?: Record<string, ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates")[]> | undefined;
+    ignoreIssues?: Record<string, ("files" | "dependencies" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "exports" | "nsExports" | "types" | "nsTypes" | "enumMembers" | "classMembers" | "duplicates" | "catalog")[]> | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
     compilers?: Record<string, true | ((filename: string, contents: string) => string) | ((filename: string, contents: string) => Promise<string>)> | undefined;

package/dist/constants.d.ts

@@ -15,7 +15,7 @@ export declare const IGNORED_DEPENDENCIES: Set<string>;
 export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;
 export declare const FOREIGN_FILE_EXTENSIONS: Set<string>;
 export declare const IGNORE_DEFINITELY_TYPED: Set<string>;
-export declare const ISSUE_TYPES: readonly ["files", "dependencies", "devDependencies", "optionalPeerDependencies", "unlisted", "binaries", "unresolved", "exports", "nsExports", "types", "nsTypes", "enumMembers", "classMembers", "duplicates"];
+export declare const ISSUE_TYPES: readonly ["files", "dependencies", "devDependencies", "optionalPeerDependencies", "unlisted", "binaries", "unresolved", "exports", "nsExports", "types", "nsTypes", "enumMembers", "classMembers", "duplicates", "catalog"];
 export declare const ISSUE_TYPE_TITLE: {
     readonly files: "Unused files";
     readonly _files: "Unused files";
@@ -32,6 +32,7 @@ export declare const ISSUE_TYPE_TITLE: {
     readonly enumMembers: "Unused exported enum members";
     readonly classMembers: "Unused exported class members";
     readonly duplicates: "Duplicate exports";
+    readonly catalog: "Unused catalog entries";
 };
 export declare const SYMBOL_TYPE: {
     readonly CLASS: "class";
@@ -49,3 +50,10 @@ export declare const FIX_FLAGS: {
     readonly EMPTY_DECLARATION: number;
     readonly WITH_NEWLINE: number;
 };
+export declare const IMPORT_MODIFIERS: {
+    readonly NONE: 0;
+    readonly RE_EXPORT: number;
+    readonly TYPE_ONLY: number;
+    readonly ENTRY: number;
+    readonly OPTIONAL: number;
+};

package/dist/constants.js

@@ -172,6 +172,7 @@ export const ISSUE_TYPES = [
     'enumMembers',
     'classMembers',
     'duplicates',
+    'catalog',
 ];
 export const ISSUE_TYPE_TITLE = {
     files: 'Unused files',
@@ -189,6 +190,7 @@ export const ISSUE_TYPE_TITLE = {
     enumMembers: 'Unused exported enum members',
     classMembers: 'Unused exported class members',
     duplicates: 'Duplicate exports',
+    catalog: 'Unused catalog entries',
 };
 export const SYMBOL_TYPE = {
     CLASS: 'class',
@@ -206,3 +208,10 @@ export const FIX_FLAGS = {
     EMPTY_DECLARATION: 1 << 1,
     WITH_NEWLINE: 1 << 2,
 };
+export const IMPORT_MODIFIERS = {
+    NONE: 0,
+    RE_EXPORT: 1 << 0,
+    TYPE_ONLY: 1 << 1,
+    ENTRY: 1 << 2,
+    OPTIONAL: 1 << 3,
+};

package/dist/graph/analyze.d.ts

@@ -1,3 +1,4 @@
+import type { CatalogCounselor } from '../CatalogCounselor.js';
 import type { ConfigurationChief } from '../ConfigurationChief.js';
 import type { ConsoleStreamer } from '../ConsoleStreamer.js';
 import type { DependencyDeputy } from '../DependencyDeputy.js';
@@ -8,6 +9,7 @@ import type { ModuleGraph } from '../types/module-graph.js';
 import type { MainOptions } from '../util/create-options.js';
 interface AnalyzeOptions {
     analyzedFiles: Set<string>;
+    counselor: CatalogCounselor;
     chief: ConfigurationChief;
     collector: IssueCollector;
     deputy: DependencyDeputy;
@@ -19,5 +21,5 @@ interface AnalyzeOptions {
     unreferencedFiles: Set<string>;
     options: MainOptions;
 }
-export declare const analyze: ({ analyzedFiles, chief, collector, deputy, entryPaths, factory, fixer, graph, streamer, unreferencedFiles, options, }: AnalyzeOptions) => Promise<() => Promise<void>>;
+export declare const analyze: ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, factory, graph, streamer, unreferencedFiles, options, }: AnalyzeOptions) => Promise<() => Promise<void>>;
 export {};