knip 5.70.1 → 5.71.0

package/dist/plugins/vite/helpers.js

@@ -4,7 +4,7 @@ export const getReactBabelPlugins = (sourceFile) => {
     const babelPlugins = [];
     const importMap = getImportMap(sourceFile);
     const reactPluginNames = new Set();
-    for (const [importName, importPath] of importMap.entries()) {
+    for (const [importName, importPath] of importMap) {
         if (importPath.includes('@vitejs/plugin-react')) {
             reactPluginNames.add(importName);
         }

package/dist/reporters/codeclimate.js

@@ -1,7 +1,6 @@
 import { createHash } from 'node:crypto';
-import { ISSUE_TYPE_TITLE } from '../constants.js';
 import { toRelative } from '../util/path.js';
-import { getIssueTypeTitle } from './util/util.js';
+import { getIssuePrefix, getIssueTypeTitle } from './util/util.js';
 export default async ({ report, issues, cwd }) => {
     const entries = [];
     for (const [type, isReportType] of Object.entries(report)) {
@@ -52,15 +51,12 @@ function convertSeverity(severity) {
             return 'info';
     }
 }
-function getPrefix(type) {
-    return ISSUE_TYPE_TITLE[type].replace(/ies$/, 'y').replace(/s$/, '');
-}
 function getIssueDescription({ type, symbol, symbols, parentSymbol }) {
     const symbolDescription = symbols ? `${symbols.map(s => s.symbol).join(', ')}` : symbol;
-    return `${getPrefix(type)}: ${symbolDescription}${parentSymbol ? ` (${parentSymbol})` : ''}`;
+    return `${getIssuePrefix(type)}: ${symbolDescription}${parentSymbol ? ` (${parentSymbol})` : ''}`;
 }
 function getSymbolDescription({ type, symbol, parentSymbol, }) {
-    return `${getPrefix(type)}: ${symbol.symbol}${parentSymbol ? ` (${parentSymbol})` : ''}`;
+    return `${getIssuePrefix(type)}: ${symbol.symbol}${parentSymbol ? ` (${parentSymbol})` : ''}`;
 }
 function createLocation(filePath, cwd, line, col) {
     if (col !== undefined) {

package/dist/reporters/util/util.d.ts

@@ -1,5 +1,5 @@
 import { ISSUE_TYPE_TITLE } from '../../constants.js';
-import type { Issue, IssueSeverity, IssueSymbol } from '../../types/issues.js';
+import type { Issue, IssueSeverity, IssueSymbol, IssueType } from '../../types/issues.js';
 import { Table } from '../../util/table.js';
 export declare const dim: import("picocolors/types.js").Formatter;
 export declare const bright: import("picocolors/types.js").Formatter;
@@ -23,4 +23,5 @@ export declare const convert: (issue: Issue | IssueSymbol) => {
 export declare const getTableForType: (issues: Issue[], cwd: string, options?: {
     isUseColors?: boolean;
 }) => Table;
+export declare const getIssuePrefix: (type: IssueType) => string;
 export {};

package/dist/reporters/util/util.js

@@ -54,3 +54,4 @@ export const getTableForType = (issues, cwd, options = { isUseColors: true }) =>
     }
     return table;
 };
+export const getIssuePrefix = (type) => ISSUE_TYPE_TITLE[type].replace(/ies$/, 'y').replace(/s$/, '');

package/dist/reporters/watch.js

@@ -23,7 +23,7 @@ export default (options, { issues, streamer, duration, size }) => {
     }
     const mem = perfObserver.getCurrentMemUsageInMb();
     const ms = duration ?? perfObserver.getCurrentDurationInMs();
-    const summary = `${size} files in ${prettyMilliseconds(ms)} (${mem}MB)`;
+    const summary = `${size} files (${prettyMilliseconds(ms)} • ${mem}MB)`;
     const messages = totalIssues === 0
         ? ['✂️  Excellent, Knip found no issues.', '', picocolors.gray(summary)]
         : [...lines, '', picocolors.gray(summary)];

package/dist/run.d.ts

@@ -0,0 +1,25 @@
+import { ConsoleStreamer } from './ConsoleStreamer.js';
+import type { MainOptions } from './util/create-options.js';
+export declare const run: (options: MainOptions) => Promise<{
+    results: {
+        issues: import("./types/issues.js").Issues;
+        counters: import("./types/issues.js").Counters;
+        tagHints: Set<import("./types/issues.js").TagHint>;
+        configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
+        includedWorkspaceDirs: string[];
+    };
+    watchHandler: {
+        listener: import("fs").WatchListener<string | Buffer<ArrayBufferLike>>;
+        handleFileChanges: (changes: {
+            type: "added" | "deleted" | "modified";
+            filePath: string;
+        }[]) => Promise<{
+            duration: number;
+            mem: number;
+        }>;
+        getEntryPaths: () => Set<string>;
+        getGraph: () => import("./types/module-graph.js").ModuleGraph;
+        getIssues: () => import("./types/issues.js").Issues;
+    } | undefined;
+    streamer: ConsoleStreamer;
+}>;

package/dist/run.js

@@ -0,0 +1,107 @@
+import { watch } from 'node:fs';
+import { formatly } from 'formatly';
+import { CatalogCounselor } from './CatalogCounselor.js';
+import { ConfigurationChief } from './ConfigurationChief.js';
+import { ConsoleStreamer } from './ConsoleStreamer.js';
+import { DependencyDeputy } from './DependencyDeputy.js';
+import { analyze } from './graph/analyze.js';
+import { build } from './graph/build.js';
+import { IssueCollector } from './IssueCollector.js';
+import { IssueFixer } from './IssueFixer.js';
+import { PrincipalFactory } from './PrincipalFactory.js';
+import watchReporter from './reporters/watch.js';
+import { debugLogArray, debugLogObject } from './util/debug.js';
+import { getGitIgnoredHandler } from './util/glob-core.js';
+import { getWatchHandler } from './util/watch.js';
+export const run = async (options) => {
+    debugLogObject('*', 'Unresolved configuration', options);
+    debugLogObject('*', 'Included issue types', options.includedIssueTypes);
+    const chief = new ConfigurationChief(options);
+    const deputy = new DependencyDeputy(options);
+    const factory = new PrincipalFactory();
+    const streamer = new ConsoleStreamer(options);
+    const fixer = new IssueFixer(options);
+    const collector = new IssueCollector(options);
+    const counselor = new CatalogCounselor(options);
+    streamer.cast('Reading workspace configuration');
+    const workspaces = await chief.getWorkspaces();
+    const isGitIgnored = await getGitIgnoredHandler(options);
+    collector.setIgnoreIssues(chief.config.ignoreIssues);
+    debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
+    debugLogObject('*', 'Included workspace configs', () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors })));
+    const { graph, entryPaths, analyzedFiles, unreferencedFiles, analyzeSourceFile } = await build({
+        chief,
+        collector,
+        counselor,
+        deputy,
+        factory,
+        isGitIgnored,
+        streamer,
+        workspaces,
+        options,
+    });
+    const reAnalyze = await analyze({
+        analyzedFiles,
+        counselor,
+        chief,
+        collector,
+        deputy,
+        entryPaths,
+        factory,
+        fixer,
+        graph,
+        streamer,
+        unreferencedFiles,
+        options,
+    });
+    let watchHandler;
+    if (options.isWatch) {
+        const isIgnored = (filePath) => (!!options.cacheLocation && filePath.startsWith(options.cacheLocation)) ||
+            filePath.includes('/.git/') ||
+            isGitIgnored(filePath);
+        const onFileChange = options.isWatch
+            ? ({ issues, duration }) => watchReporter(options, { issues, streamer, size: analyzedFiles.size, duration })
+            : undefined;
+        watchHandler = await getWatchHandler(options, {
+            analyzedFiles,
+            analyzeSourceFile,
+            chief,
+            collector,
+            analyze: reAnalyze,
+            factory,
+            graph,
+            isIgnored,
+            onFileChange,
+            unreferencedFiles,
+            entryPaths,
+        });
+        if (options.isWatch)
+            watch('.', { recursive: true }, watchHandler.listener);
+    }
+    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
+    if (options.isFix) {
+        const touchedFiles = await fixer.fixIssues(issues);
+        if (options.isFormat) {
+            const report = await formatly(Array.from(touchedFiles));
+            if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
+                debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
+            }
+            else {
+                debugLogObject('*', 'Formatting files failed', report);
+            }
+        }
+    }
+    if (!options.isWatch)
+        streamer.clear();
+    return {
+        results: {
+            issues,
+            counters,
+            tagHints,
+            configurationHints,
+            includedWorkspaceDirs: chief.includedWorkspaces.map(w => w.dir),
+        },
+        watchHandler,
+        streamer,
+    };
+};

package/dist/types/issues.d.ts

@@ -1,13 +1,13 @@
 import type { SYMBOL_TYPE } from '../constants.js';
 import type { Fixes } from './exports.js';
 export type SymbolType = (typeof SYMBOL_TYPE)[keyof typeof SYMBOL_TYPE];
-export type IssueSymbol = {
+export interface IssueSymbol {
     symbol: string;
     pos?: number;
     line?: number;
     col?: number;
-};
-export type Issue = {
+}
+export interface Issue {
     type: SymbolIssueType;
     filePath: string;
     workspace: string;
@@ -22,7 +22,7 @@ export type Issue = {
     col?: number;
     fixes: Fixes;
     isFixed?: boolean;
-};
+}
 export type IssueSet = Set<string>;
 export type IssueRecords = Record<string, Record<string, Issue>>;
 export type Issues = {

package/dist/types/module-graph.d.ts

@@ -1,12 +1,17 @@
 import type ts from 'typescript';
 import type { Fix, Fixes } from './exports.js';
 import type { IssueSymbol, SymbolType } from './issues.js';
-type Identifier = string;
+export type Identifier = string;
 type FilePath = string;
 type NamespaceOrAlias = string;
 type Reference = string;
 type References = Set<Reference>;
 type Tags = Set<string>;
+interface SourceLocation {
+    pos: number;
+    line: number;
+    col: number;
+}
 export type IdToFileMap = Map<Identifier, Set<FilePath>>;
 export type IdToNsToFileMap = Map<Identifier, Map<NamespaceOrAlias, Set<FilePath>>>;
 export type ImportMaps = {
@@ -19,24 +24,21 @@ export type ImportMaps = {
     reExportedNs: IdToFileMap;
 };
 export type ImportMap = Map<FilePath, ImportMaps>;
-export type Import = {
+export interface Import extends SourceLocation {
     specifier: string;
-    identifier: string;
-    pos?: number;
-    line?: number;
-    col?: number;
-};
-export interface Export {
+    filePath: string | undefined;
+    identifier: string | undefined;
+    isTypeOnly: boolean;
+}
+export interface Export extends SourceLocation {
     identifier: Identifier;
-    pos: number;
-    line: number;
-    col: number;
     type: SymbolType;
     members: ExportMember[];
     jsDocTags: Tags;
     refs: [number, boolean];
     fixes: Fixes;
     symbol?: ts.Symbol;
+    isReExport?: boolean;
 }
 export type ExportMember = {
     identifier: Identifier;
@@ -50,7 +52,7 @@ export type ExportMember = {
     jsDocTags: Tags;
 };
 export type ExportMap = Map<Identifier, Export>;
-export type Imports = Set<[Import, FilePath]>;
+export type Imports = Set<Import>;
 export type FileNode = {
     imports: {
         internal: ImportMap;

package/dist/typescript/ast-helpers.d.ts

@@ -58,6 +58,10 @@ export declare const isModuleExportsAccess: (node: ts.PropertyAccessExpression)
 export declare const getImportMap: (sourceFile: ts.SourceFile) => Map<string, string>;
 export declare const getDefaultImportName: (importMap: ReturnType<typeof getImportMap>, specifier: string) => string | undefined;
 export declare const getPropertyValues: (node: ts.ObjectLiteralExpression, propertyName: string) => Set<string>;
+export declare function getThenBindings(callExpression: ts.CallExpression): {
+    identifier: string;
+    pos: number;
+}[] | undefined;
 export declare const getAccessedIdentifiers: (identifier: string, scope: ts.Node) => {
     identifier: string;
     pos: number;

package/dist/typescript/ast-helpers.js

@@ -203,6 +203,7 @@ export const isConsiderReferencedNS = (node) => ts.isPropertyAssignment(node.par
     ts.isSpreadAssignment(node.parent) ||
     ts.isArrayLiteralExpression(node.parent) ||
     ts.isExportAssignment(node.parent) ||
+    ts.isConditionalExpression(node.parent) ||
     (ts.isVariableDeclaration(node.parent) && node.parent.initializer === node) ||
     ts.isTypeQueryNode(node.parent.parent);
 export const isInOpaqueExpression = (node) => ts.isAwaitExpression(node.parent)
@@ -263,6 +264,18 @@ export const getImportMap = (sourceFile) => {
                     importMap.set(element.name.text, importPath);
             }
         }
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (declaration.initializer &&
+                    isRequireCall(declaration.initializer) &&
+                    ts.isIdentifier(declaration.name) &&
+                    ts.isStringLiteral(declaration.initializer.arguments[0])) {
+                    const importName = declaration.name.text;
+                    const importPath = stripQuotes(declaration.initializer.arguments[0].text);
+                    importMap.set(importName, importPath);
+                }
+            }
+        }
     }
     return importMap;
 };
@@ -304,6 +317,32 @@ const isMatchAlias = (expression, identifier) => {
         expression = expression.expression;
     return expression && ts.isIdentifier(expression) && expression.escapedText === identifier;
 };
+export function getThenBindings(callExpression) {
+    if (!ts.isFunctionLike(callExpression.arguments[0]))
+        return;
+    const fn = callExpression.arguments[0];
+    const param = fn.parameters[0];
+    if (!param)
+        return;
+    if (ts.isIdentifier(param.name)) {
+        const paramName = param.name.escapedText;
+        const identifiers = [];
+        for (const node of findDescendants(fn.body, ts.isPropertyAccessExpression)) {
+            if (ts.isIdentifier(node.expression) && node.expression.escapedText === paramName) {
+                identifiers.push({ identifier: String(node.name.escapedText), pos: node.name.pos });
+            }
+        }
+        if (identifiers.length > 0)
+            return identifiers;
+    }
+    else if (ts.isObjectBindingPattern(param.name)) {
+        return param.name.elements.map(element => {
+            const identifier = (element.propertyName ?? element.name).getText();
+            const alias = element.propertyName ? element.name.getText() : undefined;
+            return { identifier, alias, pos: element.pos };
+        });
+    }
+}
 export const getAccessedIdentifiers = (identifier, scope) => {
     const identifiers = [];
     function visit(node) {
@@ -328,6 +367,15 @@ export const getAccessedIdentifiers = (identifier, scope) => {
                 }
             }
         }
+        else if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            isMatchAlias(node.expression.expression, identifier) &&
+            node.expression.name.escapedText === 'then') {
+            const accessed = getThenBindings(node);
+            if (accessed)
+                for (const acc of accessed)
+                    identifiers.push(acc);
+        }
         ts.forEachChild(node, visit);
     }
     visit(scope);

package/dist/typescript/get-imports-and-exports.js

@@ -79,7 +79,15 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         const { symbol, filePath, namespace, specifier, modifiers } = options;
         const identifier = options.identifier ?? (modifiers & IMPORT_MODIFIERS.OPAQUE ? OPAQUE : SIDE_EFFECTS);
         const isStar = identifier === IMPORT_STAR;
-        imports.add([{ specifier, identifier, pos: options.pos, line: options.line, col: options.col }, filePath]);
+        imports.add({
+            filePath,
+            specifier,
+            identifier: namespace ?? options.identifier,
+            pos: options.pos,
+            line: options.line,
+            col: options.col,
+            isTypeOnly: !!(modifiers & IMPORT_MODIFIERS.TYPE_ONLY),
+        });
         const file = internal.get(filePath);
         const importMaps = file ?? createImports();
         if (!file)
@@ -105,7 +113,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                     addNsValue(importMaps.importedAs, identifier, nsOrAlias, sourceFile.fileName);
                 }
             }
-            else if (identifier !== SIDE_EFFECTS && identifier !== IMPORT_STAR) {
+            else if (identifier !== IMPORT_STAR) {
                 addValue(importMaps.imported, identifier, sourceFile.fileName);
             }
             if (symbol)
@@ -144,11 +152,13 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                     const pos = node.moduleSpecifier?.getStart() ?? opts.pos;
                     const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
                     external.add({
+                        filePath,
                         specifier: sanitizedSpecifier,
                         identifier: opts.identifier ?? SIDE_EFFECTS,
                         pos: opts.pos,
                         line: line + 1,
                         col: character + 2,
+                        isTypeOnly: !!(opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY),
                     });
                 }
             }
