knip 6.24.0 → 6.25.0

package/dist/util/get-included-issue-types.js

@@ -1,11 +1,13 @@
 import { ISSUE_TYPES } from '../constants.js';
 import { ConfigurationError } from './errors.js';
-export const defaultExcludedIssueTypes = ['nsExports', 'nsTypes'];
+export const defaultExcludedIssueTypes = ['nsExports', 'nsTypes', 'cycles'];
+const defaultAddOnIssueTypes = ['nsExports', 'nsTypes'];
 const defaultIssueTypes = ISSUE_TYPES.filter(type => !defaultExcludedIssueTypes.includes(type));
 const normalize = (values) => values.flatMap(value => value.split(','));
 export const shorthandDeps = ['dependencies', 'unlisted', 'binaries', 'unresolved', 'catalog'];
 export const shorthandExports = ['exports', 'types', 'enumMembers', 'namespaceMembers', 'duplicates'];
 export const shorthandFiles = ['files'];
+export const shorthandCycles = ['cycles'];
 export const getIncludedIssueTypes = (options) => {
     const incl = normalize(options.includeOverrides ?? []);
     const excl = normalize(options.excludeOverrides ?? []);
@@ -28,7 +30,7 @@ export const getIncludedIssueTypes = (options) => {
             _exclude.push('devDependencies', 'optionalPeerDependencies');
     }
     const included = (_include.length > 0
-        ? _include.some(type => !defaultExcludedIssueTypes.includes(type))
+        ? _include.some(type => !defaultAddOnIssueTypes.includes(type))
             ? _include
             : [..._include, ...defaultIssueTypes]
         : defaultIssueTypes).filter(group => !_exclude.includes(group));

package/dist/util/issue-initializers.js

@@ -5,4 +5,4 @@ export const initCounters = () => ({
     processed: 0,
     total: 0,
 });
-export const defaultRules = Object.fromEntries(ISSUE_TYPES.map(issueType => [issueType, 'error']));
+export const defaultRules = Object.fromEntries(ISSUE_TYPES.map(issueType => [issueType, issueType === 'cycles' ? 'warn' : 'error']));

package/dist/util/load-tsconfig.js

@@ -2,7 +2,7 @@ import { parseTsconfig } from 'get-tsconfig';
 import { compact } from './array.js';
 import { isFile } from './fs.js';
 import { _syncGlob } from './glob.js';
-import { dirname, isAbsolute, join, toAbsolute } from './path.js';
+import { dirname, isAbsolute, join, toAbsolute, toPosix } from './path.js';
 const hasGlobChar = (p) => p.includes('*') || p.includes('?');
 const hasExtension = (p) => {
     const last = p.lastIndexOf('/');
@@ -17,7 +17,20 @@ const resolvePatterns = (patterns, dir, expandDirs = false) => {
         return expandDirs && !hasGlobChar(p) && !hasExtension(p) ? join(resolved, '**/*') : resolved;
     });
 };
