knip 5.70.2 → 5.72.0

package/dist/util/watch.js

@@ -2,18 +2,23 @@ import { debugLog } from './debug.js';
 import { isFile } from './fs.js';
 import { updateImportMap } from './module-graph.js';
 import { join, toAbsolute, toRelative } from './path.js';
-export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onUpdate, unreferencedFiles, }) => {
+const createUpdate = (options) => {
+    const duration = performance.now() - options.startTime;
+    const mem = process.memoryUsage().heapUsed;
+    return { duration, mem };
+};
+export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, factory, graph, isIgnored, onFileChange, unreferencedFiles, entryPaths, }) => {
     const getIssues = () => collector.getIssues().issues;
-    const processBatch = async (changes) => {
+    const handleFileChanges = async (changes) => {
         const startTime = performance.now();
         const added = new Set();
         const deleted = new Set();
         const modified = new Set();
-        for (const [type, _path] of changes) {
-            const filePath = toAbsolute(_path, options.cwd);
-            const relativePath = toRelative(_path, options.cwd);
+        for (const change of changes) {
+            const filePath = toAbsolute(change.filePath, options.cwd);
+            const relativePath = toRelative(change.filePath, options.cwd);
             if (isIgnored(filePath)) {
-                debugLog('*', `ignoring ${type} ${relativePath}`);
+                debugLog('*', `ignoring ${change.type} ${relativePath}`);
                 continue;
             }
             const workspace = chief.findWorkspaceByFilePath(filePath);
@@ -22,7 +27,7 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
             const principal = factory.getPrincipalByPackageName(workspace.pkgName);
             if (!principal)
                 continue;
-            switch (type) {
+            switch (change.type) {
                 case 'added':
                     added.add(filePath);
                     principal.addProjectPath(filePath);
@@ -35,7 +40,7 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
                     principal.removeProjectPath(filePath);
                     debugLog(workspace.name, `Watcher: - ${relativePath}`);
                     break;
-                case 'modified':
+                default:
                     modified.add(filePath);
                     debugLog(workspace.name, `Watcher: ± ${relativePath}`);
                     break;
@@ -43,7 +48,7 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
             principal.invalidateFile(filePath);
         }
         if (added.size === 0 && deleted.size === 0 && modified.size === 0)
-            return;
+            return createUpdate({ startTime });
         unreferencedFiles.clear();
         const cachedUnusedFiles = collector.purge();
         for (const filePath of added)
@@ -110,15 +115,21 @@ export const getWatchHandler = async (options, { analyzedFiles, analyzeSourceFil
         collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
         for (const issue of collector.getRetainedIssues())
             collector.addIssue(issue);
-        onUpdate({ issues: getIssues(), duration: performance.now() - startTime });
+        const update = createUpdate({ startTime });
+        if (onFileChange)
+            onFileChange(Object.assign({ issues: getIssues() }, update));
+        return update;
     };
-    const listener = (eventType, filename) => {
-        debugLog('*', `(raw) ${eventType} ${filename}`);
-        if (typeof filename === 'string') {
-            const event = eventType === 'rename' ? (isFile(join(options.cwd, filename)) ? 'added' : 'deleted') : 'modified';
-            processBatch([[event, filename]]);
+    const listener = (eventType, filePath) => {
+        debugLog('*', `(raw) ${eventType} ${filePath}`);
+        if (typeof filePath === 'string') {
+            const type = eventType === 'rename' ? (isFile(join(options.cwd, filePath)) ? 'added' : 'deleted') : 'modified';
+            handleFileChanges([{ type, filePath }]);
         }
     };
-    onUpdate({ issues: getIssues() });
-    return listener;
+    if (onFileChange)
+        onFileChange({ issues: getIssues() });
+    const getEntryPaths = () => entryPaths;
+    const getGraph = () => graph;
+    return { listener, handleFileChanges, getEntryPaths, getGraph, getIssues };
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.70.2";
+export declare const version = "5.72.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.70.2';
+export const version = '5.72.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.70.2",
+  "version": "5.72.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {
@@ -39,7 +39,7 @@
     "test": "node scripts/run-test.ts",
     "test:node": "tsx --test test/*.test.ts test/**/*.test.ts",
     "test:bun": "bun test test/*.test.ts test/**/*.test.ts",
-    "test:smoke": "glob -c \"tsx --test\" \"test/*.test.ts\" && glob -c \"tsx --test\" \"test/{plugins,util}/*.test.ts\"",
+    "test:smoke": "glob-bin -c \"tsx --test\" \"test/*.test.ts\" && glob-bin -c \"tsx --test\" \"test/{plugins,util}/*.test.ts\"",
     "test:bun:smoke": "bun test test/*.test.ts test/{plugins,util}/*.test.ts",
     "watch": "npm link && tsc --watch",
     "prebuild": "pnpm run generate-plugin-defs && node rmdir.js dist",
@@ -63,7 +63,7 @@
     "jiti": "^2.6.0",
     "js-yaml": "^4.1.1",
     "minimist": "^1.2.8",
-    "oxc-resolver": "^11.13.2",
+    "oxc-resolver": "^11.15.0",
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.1",
     "smol-toml": "^1.5.2",
@@ -77,14 +77,14 @@
   "devDependencies": {
     "@jest/types": "^29.6.3",
     "@release-it/bumper": "^7.0.5",
-    "@types/bun": "1.2.22",
+    "@types/bun": "^1.3.3",
     "@types/js-yaml": "^4.0.9",
     "@types/minimist": "^1.2.5",
-    "@types/picomatch": "3.0.1",
+    "@types/picomatch": "^4.0.1",
     "@types/webpack": "^5.28.5",
-    "@wdio/types": "^9.16.2",
+    "@wdio/types": "^9.20.0",
     "codeclimate-types": "^0.3.1",
-    "glob": "^11.0.2",
+    "glob-bin": "^1.0.0",
     "release-it": "^19.0.5",
     "tsx": "^4.20.3",
     "typescript": "^5.5.2"

package/schema.json

@@ -714,6 +714,10 @@
           "title": "svgo plugin configuration (https://knip.dev/reference/plugins/svgo)",
           "$ref": "#/definitions/plugin"
         },
+        "svgr": {
+          "title": "svgr plugin configuration (https://knip.dev/reference/plugins/svgr)",
+          "$ref": "#/definitions/plugin"
+        },
         "syncpack": {
           "title": "syncpack plugin configuration (https://knip.dev/reference/plugins/syncpack)",
           "$ref": "#/definitions/plugin"

package/vendor/bash-parser/index.d.ts

@@ -43,6 +43,11 @@ type Function_ = {
   body: CompoundList;
 };
 
+type Subshell = {
+  type: 'Subshell';
+  list: CompoundList;
+};
+
 export type ExpansionNode = {
   expansion: Expansion[];
 };
@@ -62,7 +67,7 @@ export type Assignment = {
   text: string;
 };
 
-export type Node = CompoundList | Command | LogicalExpression | If | For | Function_ | Pipeline;
+export type Node = CompoundList | Command | LogicalExpression | If | For | Function_ | Pipeline | Subshell;
 
 export type AST = {
   type: 'Script';

package/dist/util/has-strictly-ns-references.d.ts

@@ -1,4 +0,0 @@
-import type { ImportMaps, ModuleGraph } from '../types/module-graph.js';
-export declare const hasStrictlyEnumReferences: (importsForExport: ImportMaps | undefined, id: string) => boolean;
-export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportMaps | undefined, id: string) => [boolean, string?];
-export declare const getType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "types" | "nsTypes";

package/dist/util/has-strictly-ns-references.js

@@ -1,103 +0,0 @@
-import { IMPORT_STAR } from '../constants.js';
-export const hasStrictlyEnumReferences = (importsForExport, id) => {
-    if (!importsForExport || !importsForExport.refs.has(id))
-        return false;
-    for (const ref of importsForExport.refs)
-        if (ref.startsWith(`${id}.`))
-            return false;
-    return true;
-};
-export const hasStrictlyNsReferences = (graph, importsForExport, id) => {
-    if (!importsForExport)
-        return [false];
-    let namespace;
-    for (const ns of importsForExport.importedNs.keys()) {
-        const hasNs = importsForExport.refs.has(ns);
-        if (!hasNs)
-            return [false, ns];
-        for (const id of importsForExport.refs)
-            if (id.startsWith(`${ns}.`))
-                return [false, ns];
-        const byFilePaths = importsForExport.reExportedNs.get(ns);
-        if (byFilePaths) {
-            for (const filePath of byFilePaths) {
-                const file = graph.get(filePath);
-                if (file?.imported) {
-                    const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                    if (hasStrictlyNsRefs[0] === false)
-                        return hasStrictlyNsRefs;
-                }
-            }
-        }
-        const reExportedAs = importsForExport.reExportedAs.get(ns);
-        if (reExportedAs) {
-            for (const byFilePaths of reExportedAs.values()) {
-                for (const filePath of byFilePaths) {
-                    const file = graph.get(filePath);
-                    if (file?.imported) {
-                        const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                        if (hasStrictlyNsRefs[0] === false)
-                            return hasStrictlyNsRefs;
-                    }
-                }
-            }
-        }
-        namespace = ns;
-    }
-    const byFilePaths = importsForExport.reExported.get(id);
-    if (byFilePaths) {
-        for (const filePath of byFilePaths) {
-            const file = graph.get(filePath);
-            if (file?.imported) {
-                const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                if (hasStrictlyNsRefs[0] === false)
-                    return hasStrictlyNsRefs;
-                namespace = hasStrictlyNsRefs[1];
-            }
-        }
-    }
-    {
-        const byFilePaths = importsForExport.reExported.get(IMPORT_STAR);
-        if (byFilePaths) {
-            for (const filePath of byFilePaths) {
-                const file = graph.get(filePath);
-                if (file?.imported) {
-                    const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, id);
-                    if (hasStrictlyNsRefs[0] === false)
-                        return hasStrictlyNsRefs;
-                    namespace = hasStrictlyNsRefs[1];
-                }
-            }
-        }
-    }
-    const [identifier, ...rest] = id.split('.');
-    const reExportedAs = importsForExport.reExportedAs.get(identifier);
-    if (reExportedAs) {
-        for (const [alias, filePaths] of reExportedAs.entries()) {
-            for (const filePath of filePaths) {
-                const file = graph.get(filePath);
-                if (file?.imported) {
-                    const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, [alias, ...rest].join('.'));
-                    if (hasStrictlyNsRefs[0] === false)
-                        return hasStrictlyNsRefs;
-                    namespace = hasStrictlyNsRefs[1];
-                }
-            }
-        }
-    }
-    for (const [ns, filePaths] of importsForExport.reExportedNs.entries()) {
-        for (const filePath of filePaths) {
-            const file = graph.get(filePath);
-            if (file?.imported) {
-                const hasStrictlyNsRefs = hasStrictlyNsReferences(graph, file.imported, `${ns}.${id}`);
-                if (hasStrictlyNsRefs[0] === false)
-                    return hasStrictlyNsRefs;
-                namespace = hasStrictlyNsRefs[1];
-            }
-        }
-    }
-    if (namespace)
-        return [true, namespace];
-    return [false];
-};
-export const getType = (hasOnlyNsReference, isType) => hasOnlyNsReference ? (isType ? 'nsTypes' : 'nsExports') : isType ? 'types' : 'exports';

package/dist/util/is-identifier-referenced.d.ts

@@ -1,9 +0,0 @@
-import type { ModuleGraph } from '../types/module-graph.js';
-import { type TraceNode } from './trace.js';
-type Result = {
-    isReferenced: boolean;
-    reExportingEntryFile: undefined | string;
-    traceNode: TraceNode;
-};
-export declare const getIsIdentifierReferencedHandler: (graph: ModuleGraph, entryPaths: Set<string>, isTrace: boolean) => (filePath: string, id: string, isIncludeEntryExports?: boolean, traceNode?: TraceNode, seen?: Set<string>) => Result;
-export {};

package/dist/util/is-identifier-referenced.js

@@ -1,145 +0,0 @@
-import { IMPORT_STAR, OPAQUE } from '../constants.js';
-import { addNodes, createNode } from './trace.js';
-export const getIsIdentifierReferencedHandler = (graph, entryPaths, isTrace) => {
-    const isIdentifierReferenced = (filePath, id, isIncludeEntryExports = false, traceNode = createNode(filePath), seen = new Set()) => {
-        let isReferenced = false;
-        let reExportingEntryFile = entryPaths.has(filePath) ? filePath : undefined;
-        if (reExportingEntryFile)
-            traceNode.isEntry = true;
-        if (!isIncludeEntryExports && reExportingEntryFile)
-            return { isReferenced, reExportingEntryFile, traceNode };
-        seen.add(filePath);
-        const restIds = id.split('.');
-        const identifier = restIds.shift();
-        const file = graph.get(filePath)?.imported;
-        if (!identifier || !file)
-            return { isReferenced, reExportingEntryFile, traceNode };
-        if (file.imported.get(OPAQUE) ||
-            ((identifier === id || (identifier !== id && file.refs.has(id))) &&
-                (file.imported.has(identifier) || file.importedAs.has(identifier)))) {
-            isReferenced = true;
-            if (!isTrace)
-                return { isReferenced, reExportingEntryFile, traceNode };
-            if (file.importedAs.has(identifier)) {
-                for (const aliases of file.importedAs.values()) {
-                    for (const alias of aliases.keys())
-                        addNodes(traceNode, alias, graph, aliases.get(alias));
-                }
-            }
-            else
-                addNodes(traceNode, id, graph, file.imported.get(identifier));
-        }
-        for (const [exportId, aliases] of file.importedAs.entries()) {
-            if (identifier === exportId) {
-                for (const alias of aliases.keys()) {
-                    const aliasedRef = [alias, ...restIds].join('.');
-                    if (file.refs.has(aliasedRef)) {
-                        isReferenced = true;
-                        if (!isTrace)
-                            return { isReferenced, reExportingEntryFile, traceNode };
-                        addNodes(traceNode, aliasedRef, graph, aliases.get(alias));
-                    }
-                }
-            }
-        }
-        for (const [namespace, byFilePaths] of file.importedNs) {
-            if (file.refs.has(`${namespace}.${id}`)) {
-                isReferenced = true;
-                if (!isTrace)
-                    return { isReferenced, reExportingEntryFile, traceNode };
-                addNodes(traceNode, `${namespace}.${id}`, graph, byFilePaths);
-            }
-            const reExportedAs = file.reExportedAs.get(namespace);
-            if (reExportedAs) {
-                for (const [alias, byFilePaths] of reExportedAs) {
-                    for (const byFilePath of byFilePaths) {
-                        if (!seen.has(byFilePath)) {
-                            const child = createNode(byFilePath);
-                            traceNode.children.add(child);
-                            const result = isIdentifierReferenced(byFilePath, `${alias}.${id}`, isIncludeEntryExports, child, seen);
-                            if (result.reExportingEntryFile)
-                                reExportingEntryFile = result.reExportingEntryFile;
-                            if (result.isReferenced) {
-                                isReferenced = true;
-                                if (!isTrace)
-                                    return { isReferenced, reExportingEntryFile, traceNode };
-                            }
-                        }
-                    }
-                }
-            }
-            const reExportedNs = file.reExportedNs.get(namespace);
-            if (reExportedNs) {
-                for (const byFilePath of reExportedNs) {
-                    if (!seen.has(byFilePath)) {
-                        const child = createNode(byFilePath);
-                        traceNode.children.add(child);
-                        const result = isIdentifierReferenced(byFilePath, `${namespace}.${id}`, isIncludeEntryExports, child, seen);
-                        if (result.reExportingEntryFile)
-                            reExportingEntryFile = result.reExportingEntryFile;
-                        if (result.isReferenced) {
-                            isReferenced = true;
-                            if (!isTrace)
-                                return { isReferenced, reExportingEntryFile, traceNode };
-                        }
-                    }
-                }
-            }
-        }
-        const reExportedAs = file.reExportedAs.get(identifier);
-        if (reExportedAs) {
-            for (const [alias, byFilePaths] of reExportedAs) {
-                for (const byFilePath of byFilePaths) {
-                    if (!seen.has(byFilePath)) {
-                        const child = createNode(byFilePath);
-                        traceNode.children.add(child);
-                        const ref = [alias, ...restIds].join('.');
-                        const result = isIdentifierReferenced(byFilePath, ref, isIncludeEntryExports, child, seen);
-                        if (result.reExportingEntryFile)
-                            reExportingEntryFile = result.reExportingEntryFile;
-                        if (result.isReferenced) {
-                            isReferenced = true;
-                            if (!isTrace)
-                                return { isReferenced, reExportingEntryFile, traceNode };
-                        }
-                    }
-                }
-            }
-        }
-        const reExported = file.reExported.get(identifier) ?? file.reExported.get(IMPORT_STAR);
-        if (reExported) {
-            for (const byFilePath of reExported) {
-                if (!seen.has(byFilePath)) {
-                    const child = createNode(byFilePath);
-                    traceNode.children.add(child);
-                    const result = isIdentifierReferenced(byFilePath, id, isIncludeEntryExports, child, seen);
-                    if (result.reExportingEntryFile)
-                        reExportingEntryFile = result.reExportingEntryFile;
-                    if (result.isReferenced) {
-                        isReferenced = true;
-                        if (!isTrace)
-                            return { isReferenced, reExportingEntryFile, traceNode };
-                    }
-                }
-            }
-        }
-        for (const [namespace, byFilePaths] of file.reExportedNs.entries()) {
-            for (const byFilePath of byFilePaths) {
-                if (!seen.has(byFilePath)) {
-                    const child = createNode(byFilePath);
-                    traceNode.children.add(child);
-                    const result = isIdentifierReferenced(byFilePath, `${namespace}.${id}`, isIncludeEntryExports, child, seen);
-                    if (result.reExportingEntryFile)
-                        reExportingEntryFile = result.reExportingEntryFile;
-                    if (result.isReferenced) {
-                        isReferenced = true;
-                        if (!isTrace)
-                            return { isReferenced, reExportingEntryFile, traceNode };
-                    }
-                }
-            }
-        }
-        return { isReferenced, reExportingEntryFile, traceNode };
-    };
-    return isIdentifierReferenced;
-};