knip 5.47.0 → 5.48.0

package/dist/plugins/index.js

@@ -64,12 +64,15 @@ import { default as semanticRelease } from './semantic-release/index.js';
 import { default as sentry } from './sentry/index.js';
 import { default as simpleGitHooks } from './simple-git-hooks/index.js';
 import { default as sizeLimit } from './size-limit/index.js';
+import { default as sst } from './sst/index.js';
+import { default as starlight } from './starlight/index.js';
 import { default as storybook } from './storybook/index.js';
 import { default as stryker } from './stryker/index.js';
 import { default as stylelint } from './stylelint/index.js';
 import { default as svelte } from './svelte/index.js';
 import { default as syncpack } from './syncpack/index.js';
 import { default as tailwind } from './tailwind/index.js';
+import { default as tanstackRouter } from './tanstack-router/index.js';
 import { default as travis } from './travis/index.js';
 import { default as tsNode } from './ts-node/index.js';
 import { default as tsup } from './tsup/index.js';
@@ -157,12 +160,15 @@ export const Plugins = {
     sentry,
     'simple-git-hooks': simpleGitHooks,
     'size-limit': sizeLimit,
+    sst,
+    starlight,
     storybook,
     stryker,
     stylelint,
     svelte,
     syncpack,
     tailwind,
+    'tanstack-router': tanstackRouter,
     travis,
     'ts-node': tsNode,
     tsup,

package/dist/plugins/jest/index.js

@@ -80,7 +80,9 @@ const resolveEntryPaths = async (localConfig, options) => {
         localConfig = await localConfig();
     const rootDir = localConfig.rootDir ?? configFileDir;
     const replaceRootDir = (name) => name.replace(/<rootDir>/, rootDir);
-    return (localConfig.testMatch ?? []).map(replaceRootDir).map(toEntry);
+    if (localConfig.testMatch)
+        return localConfig.testMatch.map(replaceRootDir).map(toEntry);
+    return entry.map(id => toEntry(id));
 };
 const resolveConfig = async (localConfig, options) => {
     const { configFileDir } = options;

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

@@ -1,9 +1,10 @@
-import type { IsPluginEnabled } from '../../types/config.js';
+import type { IsPluginEnabled, ResolveFromAST } from '../../types/config.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
-    entry: string[];
+    config: string[];
     production: string[];
+    resolveFromAST: ResolveFromAST;
 };
 export default _default;

package/dist/plugins/next/index.js

@@ -1,9 +1,12 @@
+import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { getPageExtensions } from './resolveFromAST.js';
 const title = 'Next.js';
 const enablers = ['next'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const entry = ['next.config.{js,ts,cjs,mjs}'];
-const productionEntryFilePatternsWithoutSrc = [
+const config = ['next.config.{js,ts,cjs,mjs}'];
+const defaultPageExtensions = ['{js,jsx,ts,tsx}'];
+const productionEntryFilePatterns = [
     '{instrumentation,middleware}.{js,ts}',
     'app/global-error.{js,jsx,ts,tsx}',
     'app/**/{error,layout,loading,not-found,page,template,default}.{js,jsx,ts,tsx}',
@@ -11,16 +14,24 @@ const productionEntryFilePatternsWithoutSrc = [
     'app/{manifest,sitemap,robots}.{js,ts}',
     'app/**/{icon,apple-icon}.{js,jsx,ts,tsx}',
     'app/**/{opengraph,twitter}-image.{js,jsx,ts,tsx}',
-    'pages/**/*.{js,jsx,ts,tsx}',
-];
-const production = [
-    ...productionEntryFilePatternsWithoutSrc,
-    ...productionEntryFilePatternsWithoutSrc.map(pattern => `src/${pattern}`),
 ];
+const getEntryFilePatterns = (pageExtensions = defaultPageExtensions) => {
+    const pages = pageExtensions.map(ext => `pages/**/*.${ext}`);
+    const patterns = [...productionEntryFilePatterns, ...pages];
+    return [...patterns, ...patterns.map(pattern => `src/${pattern}`)];
+};
+const production = getEntryFilePatterns();
+const resolveFromAST = sourceFile => {
+    const pageExtensions = getPageExtensions(sourceFile);
+    const extensions = pageExtensions.length > 0 ? pageExtensions : defaultPageExtensions;
+    const patterns = getEntryFilePatterns(extensions);
+    return patterns.map(id => toProductionEntry(id));
+};
 export default {
     title,
     enablers,
     isEnabled,
-    entry,
+    config,
     production,
+    resolveFromAST,
 };

package/dist/plugins/next/resolveFromAST.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare const getPageExtensions: (sourceFile: ts.SourceFile) => string[];

package/dist/plugins/next/resolveFromAST.js

@@ -0,0 +1,15 @@
+import ts from 'typescript';
+import { getPropertyValues } from '../../typescript/ast-helpers.js';
+export const getPageExtensions = (sourceFile) => {
+    const pageExtensions = new Set();
+    function visit(node) {
+        if (ts.isObjectLiteralExpression(node)) {
+            const values = getPropertyValues(node, 'pageExtensions');
+            for (const value of values)
+                pageExtensions.add(value);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return Array.from(pageExtensions);
+};

package/dist/plugins/nodemon/index.js

@@ -1,6 +1,6 @@
 const title = 'nodemon';
 const args = {
-    positional: true,
+    positional: false,
     nodeImportArgs: true,
     string: ['exec'],
     fromArgs: ['exec'],

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

@@ -7,7 +7,7 @@ declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
-    entry: string[];
+    config: string[];
     production: string[];
     resolveEntryPaths: ResolveEntryPaths<NuxtConfig>;
 };

package/dist/plugins/nuxt/index.js

@@ -9,7 +9,7 @@ const isEnabled = ({ dependencies }) => {
         globalThis.defineNuxtConfig = (c) => c;
     return isEnabled;
 };
-const entry = ['nuxt.config.{js,mjs,ts}'];
+const config = ['nuxt.config.{js,mjs,ts}'];
 const production = [
     'app.{vue,jsx,tsx}',
     'error.{vue,jsx,tsx}',
@@ -43,7 +43,7 @@ export default {
     title,
     enablers,
     isEnabled,
-    entry,
+    config,
     production,
     resolveEntryPaths,
 };

package/dist/plugins/playwright/index.js

@@ -7,8 +7,6 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['playwright.config.{js,ts,mjs}'];
 export const entry = ['**/*.@(spec|test).?(c|m)[jt]s?(x)'];
 const toEntryPatterns = (testMatch, cwd, configDir, localConfig, rootConfig) => {
-    if (!testMatch)
-        return [];
     const testDir = localConfig.testDir ?? rootConfig.testDir;
     const dir = relative(cwd, testDir ? join(configDir, testDir) : configDir);
     const patterns = [testMatch].flat().filter((p) => typeof p === 'string');
@@ -18,7 +16,7 @@ const builtinReporters = ['dot', 'line', 'list', 'junit', 'html', 'blob', 'json'
 export const resolveEntryPaths = async (localConfig, options) => {
     const { cwd, configFileDir } = options;
     const projects = localConfig.projects ? [localConfig, ...localConfig.projects] : [localConfig];
-    return projects.flatMap(config => toEntryPatterns(config.testMatch, cwd, configFileDir, config, localConfig));
+    return projects.flatMap(config => toEntryPatterns(config.testMatch ?? entry, cwd, configFileDir, config, localConfig));
 };
 export const resolveConfig = async (config) => {
     const reporters = [config.reporter].flat().flatMap(reporter => {

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

@@ -24,7 +24,9 @@ const resolveEntryPaths = async (localConfig, options) => {
     const mapRoute = (route) => {
         return [join(appDir, route.file), ...(route.children ? route.children.flatMap(mapRoute) : [])];
     };
-    const routes = routeConfig.flatMap(mapRoute);
+    const routes = routeConfig
+        .flatMap(mapRoute)
+        .map(route => route.replace(/[$^*+?()\[\]]/g, '\\$&'));
     return [
         join(appDir, 'routes.{js,ts}'),
         join(appDir, 'root.{jsx,tsx}'),

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

@@ -0,0 +1,9 @@
+import type { IsPluginEnabled, ResolveFromAST } from '../../types/config.js';
+declare const _default: {
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    resolveFromAST: ResolveFromAST;
+};
+export default _default;

package/dist/plugins/sst/index.js

@@ -0,0 +1,17 @@
+import { hasDependency } from '../../util/plugin.js';
+import { getInputsFromHandlers } from './resolveFromAST.js';
+const title = 'SST';
+const enablers = ['sst'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['sst.config.ts'];
+const resolveFromAST = (sourceFile, options) => {
+    const inputs = getInputsFromHandlers(sourceFile, options);
+    return inputs;
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveFromAST,
+};

package/dist/plugins/sst/resolveFromAST.d.ts

@@ -0,0 +1,2 @@
+import type { ResolveFromAST } from '../../types/config.js';
+export declare const getInputsFromHandlers: ResolveFromAST;

package/dist/plugins/sst/resolveFromAST.js

@@ -0,0 +1,47 @@
+import ts from 'typescript';
+import { getImportMap, getPropertyValues } from '../../typescript/ast-helpers.js';
+import { toDeferResolveProductionEntry } from '../../util/input.js';
+export const getInputsFromHandlers = (sourceFile, options) => {
+    const { getSourceFile, getReferencedInternalFilePath } = options;
+    const entries = new Set();
+    const importMap = getImportMap(sourceFile);
+    function addHandlerSpecifiers(node) {
+        if (ts.isObjectLiteralExpression(node)) {
+            const specifiers = getPropertyValues(node, 'handler');
+            for (const specifier of specifiers)
+                entries.add(specifier.substring(0, specifier.lastIndexOf('.')));
+        }
+        ts.forEachChild(node, addHandlerSpecifiers);
+    }
+    function visit(node) {
+        if (ts.isCallExpression(node)) {
+            if (ts.isPropertyAccessExpression(node.expression)) {
+                if (node.expression.name.text === 'stack') {
+                    const arg = node.arguments[0];
+                    if (ts.isIdentifier(arg)) {
+                        const importPath = importMap.get(arg.text);
+                        if (importPath) {
+                            const input = toDeferResolveProductionEntry(importPath, { containingFilePath: options.configFilePath });
+                            const resolvedPath = getReferencedInternalFilePath(input);
+                            if (resolvedPath) {
+                                const stackFile = getSourceFile(resolvedPath);
+                                if (stackFile)
+                                    ts.forEachChild(stackFile, addHandlerSpecifiers);
+                            }
+                        }
+                    }
+                }
+                if (node.expression.name.text === 'route' && node.arguments.length >= 2) {
+                    const handlerArg = node.arguments[1];
+                    if (ts.isStringLiteral(handlerArg)) {
+                        entries.add(handlerArg.text);
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    ts.forEachChild(sourceFile, addHandlerSpecifiers);
+    ts.forEachChild(sourceFile, visit);
+    return Array.from(entries).map(specifier => toDeferResolveProductionEntry(specifier, { containingFilePath: options.configFilePath }));
+};

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

@@ -0,0 +1,9 @@
+import type { IsPluginEnabled, ResolveFromAST } from '../../types/config.js';
+declare const _default: {
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    resolveFromAST: ResolveFromAST;
+};
+export default _default;

package/dist/plugins/starlight/index.js

@@ -0,0 +1,18 @@
+import { toProductionEntry } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
+import { getComponentPathsFromSourceFile } from './resolveFromAST.js';
+const title = 'Starlight';
+const enablers = ['@astrojs/starlight'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['astro.config.{js,cjs,mjs,ts}'];
+const resolveFromAST = (sourceFile) => {
+    const componentPaths = getComponentPathsFromSourceFile(sourceFile);
+    return Array.from(componentPaths).map(id => toProductionEntry(id));
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveFromAST,
+};

package/dist/plugins/starlight/resolveFromAST.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare const getComponentPathsFromSourceFile: (sourceFile: ts.SourceFile) => Set<string>;

package/dist/plugins/starlight/resolveFromAST.js

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+import { getDefaultImportName, getImportMap, getPropertyValues } from '../../typescript/ast-helpers.js';
+export const getComponentPathsFromSourceFile = (sourceFile) => {
+    const componentPaths = new Set();
+    const importMap = getImportMap(sourceFile);
+    const starlightImportName = getDefaultImportName(importMap, '@astrojs/starlight');
+    function visit(node) {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === starlightImportName) {
+            const starlightConfig = node.arguments[0];
+            if (ts.isObjectLiteralExpression(starlightConfig)) {
+                const values = getPropertyValues(starlightConfig, 'components');
+                for (const value of values)
+                    componentPaths.add(value);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return componentPaths;
+};

package/dist/plugins/storybook/index.js

@@ -17,7 +17,10 @@ const resolveEntryPaths = async (localConfig, options) => {
             return relative(cwd, join(configFileDir, pattern));
         return relative(cwd, join(configFileDir, pattern.directory, pattern.files ?? stories[0]));
     });
-    const patterns = [...restEntry, ...(relativePatterns && relativePatterns.length > 0 ? relativePatterns : stories)];
+    const patterns = [
+        ...(options.config.entry ?? restEntry),
+        ...(relativePatterns && relativePatterns.length > 0 ? relativePatterns : stories),
+    ];
     return patterns.map(toEntry);
 };
 const resolveConfig = async (localConfig) => {

package/dist/plugins/tanstack-router/index.d.ts

@@ -0,0 +1,12 @@
+import type { IsPluginEnabled, ResolveEntryPaths, ResolveFromAST } from '../../types/config.js';
+import type { TanstackRouterConfig } from './types.js';
+declare const _default: {
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    production: string[];
+    resolveEntryPaths: ResolveEntryPaths<TanstackRouterConfig>;
+    resolveFromAST: ResolveFromAST;
+};
+export default _default;

package/dist/plugins/tanstack-router/index.js

@@ -0,0 +1,46 @@
+import { toEntry } from '../../util/input.js';
+import { extname, join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import { getCustomConfig } from './resolveFromAST.js';
+const title = 'tanstack-router';
+const enablers = ['@tanstack/react-router', '@tanstack/router-plugin', '@tanstack/router-cli'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = [
+    'tsr.config.json',
+    'vite.config.{js,mjs,ts,cjs,mts,cts}',
+    'rs{pack,build}.config.{js,mjs,ts,cjs,mts,cts}',
+    'webpack.config.{js,mjs,ts,cjs,mts,cts}',
+];
+const production = ['./src/routeTree.gen.ts', './src/routes/**/*.{ts,tsx}', '!src/routes/**/-*/**'];
+const getEntryPatterns = (config) => {
+    const dir = config.routesDirectory ?? 'src/routes';
+    const entries = [
+        toEntry(join(config.generatedRouteTree ?? './src/routeTree.gen.ts')),
+        toEntry(join(dir, '**', `${config.routeFilePrefix ?? ''}*`)),
+        toEntry(join(`!${dir}`, '**', `${config.routeFileIgnorePrefix ?? '-'}*`)),
+    ];
+    if (config.routeFileIgnorePattern) {
+        entries.push(toEntry(join(`!${dir}`, '**', `*${config.routeFileIgnorePattern}*`)));
+    }
+    return entries;
+};
+const resolveEntryPaths = (localConfig, options) => {
+    if (extname(options.configFileName) !== '.json')
+        return [];
+    return getEntryPatterns(localConfig);
+};
+const resolveFromAST = (sourceFile, options) => {
+    if (extname(options.configFileName) === '.json')
+        return [];
+    const resolvedConfig = getCustomConfig(sourceFile);
+    return getEntryPatterns(resolvedConfig);
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveEntryPaths,
+    resolveFromAST,
+};

package/dist/plugins/tanstack-router/resolveFromAST.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare const getCustomConfig: (sourceFile: ts.SourceFile) => Record<string, string>;

package/dist/plugins/tanstack-router/resolveFromAST.js

@@ -0,0 +1,28 @@
+import ts from 'typescript';
+import { getPropertyValueEntries } from '../../typescript/ast-helpers.js';
+const CONFIG_KEYS = new Set([
+    'routeFilePrefix',
+    'routeFileIgnorePrefix',
+    'routeFileIgnorePattern',
+    'routesDirectory',
+    'generatedRouteTree',
+]);
+const FUNCTIONS = new Set(['TanStackRouterVite', 'TanStackRouterRspack', 'TanStackRouterWebpack']);
+export const getCustomConfig = (sourceFile) => {
+    const config = {};
+    function visit(node) {
+        if (ts.isCallExpression(node)) {
+            const callee = node.expression;
+            if (ts.isIdentifier(callee) && FUNCTIONS.has(callee.text)) {
+                const firstArg = node.arguments[0];
+                if (ts.isObjectLiteralExpression(firstArg)) {
+                    for (const [key, value] of getPropertyValueEntries(firstArg, CONFIG_KEYS))
+                        config[key] = value;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return config;
+};

package/dist/plugins/tanstack-router/types.d.ts

@@ -0,0 +1,7 @@
+export type TanstackRouterConfig = {
+    routeFilePrefix?: string;
+    routeFileIgnorePrefix?: string;
+    routeFileIgnorePattern?: string;
+    routesDirectory?: string;
+    generatedRouteTree?: string;
+};

package/dist/plugins/tanstack-router/types.js

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

package/dist/reporters/codeowners.js

@@ -1,5 +1,5 @@
-import { OwnershipEngine } from '@snyk/github-codeowners/dist/lib/ownership/index.js';
 import picocolors from 'picocolors';
+import { createOwnershipEngine } from '../util/codeowners.js';
 import { relative, resolve, toRelative } from '../util/path.js';
 import { getTitle, logIssueLine, logTitle } from './util.js';
 const logIssueSet = (issues) => {
@@ -22,13 +22,15 @@ export default ({ report, issues, isShowProgress, options }) => {
         console.error(error);
     }
     const codeownersFilePath = resolve(opts.path ?? '.github/CODEOWNERS');
-    const codeownersEngine = OwnershipEngine.FromCodeownersFile(codeownersFilePath);
+    const findOwners = createOwnershipEngine(codeownersFilePath);
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
-    const [dependenciesOwner = '[no-owner]'] = codeownersEngine.calcFileOwnership('package.json');
-    const fallbackOwner = dependenciesOwner;
+    const [dependenciesOwner = '[no-owner]'] = findOwners('package.json');
     let totalIssues = 0;
-    const calcFileOwnership = (filePath) => codeownersEngine.calcFileOwnership(relative(filePath))[0] ?? fallbackOwner;
-    const addOwner = (issue) => ({ ...issue, owner: calcFileOwnership(issue.filePath) });
+    const calcFileOwnership = (filePath) => findOwners(relative(filePath))[0] ?? dependenciesOwner;
+    const addOwner = (issue) => ({
+        ...issue,
+        owner: calcFileOwnership(issue.filePath),
+    });
     for (const [reportType, isReportType] of Object.entries(report)) {
         if (isReportType) {
             const title = reportMultipleGroups && getTitle(reportType);

package/dist/reporters/json.js

@@ -1,4 +1,4 @@
-import { OwnershipEngine } from '@snyk/github-codeowners/dist/lib/ownership/index.js';
+import { createOwnershipEngine } from '../util/codeowners.js';
 import { isFile } from '../util/fs.js';
 import { relative, resolve } from '../util/path.js';
 import { convert } from './util.js';
@@ -12,13 +12,13 @@ export default async ({ report, issues, options }) => {
     }
     const json = {};
     const codeownersFilePath = resolve(opts.codeowners ?? '.github/CODEOWNERS');
-    const codeownersEngine = isFile(codeownersFilePath) && OwnershipEngine.FromCodeownersFile(codeownersFilePath);
+    const findOwners = isFile(codeownersFilePath) && createOwnershipEngine(codeownersFilePath);
     const flatten = (issues) => Object.values(issues).flatMap(Object.values);
     const initRow = (filePath) => {
         const file = relative(filePath);
         const row = {
             file,
-            ...(codeownersEngine && { owners: codeownersEngine.calcFileOwnership(file) }),
+            ...(findOwners && { owners: findOwners(file).map(name => ({ name })) }),
             ...(report.dependencies && { dependencies: [] }),
             ...(report.devDependencies && { devDependencies: [] }),
             ...(report.optionalPeerDependencies && { optionalPeerDependencies: [] }),