-const pathsBaseDir = (baseUrl, dir) => (baseUrl ? toAbsolute(baseUrl, dir) : dir);
+const getImplicitBaseUrl = (compilerOptions) => {
+    for (const symbol of Object.getOwnPropertySymbols(compilerOptions)) {
+        if (symbol.description === 'implicitBaseUrl') {
+            const value = Reflect.get(compilerOptions, symbol);
+            if (typeof value === 'string')
+                return toPosix(value);
+        }
+    }
+};
+const pathsBaseDir = (compilerOptions, dir) => {
+    if (compilerOptions?.baseUrl)
+        return toAbsolute(compilerOptions.baseUrl, dir);
+    return (compilerOptions && getImplicitBaseUrl(compilerOptions)) ?? dir;
+};
 const collectPaths = (acc, paths, baseDir) => {
     if (!paths)
         return;
@@ -74,7 +87,7 @@ const walkReferences = (target, references, dir, visited, pairs, paths) => {
         const refConfig = parseTsconfig(refPath);
         const refDir = dirname(refPath);
         const refOpts = refConfig.compilerOptions;
-        collectPaths(paths, refOpts?.paths, pathsBaseDir(refOpts?.baseUrl, refDir));
+        collectPaths(paths, refOpts?.paths, pathsBaseDir(refOpts, refDir));
         const refOutDir = refOpts?.outDir ? absDir(refOpts.outDir, refDir) : undefined;
         const refRootDir = refOpts?.rootDir ? absDir(refOpts.rootDir, refDir) : undefined;
         if (refOutDir && refRootDir && refOutDir !== refRootDir)
@@ -109,7 +122,7 @@ export const loadTSConfig = async (tsConfigFilePath) => {
         if (compilerOptions.rootDirs)
             compilerOptions.rootDirs = compilerOptions.rootDirs.map(d => absDir(d, dir));
         const tsconfigPaths = {};
-        collectPaths(tsconfigPaths, compilerOptions.paths, pathsBaseDir(compilerOptions.baseUrl, dir));
+        collectPaths(tsconfigPaths, compilerOptions.paths, pathsBaseDir(compilerOptions, dir));
         const sourceMapPairs = [];
         if (config.references?.length) {
             walkReferences(compilerOptions, config.references, dir, new Set([tsConfigFilePath]), sourceMapPairs, tsconfigPaths);

package/dist/util/module-graph.js

@@ -47,6 +47,7 @@ export const createFileNode = () => ({
     exports: new Map(),
     duplicates: new Set(),
     scripts: new Set(),
+    importGlobs: [],
     importedBy: undefined,
     internalImportCache: undefined,
 });

package/dist/util/modules.js

@@ -1,5 +1,6 @@
+import { readFileSync } from 'node:fs';
 import { DT_SCOPE, PROTOCOL_VIRTUAL } from '../constants.js';
-import { isAbsolute, isInNodeModules, toPosix } from './path.js';
+import { isAbsolute, isInNodeModules, join, toPosix } from './path.js';
 export const getPackageNameFromModuleSpecifier = (specifier) => {
     if (!isStartsLikePackageName(specifier))
         return;
@@ -18,13 +19,33 @@ export const getPackageNameFromModuleSpecifier = (specifier) => {
     return specifier;
 };
 const lastPackageNameMatch = /(?<=node_modules\/)(@[^/]+\/[^/]+|[^/]+)/g;
+const yarnPnpmStorePackageRoot = /^(.*\/node_modules\/\.store\/[^/]+\/package)(?:\/|$)/;
+const yarnPnpmStoreNameCache = new Map();
+const getPackageNameFromYarnPnpmStore = (posixPath) => {
+    const match = posixPath.match(yarnPnpmStorePackageRoot);
+    if (!match)
+        return;
+    const root = match[1];
+    if (yarnPnpmStoreNameCache.has(root))
+        return yarnPnpmStoreNameCache.get(root);
+    let name;
+    try {
+        name = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).name;
+    }
+    catch { }
+    yarnPnpmStoreNameCache.set(root, name);
+    return name;
+};
 export const getPackageNameFromFilePath = (value) => {
     const name = value.startsWith('file://') ? value.slice(7) : value;
     if (name.includes('node_modules/.bin/'))
         return extractBinary(name);
-    const match = toPosix(name).match(lastPackageNameMatch);
-    if (match)
-        return match[match.length - 1];
+    const posixPath = toPosix(name);
+    const match = posixPath.match(lastPackageNameMatch);
+    if (match) {
+        const last = match[match.length - 1];
+        return last === '.store' ? (getPackageNameFromYarnPnpmStore(posixPath) ?? last) : last;
+    }
     return name;
 };
 export const getPackageNameFromSpecifier = (specifier) => isInNodeModules(specifier) ? getPackageNameFromFilePath(specifier) : getPackageNameFromModuleSpecifier(specifier);

package/dist/util/scripts.d.ts

@@ -0,0 +1,7 @@
+import { type Command, type Node } from 'unbash';
+export interface ScriptCommand {
+    binary: string;
+    args: string[];
+}
+export declare function walkCommands(node: Node): Generator<Command>;
+export declare const getScriptCommands: (script: string) => ScriptCommand[];

package/dist/util/scripts.js

@@ -0,0 +1,75 @@
+import { parse } from 'unbash';
+import { extractBinary } from './modules.js';
+const spawningBinaries = new Set(['cross-env', 'retry-cli']);
+export function* walkCommands(node) {
+    switch (node.type) {
+        case 'Command':
+            yield node;
+            break;
+        case 'AndOr':
+        case 'Pipeline':
+            for (const command of node.commands)
+                yield* walkCommands(command);
+            break;
+        case 'If':
+            for (const statement of node.clause.commands)
+                yield* walkCommands(statement.command);
+            for (const statement of node.then.commands)
+                yield* walkCommands(statement.command);
+            if (node.else)
+                yield* walkCommands(node.else);
+            break;
+        case 'While':
+            for (const statement of node.clause.commands)
+                yield* walkCommands(statement.command);
+            for (const statement of node.body.commands)
+                yield* walkCommands(statement.command);
+            break;
+        case 'For':
+        case 'Select':
+        case 'Subshell':
+        case 'BraceGroup':
+            for (const statement of node.body.commands)
+                yield* walkCommands(statement.command);
+            break;
+        case 'CompoundList':
+            for (const statement of node.commands)
+                yield* walkCommands(statement.command);
+            break;
+        case 'Function':
+        case 'Coproc':
+            yield* walkCommands(node.body);
+            break;
+        case 'Statement':
+            yield* walkCommands(node.command);
+            break;
+    }
+}
+export const getScriptCommands = (script) => {
+    if (!script)
+        return [];
+    let parsed;
+    try {
+        parsed = parse(script);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed.commands)
+        return [];
+    const out = [];
+    for (const statement of parsed.commands) {
+        for (const node of walkCommands(statement.command)) {
+            const text = node.name?.value;
+            if (!text)
+                continue;
+            const binary = extractBinary(text);
+            const args = node.suffix.map(word => word.value);
+            if (spawningBinaries.has(binary))
+                out.push(...getScriptCommands(args.filter(arg => arg !== '--').join(' ')));
+            else
+                out.push({ binary, args });
+        }
+    }
+    return out;
+};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.24.0";
+export declare const version = "6.25.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.24.0';
+export const version = '6.25.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.24.0",
+  "version": "6.25.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",

package/schema.json

@@ -67,6 +67,33 @@
         "$ref": "#/definitions/issueTypes"
       }
     },
+    "cycles": {
+      "title": "Configure circular dependency (cycles) detection",
+      "examples": [
+        {
+          "dynamicImports": true,
+          "allow": [["src/a.ts", "src/b.ts"]]
+        }
+      ],
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "dynamicImports": {
+          "title": "Include dynamic import() edges in cycle detection (excluded by default)",
+          "type": "boolean"
+        },
+        "allow": {
+          "title": "Allow (accept) specific cycles by exact path, relative to the root and omitting the closing repeat of the first file",
+          "type": "array",
+          "items": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    },
     "includeEntryExports": {
       "$ref": "#/definitions/includeEntryExports"
     },
@@ -99,6 +126,9 @@
         "catalog": {
           "$ref": "#/definitions/ruleValue"
         },
+        "cycles": {
+          "$ref": "#/definitions/ruleValue"
+        },
         "dependencies": {
           "$ref": "#/definitions/ruleValue"
         },
@@ -251,7 +281,8 @@
           "duplicates",
           "enumMembers",
           "namespaceMembers",
-          "catalog"
+          "catalog",
+          "cycles"
         ]
       }
     },
@@ -483,6 +514,10 @@
           "title": "ESLint plugin configuration (https://knip.dev/reference/plugins/eslint)",
           "$ref": "#/definitions/plugin"
         },
+        "eve": {
+          "title": "eve plugin configuration (https://knip.dev/reference/plugins/eve)",
+          "$ref": "#/definitions/plugin"
+        },
         "execa": {
           "title": "execa plugin configuration (https://knip.dev/reference/plugins/execa)",
           "$ref": "#/definitions/plugin"
@@ -499,6 +534,10 @@
           "title": "fast plugin configuration (https://knip.dev/reference/plugins/fast)",
           "$ref": "#/definitions/plugin"
         },
+        "fumadocs": {
+          "title": "fumadocs plugin configuration (https://knip.dev/reference/plugins/fumadocs)",
+          "$ref": "#/definitions/plugin"
+        },
         "gatsby": {
           "title": "Gatsby plugin configuration (https://knip.dev/reference/plugins/gatsby)",
           "$ref": "#/definitions/plugin"