knip 5.83.0 → 5.84.0

package/dist/{compilers/prisma.js → plugins/prisma/compiler.js}

@@ -1,4 +1,3 @@
-const condition = (hasDependency) => hasDependency('prisma');
 const directiveMatcher = /generator\s+(?!client)\w+\s*\{\s*provider\s*=\s*"([^"]+)"[^}]*\}/g;
 const compiler = (text) => {
     const imports = [];
@@ -10,4 +9,4 @@ const compiler = (text) => {
     }
     return imports.join('\n');
 };
-export default { condition, compiler };
+export default compiler;

package/dist/plugins/prisma/index.js

@@ -2,6 +2,7 @@ import { isDirectory } from '../../util/fs.js';
 import { toEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import compiler from './compiler.js';
 const title = 'Prisma';
 const enablers = ['prisma', /^@prisma\/.*/];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -30,6 +31,10 @@ const resolveConfig = async (config, options) => {
     }
     return inputs;
 };
+const registerCompilers = ({ registerCompiler, hasDependency }) => {
+    if (hasDependency('prisma'))
+        registerCompiler({ extension: '.prisma', compiler });
+};
 const args = {
     config: true,
     resolveInputs: (parsed, { cwd }) => {
@@ -48,5 +53,6 @@ const plugin = {
     config,
     args,
     resolveConfig,
+    registerCompilers,
 };
 export default plugin;

package/dist/plugins/react-native/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.js';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/react-native/index.js

@@ -0,0 +1,38 @@
+import { toDependency } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'React Native';
+const enablers = ['react-native'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['react-native.config.js'];
+const RN_CLI_PACKAGES = [
+    '@react-native-community/cli',
+    '@react-native-community/cli-platform-android',
+    '@react-native-community/cli-platform-ios',
+];
+const resolveConfig = async (config) => {
+    const inputs = [];
+    if (config.dependencies) {
+        for (const name of Object.keys(config.dependencies)) {
+            inputs.push(toDependency(name));
+        }
+    }
+    if (config.platforms) {
+        for (const platform of Object.values(config.platforms)) {
+            if (platform.npmPackageName)
+                inputs.push(toDependency(platform.npmPackageName));
+        }
+    }
+    return inputs;
+};
+const resolve = () => {
+    return RN_CLI_PACKAGES.map(pkg => toDependency(pkg, { optional: true }));
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+    resolve,
+};
+export default plugin;

package/dist/plugins/react-native/types.d.ts

@@ -0,0 +1,7 @@
+export type ReactNativeConfig = {
+    reactNativePath?: string;
+    dependencies?: Record<string, unknown>;
+    platforms?: Record<string, {
+        npmPackageName?: string;
+    }>;
+};

package/dist/plugins/react-native/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/svelte/compiler.d.ts

@@ -0,0 +1,2 @@
+declare const compiler: import("../../compilers/types.js").CompilerSync;
+export default compiler;

package/dist/plugins/svelte/compiler.js

@@ -0,0 +1,3 @@
+import { importsWithinScripts } from '../../compilers/compilers.js';
+const compiler = importsWithinScripts;
+export default compiler;

package/dist/plugins/svelte/index.js

@@ -1,13 +1,19 @@
 import { hasDependency } from '../../util/plugin.js';
 import { config as viteConfig } from '../vite/index.js';
+import compiler from './compiler.js';
 const title = 'Svelte';
 const enablers = ['svelte'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const entry = ['svelte.config.js', ...viteConfig];
+const registerCompilers = ({ registerCompiler, hasDependency }) => {
+    if (hasDependency('svelte'))
+        registerCompiler({ extension: '.svelte', compiler });
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
     entry,
+    registerCompilers,
 };
 export default plugin;

package/dist/plugins/tailwind/compiler.d.ts

@@ -0,0 +1,2 @@
+declare const compiler: (text: string) => string;
+export default compiler;

package/dist/{compilers/tailwind.js → plugins/tailwind/compiler.js}

@@ -1,5 +1,4 @@
-const condition = (hasDependency) => hasDependency('tailwindcss');
-const directiveMatcher = /@(?:import|config|source|plugin)\s+['"]([^'"]+)['"][^;]*;/g;
+const directiveMatcher = /@(?:import|config|plugin)\s+['"]([^'"]+)['"][^;]*;/g;
 const compiler = (text) => {
     const imports = [];
     let match;
@@ -9,4 +8,4 @@ const compiler = (text) => {
             imports.push(`import _$${index++} from '${match[1]}';`);
     return imports.join('\n');
 };
-export default { condition, compiler };
+export default compiler;

package/dist/plugins/tailwind/index.js

@@ -1,12 +1,18 @@
 import { hasDependency } from '../../util/plugin.js';
+import compiler from './compiler.js';
 const title = 'Tailwind';
 const enablers = ['tailwindcss'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const entry = ['tailwind.config.{js,cjs,mjs,ts}'];
+const registerCompilers = ({ registerCompiler, hasDependency }) => {
+    if (hasDependency('tailwindcss'))
+        registerCompiler({ extension: '.css', compiler });
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
     entry,
+    registerCompilers,
 };
 export default plugin;

package/dist/plugins/typescript/index.js

@@ -3,7 +3,7 @@ import { toConfig, toDeferResolve, toProductionDependency } from '../../util/inp
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'TypeScript';
-const enablers = ['typescript'];
+const enablers = ['typescript', '@typescript/native-preview'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['tsconfig.json'];
 const resolveConfig = async (localConfig, options) => {
@@ -32,7 +32,7 @@ const resolveConfig = async (localConfig, options) => {
     ]);
 };
 const args = {
-    binaries: ['tsc'],
+    binaries: ['tsc', 'tsgo'],
     string: ['project'],
     alias: { project: ['p'] },
     config: [['project', (p) => (p.endsWith('.json') ? p : join(p, 'tsconfig.json'))]],

package/dist/plugins/vite/helpers.d.ts

@@ -1,2 +1,4 @@
 import ts from 'typescript';
+import { type Input } from '../../util/input.js';
 export declare const getReactBabelPlugins: (sourceFile: ts.SourceFile) => string[];
+export declare const getIndexHtmlEntries: (rootDir: string) => Promise<Input[]>;

package/dist/plugins/vite/helpers.js

@@ -1,5 +1,8 @@
 import ts from 'typescript';
 import { findDescendants, getDefaultImportName, getImportMap, stripQuotes } from '../../typescript/ast-helpers.js';
+import { isFile, loadFile } from '../../util/fs.js';
+import { toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
 export const getReactBabelPlugins = (sourceFile) => {
     const babelPlugins = [];
     const importMap = getImportMap(sourceFile);
@@ -74,3 +77,23 @@ export const getReactBabelPlugins = (sourceFile) => {
     }
     return babelPlugins;
 };
+const moduleScriptPattern = /<script\b(?=[^>]*\btype\s*=\s*["']?module["']?)(?=[^>]*\bsrc\s*=\s*["']?([^"' >]+)["']?)[^>]*>/gi;
+const normalizeModuleScriptSrc = (value) => value.trim().replace(/^\//, '');
+const getModuleScriptSources = (html) => {
+    const matches = html.matchAll(moduleScriptPattern);
+    const sources = [];
+    for (const match of matches) {
+        const src = normalizeModuleScriptSrc(match[1]);
+        if (src)
+            sources.push(src);
+    }
+    return sources;
+};
+export const getIndexHtmlEntries = async (rootDir) => {
+    const indexPath = join(rootDir, 'index.html');
+    if (!isFile(indexPath))
+        return [];
+    const html = await loadFile(indexPath);
+    const entries = getModuleScriptSources(html).map(src => join(rootDir, src));
+    return entries.map(entry => toProductionEntry(entry));
+};

package/dist/plugins/vite/index.js

@@ -1,7 +1,8 @@
 import { toDependency } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 import { resolveConfig } from '../vitest/index.js';
-import { getReactBabelPlugins } from './helpers.js';
+import { getIndexHtmlEntries, getReactBabelPlugins } from './helpers.js';
+import { importMetaGlobCall } from './visitors/importMetaGlob.js';
 const title = 'Vite';
 const enablers = ['vite', 'vitest'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -10,6 +11,12 @@ const resolveFromAST = (sourceFile) => {
     const babelPlugins = getReactBabelPlugins(sourceFile);
     return babelPlugins.map(plugin => toDependency(plugin));
 };
+const resolve = async (options) => {
+    return getIndexHtmlEntries(options.cwd);
+};
+const registerVisitors = ({ registerVisitors }) => {
+    registerVisitors({ dynamicImport: [importMetaGlobCall] });
+};
 const args = {
     config: true,
 };
@@ -20,6 +27,8 @@ const plugin = {
     config,
     resolveConfig,
     resolveFromAST,
+    resolve,
+    registerVisitors,
     args,
 };
 export default plugin;

package/dist/plugins/vite/visitors/importMetaGlob.d.ts

@@ -0,0 +1,2 @@
+import type { ImportVisitor } from '../../../typescript/visitors/index.js';
+export declare const importMetaGlobCall: ImportVisitor;

package/dist/plugins/vite/visitors/importMetaGlob.js

@@ -0,0 +1,32 @@
+import ts from 'typescript';
+import { IMPORT_FLAGS } from '../../../constants.js';
+import { isPropertyAccessCall } from '../../../typescript/ast-helpers.js';
+import { _syncGlob } from '../../../util/glob.js';
+import { dirname, isAbsolute, join } from '../../../util/path.js';
+export const importMetaGlobCall = sourceFile => {
+    return node => {
+        if (!isPropertyAccessCall(node, 'import.meta.glob'))
+            return;
+        const arg = node.arguments[0];
+        if (!arg)
+            return;
+        const dir = dirname(sourceFile.fileName);
+        const patterns = ts.isStringLiteralLike(arg)
+            ? [arg.text]
+            : ts.isArrayLiteralExpression(arg)
+                ? arg.elements.filter(ts.isStringLiteralLike).map(e => e.text)
+                : undefined;
+        if (!patterns?.length)
+            return;
+        const files = _syncGlob({ patterns, cwd: dir });
+        return files.map(filePath => ({
+            specifier: isAbsolute(filePath) ? filePath : join(dir, filePath),
+            identifier: undefined,
+            pos: arg.pos,
+            modifiers: IMPORT_FLAGS.ENTRY,
+            alias: undefined,
+            namespace: undefined,
+            symbol: undefined,
+        }));
+    };
+};

package/dist/plugins/vitest/index.js

@@ -10,10 +10,8 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['vitest.config.{js,mjs,ts,cjs,mts,cts}', 'vitest.{workspace,projects}.{js,mjs,ts,cjs,mts,cts,json}'];
 const mocks = ['**/__mocks__/**/*.[jt]s?(x)'];
 const entry = ['**/*.{bench,test,test-d,spec}.?(c|m)[jt]s?(x)', ...mocks];
-const isVitestCoverageCommand = /vitest(.+)--coverage(?:\.enabled(?:=true)?)?/;
-const hasScriptWithCoverage = (scripts) => scripts ? Object.values(scripts).some(script => isVitestCoverageCommand.test(script)) : false;
-const findConfigDependencies = (localConfig, options) => {
-    const { manifest, configFileDir: dir } = options;
+const findConfigDependencies = (localConfig, options, vitestRoot) => {
+    const { configFileDir: dir } = options;
     const testConfig = localConfig.test;
     if (!testConfig)
         return [];
@@ -24,21 +22,23 @@ const findConfigDependencies = (localConfig, options) => {
             : [toDependency(getEnvSpecifier(env))]
         : [];
     const reporters = getExternalReporters(testConfig.reporters);
-    const hasCoverageEnabled = (testConfig.coverage && testConfig.coverage.enabled !== false) || hasScriptWithCoverage(manifest.scripts);
+    const hasCoverageEnabled = testConfig.coverage && testConfig.coverage.enabled !== false;
     const coverage = hasCoverageEnabled ? [`@vitest/coverage-${testConfig.coverage?.provider ?? 'v8'}`] : [];
-    const setupFiles = [testConfig.setupFiles ?? []].flat().map(specifier => ({ ...toDeferResolve(specifier), dir }));
+    const setupFiles = [testConfig.setupFiles ?? []]
+        .flat()
+        .map(specifier => ({ ...toDeferResolve(specifier), dir: vitestRoot }));
     const globalSetup = [testConfig.globalSetup ?? []].flat().map(specifier => ({ ...toDeferResolve(specifier), dir }));
     const workspaceDependencies = [];
     if (testConfig.workspace !== undefined) {
         for (const workspaceConfig of testConfig.workspace) {
-            workspaceDependencies.push(...findConfigDependencies(workspaceConfig, options));
+            workspaceDependencies.push(...findConfigDependencies(workspaceConfig, options, vitestRoot));
         }
     }
     const projectsDependencies = [];
     if (testConfig.projects !== undefined) {
         for (const projectConfig of testConfig.projects) {
             if (typeof projectConfig !== 'string') {
-                projectsDependencies.push(...findConfigDependencies(projectConfig, options));
+                projectsDependencies.push(...findConfigDependencies(projectConfig, options, vitestRoot));
             }
         }
     }
@@ -148,7 +148,7 @@ export const resolveConfig = async (localConfig, options) => {
                 inputs.add(toEntry(`src/**/*${ext}`));
             }
         }
-        for (const dependency of findConfigDependencies(cfg, options))
+        for (const dependency of findConfigDependencies(cfg, options, dir))
             inputs.add(dependency);
         const _entry = cfg.build?.lib?.entry ?? [];
         const deps = (typeof _entry === 'string' ? [_entry] : Object.values(_entry))
@@ -165,6 +165,21 @@ const args = {
         const inputs = [];
         if (parsed['ui'])
             inputs.push(toDependency('@vitest/ui', { optional: true }));
+        if (parsed['coverage']) {
+            const provider = typeof parsed['coverage'] === 'object' ? parsed['coverage'].provider : undefined;
+            inputs.push(toDependency(`@vitest/coverage-${provider ?? 'v8'}`));
+        }
+        if (parsed['reporter']) {
+            for (const reporter of getExternalReporters([parsed['reporter']].flat())) {
+                inputs.push(toDependency(reporter));
+            }
+        }
+        if (parsed['environment'] && parsed['environment'] !== 'node') {
+            inputs.push(toDependency(getEnvSpecifier(parsed['environment'])));
+        }
+        if (typeof parsed['typecheck'] === 'object' && parsed['typecheck'].checker) {
+            inputs.push(toDependency(parsed['typecheck'].checker === 'tsc' ? 'typescript' : parsed['typecheck'].checker));
+        }
         return inputs;
     },
 };

package/dist/plugins/vue/compiler.d.ts

@@ -0,0 +1,2 @@
+declare const compiler: import("../../compilers/types.js").CompilerSync;
+export default compiler;

package/dist/plugins/vue/compiler.js

@@ -0,0 +1,3 @@
+import { scriptBodies } from '../../compilers/compilers.js';
+const compiler = scriptBodies;
+export default compiler;

package/dist/plugins/vue/index.js

@@ -1,6 +1,7 @@
 import { toDependency } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
+import compiler from './compiler.js';
 const title = 'Vue';
 const enablers = ['vue'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -27,11 +28,16 @@ const resolveConfig = async (config, options) => {
     }
     return inputs;
 };
+const registerCompilers = ({ registerCompiler, hasDependency }) => {
+    if (hasDependency('vue') || hasDependency('nuxt'))
+        registerCompiler({ extension: '.vue', compiler });
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
     resolveConfig,
+    registerCompilers,
 };
 export default plugin;

package/dist/plugins/webpack/index.js

@@ -1,8 +1,8 @@
-import { compact } from '../../util/array.js';
 import { toAlias, toDeferResolve, toDeferResolveEntry, toDeferResolveProductionEntry, toDependency, } from '../../util/input.js';
 import { isInternal, join, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
+import { requireContextCall } from './visitors/requireContext.js';
 const title = 'webpack';
 const enablers = ['webpack', 'webpack-cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -140,16 +140,23 @@ export const findWebpackDependenciesFromConfig = async (config, options) => {
     return Array.from(inputs);
 };
 const resolveConfig = async (localConfig, options) => {
-    const { manifest } = options;
     const inputs = await findWebpackDependenciesFromConfig(localConfig, options);
-    const scripts = Object.values(manifest.scripts ?? {});
-    const webpackCLI = scripts.some(script => script && /(?<=^|\s)webpack(?=\s|$)/.test(script)) ? ['webpack-cli'] : [];
-    const webpackDevServer = scripts.some(script => script?.includes('webpack serve')) ? ['webpack-dev-server'] : [];
-    return compact([...inputs, ...[...webpackCLI, ...webpackDevServer].map(id => toDependency(id))]);
+    inputs.push(toDependency('webpack-cli', { optional: true }));
+    return inputs;
 };
+const registerVisitors = ({ registerVisitors }) => {
+    registerVisitors({ dynamicImport: [requireContextCall] });
+};
+const isFilterTransitiveDependencies = true;
 const args = {
     binaries: ['webpack', 'webpack-dev-server'],
     config: true,
+    resolveInputs: (parsed) => {
+        const inputs = [toDependency('webpack-cli')];
+        if (parsed._[0] === 'serve')
+            inputs.push(toDependency('webpack-dev-server'));
+        return inputs;
+    },
 };
 const plugin = {
     title,
@@ -157,6 +164,8 @@ const plugin = {
     isEnabled,
     config,
     resolveConfig,
+    registerVisitors,
+    isFilterTransitiveDependencies,
     args,
 };
 export default plugin;

package/dist/plugins/webpack/visitors/requireContext.d.ts

@@ -0,0 +1,2 @@
+import type { ImportVisitor } from '../../../typescript/visitors/index.js';
+export declare const requireContextCall: ImportVisitor;

package/dist/plugins/webpack/visitors/requireContext.js

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+import { IMPORT_FLAGS } from '../../../constants.js';
+import { isPropertyAccessCall } from '../../../typescript/ast-helpers.js';
+import { _syncGlob } from '../../../util/glob.js';
+import { dirname, isAbsolute, join } from '../../../util/path.js';
+export const requireContextCall = sourceFile => {
+    return node => {
+        if (!isPropertyAccessCall(node, 'require.context'))
+            return;
+        const [dirArg, recursiveArg, regExpArg] = node.arguments;
+        if (!dirArg || !ts.isStringLiteralLike(dirArg))
+            return;
+        const cwd = join(dirname(sourceFile.fileName), dirArg.text);
+        const isRecursive = !recursiveArg || recursiveArg.kind !== ts.SyntaxKind.FalseKeyword;
+        const pattern = isRecursive ? '**/*' : '*';
+        const files = _syncGlob({ patterns: [pattern], cwd });
+        const filter = regExpArg && ts.isRegularExpressionLiteral(regExpArg) ? regExpArg.text.match(/^\/(.+)\/([gimsuy]*)$/) : null;
+        const matched = filter ? files.filter(file => new RegExp(filter[1], filter[2]).test(file)) : files;
+        return matched.map(filePath => ({
+            specifier: isAbsolute(filePath) ? filePath : join(cwd, filePath),
+            identifier: undefined,
+            pos: dirArg.pos,
+            modifiers: IMPORT_FLAGS.ENTRY,
+            alias: undefined,
+            namespace: undefined,
+            symbol: undefined,
+        }));
+    };
+};

package/dist/plugins/yarn/index.js

@@ -1,14 +1,32 @@
 import { isFile } from '../../util/fs.js';
+import { toEntry } from '../../util/input.js';
 const title = 'Yarn';
 const enablers = 'This plugin is enabled when a `yarn.lock` file is found in the root folder.';
 const isEnabled = async ({ cwd }) => isFile(cwd, 'yarn.lock');
 const isRootOnly = true;
+const config = ['.yarnrc.yml'];
 const entry = ['yarn.config.cjs'];
+const resolveConfig = config => {
+    const inputs = entry.map(id => toEntry(id));
+    if (Array.isArray(config.plugins)) {
+        for (const plugin of config.plugins) {
+            if (plugin.path) {
+                inputs.push(toEntry(plugin.path));
+            }
+        }
+    }
+    if (config.yarnPath) {
+        inputs.push(toEntry(config.yarnPath));
+    }
+    return inputs;
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
     isRootOnly,
+    config,
     entry,
+    resolveConfig,
 };
 export default plugin;

package/dist/plugins/zx/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.js';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/zx/index.js

@@ -0,0 +1,15 @@
+import { hasDependency } from '../../util/plugin.js';
+import zxVisitor from './visitors/zx.js';
+const title = 'zx';
+const enablers = ['zx'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const registerVisitors = ({ registerVisitors }) => {
+    registerVisitors({ script: [zxVisitor] });
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    registerVisitors,
+};
+export default plugin;

package/dist/{typescript/visitors/scripts → plugins/zx/visitors}/zx.js

@@ -1,6 +1,6 @@
 import ts from 'typescript';
-import { stripQuotes } from '../../ast-helpers.js';
-import { scriptVisitor as visit } from '../index.js';
+import { stripQuotes } from '../../../typescript/ast-helpers.js';
+import { scriptVisitor as visit } from '../../../typescript/visitors/index.js';
 export default visit(sourceFile => ts.getShebang(sourceFile.text) === '#!/usr/bin/env zx', node => {
     if (ts.isTaggedTemplateExpression(node) && node.tag.getText() === '$') {
         return stripQuotes(node.template.getText());

package/dist/reporters/util/configuration-hints.js

@@ -40,6 +40,8 @@ const addWorkspace = (options) => options.configFilePath
     : `Create ${bright('knip.json')} configuration file with ${bright(`workspaces["${options.workspaceName}"]`)} object (${options.size} unused files)`;
 const packageEntry = () => 'Package entry file not found';
 const hintPrinters = new Map([
+    ['ignore', { print: unused }],
+    ['ignoreFiles', { print: unused }],
     ['ignoreBinaries', { print: unused }],
     ['ignoreDependencies', { print: unused }],
     ['ignoreUnresolved', { print: unused }],
@@ -58,6 +60,7 @@ export { hintPrinters };
 const hintTypesOrder = [
     ['top-level-unconfigured', 'workspace-unconfigured'],
     ['entry-top-level', 'project-top-level'],
+    ['ignore', 'ignoreFiles'],
     ['ignoreWorkspaces'],
     ['ignoreDependencies'],
     ['ignoreBinaries'],

package/dist/reporters/util/util.js

@@ -45,8 +45,8 @@ export const getTableForType = (issues, cwd, options = { isUseColors: true }) =>
         const print = options.isUseColors && (issue.isFixed || issue.severity === 'warn') ? dim : plain;
         const isFileIssue = issue.type === 'files';
         const symbol = issue.symbols ? issue.symbols.map(s => s.symbol).join(', ') : issue.symbol;
-        const displaySymbol = isFileIssue ? '' : symbol;
-        table.cell('symbol', print(displaySymbol), options.isUseColors ? highlightSymbol(issue) : () => displaySymbol);
+        if (!isFileIssue)
+            table.cell('symbol', print(symbol), options.isUseColors ? highlightSymbol(issue) : () => symbol);
         table.cell('parentSymbol', issue.parentSymbol && print(issue.parentSymbol));
         table.cell('symbolType', issue.symbolType && issue.symbolType !== SYMBOL_TYPE.UNKNOWN && print(issue.symbolType));
         const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;

package/dist/run.d.ts

@@ -18,7 +18,7 @@ export declare const run: (options: MainOptions) => Promise<{
         handleFileChanges: (changes: import("./util/watch.js").WatchChange[]) => Promise<{
             duration: number;
             mem: number;
-        }>;
+        } | undefined>;
         getEntryPaths: () => Set<string>;
         getGraph: () => import("./types/module-graph.js").ModuleGraph;
         getIssues: () => {