knip 6.29.0 → 6.31.0

package/dist/plugins/marko/taglibs.js

@@ -0,0 +1,111 @@
+import { readdirSync } from 'node:fs';
+import { isFile, loadJSON } from '../../util/fs.js';
+import { basename, dirname, join } from '../../util/path.js';
+const dependencyFields = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const getDependencies = async (cwd) => {
+    const manifest = await loadJSON(join(cwd, 'package.json'));
+    const dependencies = new Set();
+    if (!isRecord(manifest))
+        return dependencies;
+    for (const field of dependencyFields) {
+        const values = manifest[field];
+        if (isRecord(values))
+            for (const packageName in values)
+                dependencies.add(packageName);
+    }
+    return dependencies;
+};
+const findConfig = (cwd, packageName) => {
+    let dir = cwd;
+    while (true) {
+        const filePath = join(dir, 'node_modules', packageName, 'marko.json');
+        if (isFile(filePath))
+            return filePath;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return;
+        dir = parent;
+    }
+};
+const readDir = (dir) => {
+    try {
+        return readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+};
+const getTagName = (fileName) => (fileName.endsWith('.marko') ? basename(fileName, '.marko') : undefined);
+const isTagDir = (dir, name) => isFile(dir, 'index.marko') || isFile(dir, `${name}.marko`);
+const getTags = (dir) => {
+    const tags = new Set();
+    for (const entry of readDir(dir)) {
+        if (entry.name.startsWith('.'))
+            continue;
+        if (entry.isFile()) {
+            const name = getTagName(entry.name);
+            if (name)
+                tags.add(name);
+            continue;
+        }
+        if (!entry.isDirectory())
+            continue;
+        const tagDir = join(dir, entry.name);
+        if (isTagDir(tagDir, entry.name)) {
+            tags.add(entry.name);
+            continue;
+        }
+        if (entry.name === 'tags' || entry.name === 'components')
+            continue;
+        for (const child of readDir(tagDir)) {
+            if (child.isFile()) {
+                const name = getTagName(child.name);
+                if (name)
+                    tags.add(name);
+            }
+            else if (child.isDirectory() && isTagDir(join(tagDir, child.name), child.name)) {
+                tags.add(child.name);
+            }
+        }
+    }
+    return tags;
+};
+export const getTaglibDependencies = async (cwd) => {
+    const tagDependencies = new Map();
+    const fallbackDependencies = [];
+    for (const packageName of await getDependencies(cwd)) {
+        const configPath = findConfig(cwd, packageName);
+        if (!configPath)
+            continue;
+        let config;
+        try {
+            config = await loadJSON(configPath);
+        }
+        catch {
+            fallbackDependencies.push(packageName);
+            continue;
+        }
+        if (!isRecord(config)) {
+            fallbackDependencies.push(packageName);
+            continue;
+        }
+        const tagsDir = typeof config.exports === 'string'
+            ? config.exports
+            : typeof config['tags-dir'] === 'string'
+                ? config['tags-dir']
+                : undefined;
+        if (!tagsDir) {
+            fallbackDependencies.push(packageName);
+            continue;
+        }
+        for (const tagName of getTags(join(dirname(configPath), tagsDir))) {
+            const dependencies = tagDependencies.get(tagName);
+            if (dependencies)
+                dependencies.push(packageName);
+            else
+                tagDependencies.set(tagName, [packageName]);
+        }
+    }
+    return { tagDependencies, fallbackDependencies };
+};

package/dist/plugins/marko/types.d.ts

@@ -0,0 +1,9 @@
+export type MarkoTagDef = {
+    template?: string;
+    renderer?: string;
+    parse?: string;
+    migrate?: string;
+    transform?: string;
+    analyze?: string;
+    translate?: string;
+};

package/dist/plugins/marko/types.js

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

package/dist/plugins/metro/index.js

@@ -41,7 +41,7 @@ const resolveConfig = async (config) => {
         inputs.push(transformer.minifierPath);
     if (transformer?.babelTransformerPath)
         inputs.push(transformer.babelTransformerPath);
-    return Array.from(i).concat([...inputs].map(id => toDeferResolve(id, {
+    return Array.from(i).concat(Array.from(inputs, id => toDeferResolve(id, {
         optional: id === DEFAULT_TRANSFORMER_PACKAGE || id === DEFAULT_MINIFIER_PACKAGE,
     })));
 };

package/dist/plugins/nest/index.js

@@ -6,7 +6,7 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['nest-cli.json', '.nestcli.json', '.nest-cli.json', 'nest.json'];
 const resolveConfig = async (config) => {
     const inputs = config?.collection ? [config.collection] : [];
-    return [...inputs].map(id => toDependency(id));
+    return Array.from(inputs, id => toDependency(id));
 };
 const plugin = {
     title,

package/dist/plugins/node/index.js

@@ -8,9 +8,18 @@ const patterns = [
     '**/test.{cjs,mjs,js,cts,mts,ts}',
     '**/test/**/*.{cjs,mjs,js,cts,mts,ts}',
 ];
-const hasNodeTest = (scripts) => scripts &&
-    Object.values(scripts).some(script => typeof script === 'string' &&
+const hasNodeTestCache = new WeakMap();
+const hasNodeTest = (scripts) => {
+    if (!scripts)
+        return false;
+    const cached = hasNodeTestCache.get(scripts);
+    if (cached !== undefined)
+        return cached;
+    const result = Object.values(scripts).some(script => typeof script === 'string' &&
         getScriptCommands(script).some(({ binary, args }) => (binary === 'node' || binary === 'nub') && args.includes('--test')));
+    hasNodeTestCache.set(scripts, result);
+    return result;
+};
 const entry = ['server.js'];
 const resolve = options => {
     const entries = entry.map(id => toProductionEntry(id));

package/dist/plugins/nx/index.js

@@ -2,6 +2,7 @@ import { compact } from '../../util/array.js';
 import { toConfig, toDependency } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { substringBefore } from '../../util/string.js';
 const title = 'Nx';
 const enablers = ['nx', /^@nrwl\//, /^@nx\//];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -10,7 +11,7 @@ const findNxDependenciesInNxJson = async (localConfig) => {
     const targetsDefault = localConfig.targetDefaults
         ? Object.keys(localConfig.targetDefaults)
             .filter(it => it.includes(':') && it.startsWith('@'))
-            .map(it => it.split(':')[0])
+            .map(it => substringBefore(it, ':'))
         : [];
     const plugins = localConfig.plugins && Array.isArray(localConfig.plugins)
         ? localConfig.plugins
@@ -20,7 +21,7 @@ const findNxDependenciesInNxJson = async (localConfig) => {
     const generators = localConfig.generators
         ? Object.keys(localConfig.generators)
             .filter(value => value !== undefined)
-            .map(value => value.split(':')[0])
+            .map(value => substringBefore(value, ':'))
         : [];
     return compact([...targetsDefault, ...plugins, ...generators]).map(id => toDependency(id));
 };
@@ -34,7 +35,7 @@ const resolveConfig = async (localConfig, options) => {
     const executors = targets
         .map(target => target?.executor)
         .filter(executor => executor && !executor.startsWith('.'))
-        .map(executor => executor?.split(':')[0]);
+        .map(executor => executor && substringBefore(executor, ':'));
     const expand = (value) => value.replaceAll('{projectRoot}', options.configFileDir).replaceAll('{workspaceRoot}', options.rootCwd);
     const resolveTargetCwd = (targetCwd) => {
         if (!targetCwd)

package/dist/plugins/openclaw/index.js

@@ -38,7 +38,7 @@ const resolveFromAST = (_, options) => {
         return [];
     const sourceText = options.readFile(options.configFilePath).replace(/^\uFEFF/, '');
     const { program } = _parseFile(`${options.configFilePath}.ts`, `(${sourceText}\n)`);
-    return [...collectPropertyValues(program, 'providerCatalogEntry')].map(entry => toProductionEntry(entry));
+    return Array.from(collectPropertyValues(program, 'providerCatalogEntry'), entry => toProductionEntry(entry));
 };
 const plugin = {
     title,

package/dist/plugins/oxlint/index.js

@@ -38,9 +38,16 @@ const resolveFromAST = (program, options) => {
     const visitor = new Visitor({
         ObjectExpression(node) {
             const lint = findProperty(node, 'lint');
-            if (lint?.type === 'ObjectExpression')
-                for (const specifier of getPropertyValues(lint, 'jsPlugins'))
+            if (lint?.type !== 'ObjectExpression')
+                return;
+            for (const specifier of getPropertyValues(lint, 'jsPlugins'))
+                jsPlugins.add(specifier);
+            for (const plugin of findProperty(lint, 'jsPlugins')?.elements ?? []) {
+                if (plugin?.type !== 'ObjectExpression')
+                    continue;
+                for (const specifier of getPropertyValues(plugin, 'specifier'))
                     jsPlugins.add(specifier);
+            }
         },
     });
     visitor.visit(program);

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

@@ -0,0 +1,3 @@
+import { type Input } from '../../util/input.ts';
+import type { Manifest } from '../../util/package-json.ts';
+export declare const resolveLoadPluginStylePluginName: (prefix: string, identifier: string, manifest: Manifest) => Input;

package/dist/plugins/remark/helpers.js

@@ -0,0 +1,42 @@
+import { toDeferResolve, toDependency } from '../../util/input.js';
+import { isInternal } from '../../util/path.js';
+const getCandidates = (prefix, identifier) => {
+    if (isInternal(identifier))
+        return [identifier];
+    if (identifier.startsWith('@')) {
+        const [scope, name, ...rest] = identifier.split('/');
+        if (rest.length > 0)
+            return [identifier];
+        if (scope) {
+            if (!name)
+                return [[scope, prefix].join('/')];
+            if (name.startsWith(prefix))
+                return [identifier];
+            return [[scope, prefix + name].join('/'), identifier];
+        }
+    }
+    const [name, ...rest] = identifier.split('/');
+    if (rest.length > 0)
+        return [identifier];
+    if (name.startsWith(prefix))
+        return [identifier];
+    return [prefix + name, name];
+};
+const getDeclaredDependencies = (manifest) => new Set([
+    ...Object.keys(manifest.dependencies ?? {}),
+    ...Object.keys(manifest.devDependencies ?? {}),
+    ...Object.keys(manifest.optionalDependencies ?? {}),
+    ...Object.keys(manifest.peerDependencies ?? {}),
+]);
+const pickCandidate = (prefix, identifier, manifest) => {
+    const candidates = getCandidates(prefix, identifier);
+    if (candidates.length === 1 || isInternal(candidates[0]))
+        return candidates[0];
+    const dependencies = getDeclaredDependencies(manifest);
+    return candidates.find(candidate => dependencies.has(candidate)) ?? candidates[0];
+};
+export const resolveLoadPluginStylePluginName = (prefix, identifier, manifest) => {
+    prefix = prefix + (prefix.at(-1) === '-' ? '' : '-');
+    const candidate = pickCandidate(prefix, identifier, manifest);
+    return isInternal(candidate) ? toDeferResolve(candidate) : toDependency(candidate);
+};

package/dist/plugins/remark/index.js

@@ -1,12 +1,11 @@
-import { toDeferResolve } from '../../util/input.js';
-import { isInternal } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { resolveLoadPluginStylePluginName } from './helpers.js';
 const title = 'Remark';
 const enablers = ['remark-cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = 'remarkConfig';
 const config = ['package.json', '.remarkrc', '.remarkrc.json', '.remarkrc.{js,cjs,mjs}', '.remarkrc.{yml,yaml}'];
-const resolveConfig = config => {
+const resolveConfig = (config, options) => {
     const plugins = config.plugins
         ?.flatMap(plugin => {
         if (typeof plugin === 'string')
@@ -15,8 +14,8 @@ const resolveConfig = config => {
             return plugin[0];
         return [];
     })
-        .map(plugin => (isInternal(plugin) ? plugin : plugin.startsWith('remark-') ? plugin : `remark-${plugin}`)) ?? [];
-    return plugins.map(id => toDeferResolve(id));
+        .map(plugin => resolveLoadPluginStylePluginName('remark-', plugin, options.manifest)) ?? [];
+    return plugins;
 };
 const plugin = {
     title,

package/dist/plugins/rolldown/index.js

@@ -5,7 +5,7 @@ const title = 'Rolldown';
 const enablers = ['rolldown'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['rolldown.config.{js,cjs,mjs,ts,cts,mts}'];
-const resolveFromAST = program => [...collectPropertyValues(program, 'input')].map(id => toProductionEntry(id));
+const resolveFromAST = program => Array.from(collectPropertyValues(program, 'input'), id => toProductionEntry(id));
 const plugin = {
     title,
     enablers,

package/dist/plugins/rollup/index.js

@@ -11,7 +11,7 @@ const args = {
     fromArgs: ['_exec'],
     resolve: ['plugin', 'configPlugin'],
 };
-const resolveFromAST = program => [...collectPropertyValues(program, 'input')].map(id => toProductionEntry(id));
+const resolveFromAST = program => Array.from(collectPropertyValues(program, 'input'), id => toProductionEntry(id));
 const plugin = {
     title,
     enablers,

package/dist/plugins/rslib/index.js

@@ -5,7 +5,7 @@ const title = 'Rslib';
 const enablers = ['@rslib/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['rslib*.config.{mjs,ts,js,cjs,mts,cts}'];
-const resolveFromAST = program => [...collectPropertyValues(program, 'entry')].map(id => toProductionEntry(id, { allowIncludeExports: true }));
+const resolveFromAST = program => Array.from(collectPropertyValues(program, 'entry'), id => toProductionEntry(id, { allowIncludeExports: true }));
 const plugin = {
     title,
     enablers,

package/dist/plugins/stryker/index.js

@@ -1,4 +1,4 @@
-import { toDeferResolve } from '../../util/input.js';
+import { toConfig, toDeferResolve } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Stryker';
 const enablers = ['@stryker-mutator/core'];
@@ -12,11 +12,16 @@ const resolveConfig = localConfig => {
     const plugins = localConfig.plugins ?? [];
     return [...runners, ...checkers, ...plugins].map(id => toDeferResolve(id));
 };
+const args = {
+    boolean: ['allowEmpty', 'disableBail', 'dryRunOnly', 'force', 'ignoreStatic', 'incremental', 'inPlace'],
+    resolveInputs: parsed => (parsed._[0] === 'run' && parsed._[1] ? [toConfig('stryker', parsed._[1])] : []),
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
     resolveConfig,
+    args,
 };
 export default plugin;

package/dist/plugins/svelte/compiler.js

@@ -1,10 +1,12 @@
 import { importsWithinScripts } from '../../compilers/compilers.js';
 import { stylePreprocessorImports } from '../../compilers/style-preprocessors.js';
+import { dynamicImportsWithinTemplate } from '../../compilers/svelte.js';
 const compiler = (text, path) => {
-    const scripts = importsWithinScripts(text, path);
-    const styles = stylePreprocessorImports(text, path);
-    if (!scripts)
-        return styles;
-    return styles ? `${scripts};\n${styles}` : scripts;
+    const parts = [
+        importsWithinScripts(text, path),
+        dynamicImportsWithinTemplate(text, path),
+        stylePreprocessorImports(text, path),
+    ];
+    return parts.filter(Boolean).join(';\n');
 };
 export default compiler;

package/dist/plugins/tsdown/index.js

@@ -38,8 +38,8 @@ const resolveConfig = async (config) => {
     return [...entryPatterns, ...externalDependencies];
 };
 const resolveFromAST = program => [
-    ...[...collectPropertyValues(program, 'entry')].map(id => toProductionEntry(id, { allowIncludeExports: true })),
-    ...[...collectPropertyValues(program, 'neverBundle')].map(id => toDependency(id, { optional: true })),
+    ...Array.from(collectPropertyValues(program, 'entry'), id => toProductionEntry(id, { allowIncludeExports: true })),
+    ...Array.from(collectPropertyValues(program, 'neverBundle'), id => toDependency(id, { optional: true })),
 ];
 const args = {
     config: true,

package/dist/plugins/tsup/index.js

@@ -21,7 +21,7 @@ const resolveConfig = async (config) => {
         .map(id => toProductionEntry(id, { allowIncludeExports: true }));
     return entryPatterns;
 };
-const resolveFromAST = program => [...collectPropertyValues(program, 'entry')].map(id => toProductionEntry(id, { allowIncludeExports: true }));
+const resolveFromAST = program => Array.from(collectPropertyValues(program, 'entry'), id => toProductionEntry(id, { allowIncludeExports: true }));
 const args = {
     config: true,
 };

package/dist/plugins/vitest/index.js

@@ -70,7 +70,7 @@ const getConfigs = async (localConfig) => {
     for (const config of [localConfig].flat()) {
         if (config && typeof config !== 'string') {
             if (typeof config === 'function') {
-                for (const command of ['dev', 'serve', 'build']) {
+                for (const command of ['serve', 'build']) {
                     for (const mode of ['development', 'production']) {
                         const cfg = await config({ command, mode, ssrBuild: undefined });
                         configs.push(cfg);

package/dist/plugins/vitest/types.d.ts

@@ -58,7 +58,7 @@ export interface ViteConfig extends VitestConfig {
         extensions?: string[];
     };
 }
-export type COMMAND = 'dev' | 'serve' | 'build';
+export type COMMAND = 'serve' | 'build';
 export type MODE = 'development' | 'production';
 interface Options {
     command: COMMAND;

package/dist/reporters/codeclimate.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { toRelative } from '../util/path.js';
-import { flattenIssues, getIssuePrefix, getIssueTypeTitle } from './util/util.js';
+import { flattenIssues, getIssueDescription, getIssuePrefix, getIssueTypeTitle } from './util/util.js';
 export default async ({ report, issues, cwd }) => {
     const entries = [];
     for (const [type, isReportType] of Object.entries(report)) {
@@ -47,10 +47,6 @@ function convertSeverity(severity) {
             return 'info';
     }
 }
-function getIssueDescription({ type, symbol, symbols, parentSymbol }) {
-    const symbolDescription = symbols ? `${symbols.map(s => s.symbol).join(', ')}` : symbol;
-    return `${getIssuePrefix(type)}: ${symbolDescription}${parentSymbol ? ` (${parentSymbol})` : ''}`;
-}
 function getSymbolDescription({ type, symbol, parentSymbol, }) {
     return `${getIssuePrefix(type)}: ${symbol.symbol}${parentSymbol ? ` (${parentSymbol})` : ''}`;
 }

package/dist/reporters/github-actions.js

@@ -1,5 +1,6 @@
 import { ISSUE_TYPE_TITLE } from '../constants.js';
 import { relative } from '../util/path.js';
+import { compareStrings } from '../util/string.js';
 import { hintPrinters } from './util/configuration-hints.js';
 import { flattenIssues, getIssueTypeTitle } from './util/util.js';
 const createGitHubActionsLogger = () => {
@@ -31,7 +32,7 @@ export default ({ report, issues, cwd, configurationHints, tagHints, isDisableCo
         if (isReportType) {
             const title = reportMultipleGroups && getIssueTypeTitle(reportType);
             const issuesForType = flattenIssues(issues[reportType]);
-            issuesForType.sort((a, b) => a.filePath.localeCompare(b.filePath) || (a.line ?? 0) - (b.line ?? 0));
+            issuesForType.sort((a, b) => compareStrings(a.filePath, b.filePath) || (a.line ?? 0) - (b.line ?? 0));
             if (issuesForType.length > 0) {
                 title && core.info(`${title} (${issuesForType.length})`);
                 for (const issue of issuesForType) {
@@ -55,7 +56,7 @@ export default ({ report, issues, cwd, configurationHints, tagHints, isDisableCo
     if (!isDisableConfigHints && configurationHints.length > 0) {
         const CONFIG_HINTS_TITLE = 'Configuration hints';
         core.info(`${CONFIG_HINTS_TITLE} (${configurationHints.length})`);
-        const sortedHints = [...configurationHints].sort((a, b) => (a.filePath ?? '').localeCompare(b.filePath ?? ''));
+        const sortedHints = configurationHints.toSorted((a, b) => compareStrings(a.filePath ?? '', b.filePath ?? ''));
         for (const hint of sortedHints) {
             const hintPrinter = hintPrinters.get(hint.type);
             const message = hintPrinter?.print({
@@ -94,7 +95,8 @@ export default ({ report, issues, cwd, configurationHints, tagHints, isDisableCo
     if (!isDisableTagHints && tagHints.size > 0) {
         const TAG_HINTS_TITLE = 'Tag hints';
         core.info(`${TAG_HINTS_TITLE} (${tagHints.size})`);
-        const sortedHints = [...tagHints].sort((a, b) => a.filePath.localeCompare(b.filePath));
+        const sortedHints = Array.from(tagHints);
+        sortedHints.sort((a, b) => compareStrings(a.filePath, b.filePath));
         for (const hint of sortedHints) {
             const file = relative(cwd, hint.filePath);
             const hintMessage = `Unused tag in ${file}: ${hint.identifier} → ${hint.tagName}`;

package/dist/reporters/index.d.ts

@@ -7,6 +7,7 @@ declare const _default: {
     codeclimate: ({ report, issues, cwd }: import("../types.ts").ReporterOptions) => Promise<void>;
     json: ({ report, issues, options, cwd }: import("../types.ts").ReporterOptions) => Promise<void>;
     markdown: ({ report, issues, cwd }: import("../types.ts").ReporterOptions) => void;
+    sarif: ({ report, issues, cwd }: import("../types.ts").ReporterOptions) => void;
     'github-actions': ({ report, issues, cwd, configurationHints, tagHints, isDisableConfigHints, isDisableTagHints, isTreatConfigHintsAsErrors, isTreatTagHintsAsErrors, configFilePath, }: import("../types.ts").ReporterOptions) => void;
 };
 export default _default;

package/dist/reporters/index.js

@@ -6,6 +6,7 @@ import disclosure from './disclosure.js';
 import githubActions from './github-actions.js';
 import json from './json.js';
 import markdown from './markdown.js';
+import sarif from './sarif.js';
 import symbols from './symbols.js';
 export default {
     symbols,
@@ -16,5 +17,6 @@ export default {
     codeclimate,
     json,
     markdown,
+    sarif,
     'github-actions': githubActions,
 };

package/dist/reporters/json.d.ts

@@ -15,6 +15,7 @@ export type JSONReportEntry = {
     owners?: Array<JSONReportNamedItem>;
     binaries?: Array<JSONReportNamedItem>;
     catalog?: Array<JSONReportItem>;
+    catalogReferences?: Array<JSONReportItem>;
     cycles?: Array<Array<JSONReportItem>>;
     dependencies?: Array<JSONReportItem>;
     devDependencies?: Array<JSONReportItem>;

package/dist/reporters/json.js

@@ -20,6 +20,7 @@ export default async ({ report, issues, options, cwd }) => {
             ...(findOwners && { owners: findOwners(file).map(name => ({ name })) }),
             ...(report.binaries && { binaries: [] }),
             ...(report.catalog && { catalog: [] }),
+            ...(report.catalogReferences && { catalogReferences: [] }),
             ...(report.cycles && { cycles: [] }),
             ...(report.dependencies && { dependencies: [] }),
             ...(report.devDependencies && { devDependencies: [] }),

package/dist/reporters/sarif.d.ts

@@ -0,0 +1,3 @@
+import type { ReporterOptions } from '../types/issues.ts';
+export default _default;
+declare function _default({ report, issues, cwd }: ReporterOptions): void;

package/dist/reporters/sarif.js

@@ -0,0 +1,79 @@
+import { ISSUE_TYPE_TITLE } from '../constants.js';
+import { toPosix, toRelative } from '../util/path.js';
+import { version } from '../version.js';
+import { flattenIssues, getIssueDescription } from './util/util.js';
+const schema = 'https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json';
+const getLevel = (severity) => severity === 'error' ? 'error' : severity === 'warn' ? 'warning' : 'note';
+const getProblemSeverity = (severity) => severity === 'error' ? 'error' : severity === 'warn' ? 'warning' : 'recommendation';
+const getRuleId = (type) => `knip/${type}`;
+const getUri = (filePath, cwd) => toPosix(toRelative(filePath, cwd))
+    .split('/')
+    .map(segment => encodeURIComponent(segment))
+    .join('/');
+const getLocation = ({ filePath, line, col, symbol }, cwd) => ({
+    physicalLocation: {
+        artifactLocation: { uri: getUri(filePath, cwd) },
+        ...(line !== undefined && {
+            region: {
+                startLine: Math.max(line, 1),
+                ...(col !== undefined && {
+                    startColumn: Math.max(col, 1),
+                    endColumn: Math.max(col, 1) + Math.max(symbol.length, 1),
+                }),
+            },
+        }),
+    },
+});
+const sortByLocation = (a, b) => a.filePath.localeCompare(b.filePath) ||
+    (a.line ?? 0) - (b.line ?? 0) ||
+    (a.col ?? 0) - (b.col ?? 0) ||
+    a.symbol.localeCompare(b.symbol);
+export default ({ report, issues, cwd }) => {
+    const groups = [];
+    for (const [type, isReportType] of Object.entries(report)) {
+        if (!isReportType)
+            continue;
+        const issuesForType = flattenIssues(issues[type]).sort(sortByLocation);
+        if (issuesForType.length > 0)
+            groups.push({ type, issues: issuesForType });
+    }
+    const rules = groups.map(({ type, issues }) => {
+        const severity = issues[0].severity;
+        const title = ISSUE_TYPE_TITLE[type];
+        return {
+            id: getRuleId(type),
+            name: type,
+            shortDescription: { text: title },
+            helpUri: 'https://knip.dev/reference/issue-types',
+            defaultConfiguration: { level: getLevel(severity) },
+            properties: { 'problem.severity': getProblemSeverity(severity) },
+        };
+    });
+    const results = groups.flatMap(({ type, issues }, ruleIndex) => issues.map(issue => ({
+        ruleId: getRuleId(type),
+        ruleIndex,
+        level: getLevel(issue.severity),
+        message: { text: getIssueDescription(issue) },
+        locations: [getLocation(issue, cwd)],
+    })));
+    const output = JSON.stringify({
+        $schema: schema,
+        version: '2.1.0',
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: 'knip',
+                        version,
+                        semanticVersion: version,
+                        informationUri: 'https://knip.dev',
+                        rules,
+                    },
+                },
+                results,
+            },
+        ],
+    });
+    process.stdout._handle?.setBlocking?.(true);
+    process.stdout.write(`${output}\n`);
+};

package/dist/reporters/trace.js

@@ -1,6 +1,7 @@
 import st from '../util/colors.js';
 import { toRelative } from '../util/path.js';
 import { toRegexOrString } from '../util/regex.js';
+import { compareStrings } from '../util/string.js';
 import { Table } from '../util/table.js';
 import { formatTrace } from '../util/trace.js';
 export default ({ graph, explorer, options, workspaceFilePathFilter, issues }) => {
@@ -11,7 +12,7 @@ export default ({ graph, explorer, options, workspaceFilePathFilter, issues }) =
         const seen = new Set();
         for (const [packageName, { imports }] of explorer.getDependencyUsage(pattern)) {
             const filtered = imports.filter(i => workspaceFilePathFilter(i.filePath));
-            filtered.sort((a, b) => a.filePath.localeCompare(b.filePath) || (a.line ?? 0) - (b.line ?? 0));
+            filtered.sort((a, b) => compareStrings(a.filePath, b.filePath) || (a.line ?? 0) - (b.line ?? 0));
             for (const _import of filtered) {
                 const pos = _import.line ? `:${_import.line}:${_import.col}` : '';
                 const key = `${_import.filePath}${pos}:${packageName}`;
@@ -54,7 +55,7 @@ export default ({ graph, explorer, options, workspaceFilePathFilter, issues }) =
                 }
             }
         }
-        nodes.sort((a, b) => a.filePath.localeCompare(b.filePath) || a.identifier.localeCompare(b.identifier));
+        nodes.sort((a, b) => compareStrings(a.filePath, b.filePath) || compareStrings(a.identifier, b.identifier));
         const toRel = (path) => toRelative(path, options.cwd);
         if (nodes.length === 0) {
             if (options.traceFile && !graph.has(options.traceFile)) {