@@ -167,20 +177,24 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
             const pos = 'moduleSpecifier' in node ? node.moduleSpecifier.pos : node.pos;
             const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
             unresolved.add({
+                filePath: undefined,
                 specifier: opts.specifier,
                 identifier: opts.identifier ?? SIDE_EFFECTS,
                 pos,
                 line: line + 1,
                 col: character + 2,
+                isTypeOnly: !!(opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY),
             });
         }
     };
     const addExport = ({ node, symbol, identifier, type, pos, members = [], fix }) => {
         if (skipExports)
             return;
+        let isReExport = Boolean(node.parent?.parent && ts.isExportDeclaration(node.parent.parent) && node.parent.parent.moduleSpecifier);
         if (symbol) {
             const importedSymbolFilePath = importedInternalSymbols.get(symbol);
             if (importedSymbolFilePath) {
+                isReExport = true;
                 const importId = String(symbol.escapedName);
                 const internalImport = internal.get(importedSymbolFilePath);
                 if (internalImport) {
@@ -203,7 +217,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
             const members = [...(item.members ?? []), ...exportMembers];
             const tags = new Set([...(item.jsDocTags ?? []), ...jsDocTags]);
             const fixes = fix ? [...(item.fixes ?? []), fix] : item.fixes;
-            exports.set(identifier, { ...item, members, jsDocTags: tags, fixes });
+            exports.set(identifier, { ...item, members, jsDocTags: tags, fixes, isReExport });
         }
         else {
             const { line, character } = node.getSourceFile().getLineAndCharacterOfPosition(pos);
@@ -218,6 +232,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 col: character + 1,
                 fixes: fix ? [fix] : [],
                 refs: [0, false],
+                isReExport,
             });
         }
         if (!jsDocTags.has(ALIAS_TAG)) {

package/dist/typescript/visitors/dynamic-imports/importCall.js

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import { IMPORT_MODIFIERS } from '../../../constants.js';
-import { findAncestor, findDescendants, getAccessedIdentifiers, isAccessExpression, isImportCall, isInOpaqueExpression, isTopLevel, stripQuotes, } from '../../ast-helpers.js';
+import { findAncestor, findDescendants, getAccessedIdentifiers, getThenBindings, isAccessExpression, isImportCall, isInOpaqueExpression, isTopLevel, stripQuotes, } from '../../ast-helpers.js';
 import { importVisitor as visit } from '../index.js';
 const getSymbol = (node, isTopLevel) => (isTopLevel ? node.symbol : undefined);
 export default visit(() => true, node => {
@@ -20,24 +20,10 @@ export default visit(() => true, node => {
                         const pos = accessExpression.name.pos;
                         if (identifier === 'then') {
                             const callExpression = node.parent.parent;
-                            if (ts.isCallExpression(callExpression) && ts.isFunctionLike(callExpression.arguments[0])) {
-                                const arg = callExpression.arguments[0].parameters[0];
-                                if (arg && ts.isIdentifier(arg.name)) {
-                                    const argName = arg.name.escapedText;
-                                    const accessExpressions = findDescendants(callExpression.arguments[0].body, ts.isPropertyAccessExpression).filter(binding => binding.expression.getText() === argName);
-                                    if (accessExpressions.length > 0) {
-                                        return accessExpressions.map(binding => {
-                                            const identifier = String(binding.name.escapedText);
-                                            return { identifier, specifier, pos, modifiers };
-                                        });
-                                    }
-                                }
-                                else if (arg && ts.isObjectBindingPattern(arg.name)) {
-                                    return arg.name.elements.map(element => {
-                                        const identifier = (element.propertyName ?? element.name).getText();
-                                        const alias = element.propertyName ? element.name.getText() : undefined;
-                                        return { identifier, alias, specifier, pos: element.pos, modifiers };
-                                    });
+                            if (ts.isCallExpression(callExpression)) {
+                                const accessed = getThenBindings(callExpression);
+                                if (accessed && accessed.length > 0) {
+                                    return accessed.map(acc => ({ ...acc, specifier, modifiers }));
                                 }
                             }
                             return { identifier: 'default', specifier, pos, modifiers };

package/dist/typescript/visitors/dynamic-imports/jsDocType.js

@@ -13,16 +13,18 @@ const getImportSpecifiers = (node) => {
                     specifier: importClause.literal.text,
                     identifier,
                     pos: node.qualifier?.getStart() ?? importClause.literal.pos,
-                    modifiers: IMPORT_MODIFIERS.NONE,
+                    modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
                 });
             }
         }
         if (supportsJSDocImportTag && ts.isJSDocImportTag(node) && ts.isStringLiteralLike(node.moduleSpecifier)) {
-            if (node.importClause?.namedBindings && ts.isNamedImportBindings(node.importClause.namedBindings)) {
-                const bindings = node.importClause.namedBindings;
+            const moduleSpecifier = node.moduleSpecifier;
+            const importClause = node.importClause;
+            if (moduleSpecifier && importClause?.namedBindings && ts.isNamedImportBindings(importClause.namedBindings)) {
+                const bindings = importClause.namedBindings;
                 if (ts.isNamespaceImport(bindings)) {
                     imports.push({
-                        specifier: node.moduleSpecifier.text,
+                        specifier: moduleSpecifier.text,
                         identifier: IMPORT_STAR,
                         pos: bindings.name.getStart(),
                         modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
@@ -31,7 +33,7 @@ const getImportSpecifiers = (node) => {
                 else {
                     for (const element of bindings.elements) {
                         imports.push({
-                            specifier: node.moduleSpecifier.text,
+                            specifier: moduleSpecifier.text,
                             identifier: String((element.propertyName ?? element.name).escapedText),
                             pos: element.name.getStart(),
                             modifiers: IMPORT_MODIFIERS.TYPE_ONLY,

package/dist/typescript/visitors/imports/importDeclaration.js

@@ -9,6 +9,7 @@ export default visit(() => true, node => {
             return { specifier, identifier: undefined, pos: node.pos, modifiers: IMPORT_MODIFIERS.SIDE_EFFECTS };
         }
         const imports = [];
+        const modifiers = node.importClause.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE;
         if (isDefaultImport(node)) {
             imports.push({
                 identifier: 'default',
@@ -16,7 +17,7 @@ export default visit(() => true, node => {
                 specifier,
                 symbol: node.importClause.symbol,
                 pos: node.importClause.name?.getStart() ?? node.getStart(),
-                modifiers: IMPORT_MODIFIERS.NONE,
+                modifiers,
             });
         }
         if (node.importClause?.namedBindings) {
@@ -27,7 +28,7 @@ export default visit(() => true, node => {
                     specifier,
                     identifier: IMPORT_STAR,
                     pos: node.importClause.namedBindings.name.getStart(),
-                    modifiers: node.importClause?.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE,
+                    modifiers,
                 });
             }
             if (ts.isNamedImports(node.importClause.namedBindings)) {
@@ -38,7 +39,7 @@ export default visit(() => true, node => {
                         specifier,
                         symbol: element.symbol,
                         pos: element.name.getStart(),
-                        modifiers: node.importClause?.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE,
+                        modifiers,
                     });
                 }
             }
@@ -47,7 +48,7 @@ export default visit(() => true, node => {
                     specifier,
                     identifier: undefined,
                     pos: node.importClause.namedBindings.pos,
-                    modifiers: node.importClause?.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE,
+                    modifiers,
                 });
             }
         }

package/dist/util/create-options.js

@@ -115,7 +115,7 @@ export const createOptions = async (options) => {
         rules,
         tags,
         traceExport: parsedCLIArgs['trace-export'],
-        traceFile: parsedCLIArgs['trace-file'],
+        traceFile: parsedCLIArgs['trace-file'] ? toAbsolute(parsedCLIArgs['trace-file'], cwd) : undefined,
         tsConfigFile: parsedCLIArgs.tsConfig,
         workspace: options.workspace ?? parsedCLIArgs.workspace,
         workspaces,

package/dist/util/file-entry-cache.js

@@ -86,7 +86,7 @@ export class FileEntryCache {
     }
     reconcile() {
         this.removeNotFoundFiles();
-        for (const [entryName, cacheEntry] of this.normalizedEntries.entries()) {
+        for (const [entryName, cacheEntry] of this.normalizedEntries) {
             try {
                 const meta = this._getMetaForFileUsingMtimeAndSize(cacheEntry);
                 this.cache.set(entryName, meta);

package/dist/util/graph-sequencer.js

@@ -6,7 +6,7 @@ export function graphSequencer(graph, includedNodes = [...graph.keys()]) {
     const nodes = new Set(includedNodes);
     const visited = new Set();
     const outDegree = new Map();
-    for (const [from, edges] of graph.entries()) {
+    for (const [from, edges] of graph) {
         outDegree.set(from, 0);
         for (const to of edges) {
             if (nodes.has(from) && nodes.has(to)) {

package/dist/util/input.d.ts

@@ -10,6 +10,7 @@ export interface Input {
     containingFilePath?: string;
     allowIncludeExports?: boolean;
     skipExportsAnalysis?: boolean;
+    group?: string;
 }
 export interface ConfigInput extends Input {
     type: 'config';

package/dist/util/module-graph.js

@@ -2,21 +2,21 @@ export const getOrCreateFileNode = (graph, filePath) => graph.get(filePath) ?? c
 const updateImportMaps = (fromImportMaps, toImportMaps) => {
     for (const id of fromImportMaps.refs)
         toImportMaps.refs.add(id);
-    for (const [id, v] of fromImportMaps.imported.entries())
+    for (const [id, v] of fromImportMaps.imported)
         addValues(toImportMaps.imported, id, v);
-    for (const [id, v] of fromImportMaps.importedAs.entries())
+    for (const [id, v] of fromImportMaps.importedAs)
         addNsValues(toImportMaps.importedAs, id, v);
-    for (const [id, v] of fromImportMaps.importedNs.entries())
+    for (const [id, v] of fromImportMaps.importedNs)
         addValues(toImportMaps.importedNs, id, v);
-    for (const [id, v] of fromImportMaps.reExported.entries())
+    for (const [id, v] of fromImportMaps.reExported)
         addValues(toImportMaps.reExported, id, v);
-    for (const [id, v] of fromImportMaps.reExportedAs.entries())
+    for (const [id, v] of fromImportMaps.reExportedAs)
         addNsValues(toImportMaps.reExportedAs, id, v);
-    for (const [id, v] of fromImportMaps.reExportedNs.entries())
+    for (const [id, v] of fromImportMaps.reExportedNs)
         addValues(toImportMaps.reExportedNs, id, v);
 };
 export const updateImportMap = (file, importMap, graph) => {
-    for (const [importedFilePath, fileImportMaps] of importMap.entries()) {
+    for (const [importedFilePath, fileImportMaps] of importMap) {
         const importMaps = file.imports.internal.get(importedFilePath);
         if (!importMaps)
             file.imports.internal.set(importedFilePath, fileImportMaps);

package/dist/util/plugin.d.ts

@@ -4,6 +4,6 @@ export declare const hasDependency: (dependencies: Set<string>, values: (string
 export declare const normalizePluginConfig: (pluginConfig: RawPluginConfiguration) => boolean | {
     config: string[] | null;
     entry: string[] | null;
-    project: string[] | null;
+    project: string[];
 };
 export declare const loadConfigForPlugin: (configFilePath: string, plugin: Plugin, options: PluginOptions, pluginName: string) => Promise<any>;