knip 5.78.0 → 5.80.0

package/dist/ConfigurationChief.d.ts

@@ -243,6 +243,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        knex?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         ladle?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -383,6 +388,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        parcel?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         playwright?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -558,6 +568,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'tanstack-router'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         taskfile?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -732,6 +747,7 @@ export declare class ConfigurationChief {
         husky?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "i18next-parser"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         karma?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        knex?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         ladle?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         lefthook?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "lint-staged"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -759,6 +775,7 @@ export declare class ConfigurationChief {
         nyc?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         oclif?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         oxlint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        parcel?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         playwright?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "playwright-ct"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "playwright-test"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -793,6 +810,7 @@ export declare class ConfigurationChief {
         swc?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         syncpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tailwind?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "tanstack-router"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         taskfile?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         travis?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "ts-node"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/ProjectPrincipal.js

@@ -226,7 +226,7 @@ export class ProjectPrincipal {
             const fd = this.cache.getFileDescriptor(filePath);
             if (!fd?.meta)
                 continue;
-            fd.meta.data = { ...file, internalImportCache: undefined, imported: undefined };
+            fd.meta.data = { ...file, internalImportCache: undefined, importedBy: undefined };
         }
         this.cache.reconcile();
     }

package/dist/binaries/package-manager/bun.js

@@ -6,26 +6,47 @@ import { resolveX } from './bunx.js';
 const commands = [
     'add',
     'audit',
+    'auth',
     'build',
+    'c',
     'ci',
+    'cloud',
+    'completions',
+    'config',
     'create',
+    'deploy',
+    'discord',
     'exec',
     'feedback',
+    'fuzzilli',
+    'getcompletes',
+    'help',
+    'i',
     'info',
     'init',
     'install',
     'link',
+    'list',
+    'login',
+    'logout',
     'outdated',
     'patch',
+    'patch-commit',
     'pm',
+    'prune',
     'publish',
+    'r',
     'remove',
     'repl',
+    'rm',
     'run',
     'test',
     'unlink',
+    'uninstall',
     'update',
     'upgrade',
+    'use',
+    'whoami',
     'why',
     'x',
 ];

package/dist/compilers/index.d.ts

@@ -194,6 +194,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    knex?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     ladle?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -334,6 +339,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    parcel?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     playwright?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -509,6 +519,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'tanstack-router'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     taskfile?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -815,6 +830,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        knex?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         ladle?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -955,6 +975,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        parcel?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         playwright?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1130,6 +1155,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'tanstack-router'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         taskfile?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/graph/analyze.js

@@ -8,12 +8,15 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
     const explorer = createGraphExplorer(graph, entryPaths);
-    const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
-    const isExportReferencedInFile = (exportedItem) => exportedItem.self[1] ||
-        (exportedItem.self[0] > 0 &&
-            (typeof ignoreExportsUsedInFile === 'object'
-                ? exportedItem.type !== 'unknown' && !!ignoreExportsUsedInFile[exportedItem.type]
-                : ignoreExportsUsedInFile));
+    const isReferencedInUsedExport = (exportedItem, filePath, includeEntryExports) => {
+        if (!exportedItem.referencedIn)
+            return false;
+        for (const containingExport of exportedItem.referencedIn) {
+            if (explorer.isReferenced(filePath, containingExport, { includeEntryExports })[0])
+                return true;
+        }
+        return false;
+    };
     const analyzeGraph = async () => {
         if (options.isReportValues || options.isReportTypes) {
             streamer.cast('Connecting the dots');
@@ -29,7 +32,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     if (!isIncludeEntryExports && isEntry) {
                         continue;
                     }
-                    const importsForExport = file.imported;
+                    const importsForExport = file.importedBy;
                     for (const [identifier, exportedItem] of exportItems) {
                         if (shouldIgnore(exportedItem.jsDocTags))
                             continue;
@@ -38,7 +41,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             const [isReferenced, reExportingEntryFile] = explorer.isReferenced(filePath, identifier, {
                                 includeEntryExports: isIncludeEntryExports,
                             });
-                            if ((isReferenced || exportedItem.self[1]) && isIgnored) {
+                            if (isIgnored &&
+                                (isReferenced || isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports))) {
                                 for (const tagName of exportedItem.jsDocTags) {
                                     if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
                                         collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
@@ -66,7 +70,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             continue;
                                         if (shouldIgnore(member.jsDocTags))
                                             continue;
-                                        if (member.self[0] === 0) {
+                                        if (!member.hasRefsInFile) {
                                             const id = `${identifier}.${member.identifier}`;
                                             const [isMemberReferenced] = explorer.isReferenced(filePath, id, {
                                                 includeEntryExports: true,
@@ -127,28 +131,28 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                         }
                         const [hasStrictlyNsRefs, namespace] = explorer.hasStrictlyNsReferences(filePath, identifier);
                         const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
-                        if (hasStrictlyNsRefs &&
-                            ((!options.includedIssueTypes.nsTypes && isType) || !(options.includedIssueTypes.nsExports || isType)))
+                        if (isIgnored ||
+                            exportedItem.hasRefsInFile ||
+                            isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports) ||
+                            (hasStrictlyNsRefs &&
+                                ((!options.includedIssueTypes.nsTypes && isType) ||
+                                    !(options.includedIssueTypes.nsExports || isType))) ||
+                            (!options.isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))) {
                             continue;
-                        if (!isExportReferencedInFile(exportedItem)) {
-                            if (isIgnored)
-                                continue;
-                            if (!options.isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
-                                continue;
-                            const type = getIssueType(hasStrictlyNsRefs, isType);
-                            collector.addIssue({
-                                type,
-                                filePath,
-                                workspace: workspace.name,
-                                symbol: identifier,
-                                symbolType: exportedItem.type,
-                                parentSymbol: namespace,
-                                pos: exportedItem.pos,
-                                line: exportedItem.line,
-                                col: exportedItem.col,
-                                fixes: exportedItem.fixes,
-                            });
                         }
+                        const type = getIssueType(hasStrictlyNsRefs, isType);
+                        collector.addIssue({
+                            type,
+                            filePath,
+                            workspace: workspace.name,
+                            symbol: identifier,
+                            symbolType: exportedItem.type,
+                            parentSymbol: namespace,
+                            pos: exportedItem.pos,
+                            line: exportedItem.line,
+                            col: exportedItem.col,
+                            fixes: exportedItem.fixes,
+                        });
                     }
                 }
             }
@@ -231,6 +235,6 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
     };
     await analyzeGraph();
     if (options.isTrace)
-        traceReporter({ graph, explorer, options, isExportReferencedInFile });
+        traceReporter({ graph, explorer, options });
     return analyzeGraph;
 };

package/dist/graph/build.js

@@ -212,7 +212,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 collector.addConfigurationHint(hint);
         }
         principal.addEntryPaths(userEntryPaths);
-        if (options.isUseTscFiles) {
+        if (options.isUseTscFiles && isFile) {
             const isIgnoredWorkspace = chief.createIgnoredWorkspaceMatcher(name, dir);
             debugLogArray(name, 'Using tsconfig files as project files', tscSourcePaths);
             for (const filePath of tscSourcePaths) {

package/dist/graph-explorer/explorer.js

@@ -10,7 +10,7 @@ import { resolveDefinition } from './operations/resolve-definition.js';
 export const createGraphExplorer = (graph, entryPaths) => {
     return {
         isReferenced: (filePath, identifier, options) => isReferenced(graph, entryPaths, filePath, identifier, options),
-        hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, graph.get(filePath)?.imported, identifier),
+        hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, filePath, graph.get(filePath)?.importedBy, identifier),
         buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),
         getDependencyUsage: (pattern) => getDependencyUsage(graph, pattern),
         resolveDefinition: (filePath, identifier) => resolveDefinition(graph, filePath, identifier),

package/dist/graph-explorer/operations/build-exports-tree.js

@@ -27,7 +27,7 @@ const buildExportTree = (graph, entryPaths, filePath, identifier) => {
     const rootNode = {
         filePath,
         identifier,
-        refs: filterRefs(file?.imported?.refs, identifier),
+        refs: filterRefs(file?.importedBy?.refs, identifier),
         isEntry: entryPaths.has(filePath),
         children: [],
         originalId: undefined,
@@ -82,7 +82,7 @@ const hasRelevantRef = (refs, id) => {
 const isNsReExported = (importMaps, ns) => {
     if (!importMaps)
         return false;
-    return importMaps.reExportedAs.has(ns) || importMaps.reExportedNs.has(ns);
+    return importMaps.reExportAs.has(ns) || importMaps.reExportNs.has(ns);
 };
 const hasNonReExportStar = (node) => {
     if (node.via && node.via !== 'reExportStar')

package/dist/graph-explorer/operations/get-contention.js

@@ -100,7 +100,7 @@ const walkDown = (graph, network, filePath, identifier, visited) => {
         return;
     visited.add(filePath);
     const node = graph.get(filePath);
-    if (!node?.imported)
+    if (!node?.importedBy)
         return;
     const processConsumer = (consumerPath) => {
         network.files.add(consumerPath);
@@ -110,12 +110,12 @@ const walkDown = (graph, network, filePath, identifier, visited) => {
             network.definitions.add(consumerPath);
         walkDown(graph, network, consumerPath, identifier, visited);
     };
-    const directConsumers = node.imported.reExported.get(identifier);
+    const directConsumers = node.importedBy.reExport.get(identifier);
     if (directConsumers) {
         for (const consumerPath of directConsumers)
             processConsumer(consumerPath);
     }
-    for (const [sourceId, aliasMap] of node.imported.reExportedAs) {
+    for (const [sourceId, aliasMap] of node.importedBy.reExportAs) {
         if (sourceId === identifier) {
             for (const [_alias, consumers] of aliasMap) {
                 for (const consumerPath of consumers)
@@ -123,7 +123,7 @@ const walkDown = (graph, network, filePath, identifier, visited) => {
             }
         }
     }
-    const starConsumers = node.imported.reExported.get(IMPORT_STAR);
+    const starConsumers = node.importedBy.reExport.get(IMPORT_STAR);
     if (starConsumers) {
         for (const consumerPath of starConsumers) {
             const consumerExports = getExportedIdentifiers(graph, consumerPath);

package/dist/graph-explorer/operations/has-strictly-ns-references.d.ts

@@ -1,2 +1,2 @@
 import type { ImportMaps, ModuleGraph } from '../../types/module-graph.js';
-export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportMaps | undefined, identifier: string) => [boolean, string?];
+export declare const hasStrictlyNsReferences: (graph: ModuleGraph, filePath: string, importsForExport: ImportMaps | undefined, identifier: string) => [boolean, string?];

package/dist/graph-explorer/operations/has-strictly-ns-references.js

@@ -1,98 +1,86 @@
-import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from '../visitors.js';
-export const hasStrictlyNsReferences = (graph, importsForExport, identifier) => {
-    if (!importsForExport)
-        return [false];
-    let foundNamespace;
-    const aliasByIdentifier = new Map();
-    const namespaceReExports = new Map();
-    const namespaceEdges = [];
-    const directById = new Map();
-    forEachPassThroughReExport(importsForExport, (id, sources) => {
-        directById.set(id, sources);
-    });
-    forEachAliasReExport(importsForExport, (id, alias, sources) => {
-        let arr = aliasByIdentifier.get(id);
-        if (!arr) {
-            arr = [];
-            aliasByIdentifier.set(id, arr);
-        }
-        arr.push({ alias, sources });
-    });
-    forEachNamespaceReExport(importsForExport, (namespace, sources) => {
-        namespaceEdges.push({ namespace, sources });
-        let arr = namespaceReExports.get(namespace);
-        if (!arr) {
-            arr = [];
-            namespaceReExports.set(namespace, arr);
+import { getAliasReExportMap, getPassThroughReExportSources, getStarReExportSources } from '../visitors.js';
+export const hasStrictlyNsReferences = (graph, filePath, importsForExport, identifier) => {
+    const seen = new Set();
+    const walkDown = (path, importMaps, id) => {
+        if (!importMaps)
+            return [false];
+        if (seen.has(path))
+            return [false];
+        seen.add(path);
+        let namespace;
+        const follow = (sources, nextId) => {
+            for (const filePath of sources) {
+                const file = graph.get(filePath);
+                if (!file?.importedBy)
+                    continue;
+                const result = walkDown(filePath, file.importedBy, nextId);
+                if (result[0] === false && result[1])
+                    return result;
+                if (result[1] && !namespace)
+                    namespace = result[1];
+            }
+            return undefined;
+        };
+        for (const ns of importMaps.importNs.keys()) {
+            if (!importMaps.refs.has(ns))
+                return [false, ns];
+            for (const ref of importMaps.refs) {
+                if (ref.startsWith(`${ns}.`))
+                    return [false, ns];
+            }
+            namespace = ns;
+            const nsAliases = getAliasReExportMap(importMaps, ns);
+            if (nsAliases) {
+                for (const [alias, sources] of nsAliases) {
+                    const result = follow(sources, alias);
+                    if (result)
+                        return result;
+                }
+            }
         }
-        arr.push(sources);
-    });
-    const starSources = getStarReExportSources(importsForExport);
-    const followReExports = (sources, nextId, propagateNamespace = true) => {
-        for (const filePath of sources) {
-            const file = graph.get(filePath);
-            if (!file?.imported)
-                continue;
-            const result = hasStrictlyNsReferences(graph, file.imported, nextId);
-            if (result[0] === false)
+        const directSources = getPassThroughReExportSources(importMaps, id);
+        if (directSources) {
+            const result = follow(directSources, id);
+            if (result)
                 return result;
-            if (propagateNamespace && result[1])
-                foundNamespace = result[1];
         }
-        return undefined;
-    };
-    for (const ns of importsForExport.importedNs.keys()) {
-        const hasNsRef = importsForExport.refs.has(ns);
-        if (!hasNsRef)
-            return [false, ns];
-        for (const ref of importsForExport.refs) {
-            if (ref.startsWith(`${ns}.`))
-                return [false, ns];
+        const starSources = getStarReExportSources(importMaps);
+        if (starSources) {
+            const result = follow(starSources, id);
+            if (result)
+                return result;
         }
-        const nsReExports = namespaceReExports.get(ns);
-        if (nsReExports) {
-            for (const sources of nsReExports) {
-                const result = followReExports(sources, identifier, false);
+        const [_id, ...rest] = id.split('.');
+        const aliasEntries = getAliasReExportMap(importMaps, _id);
+        if (aliasEntries) {
+            for (const [alias, sources] of aliasEntries) {
+                const result = follow(sources, [alias, ...rest].join('.'));
                 if (result)
                     return result;
             }
         }
-        const nsAliases = aliasByIdentifier.get(ns);
-        if (nsAliases) {
-            for (const { sources } of nsAliases) {
-                const result = followReExports(sources, identifier, false);
-                if (result)
-                    return result;
-            }
+        for (const [ns, sources] of importMaps.reExportNs) {
+            const result = follow(sources, `${ns}.${id}`);
+            if (result)
+                return result;
         }
-        foundNamespace = ns;
-    }
-    const directSources = directById.get(identifier);
-    if (directSources) {
-        const result = followReExports(directSources, identifier, true);
-        if (result)
-            return result;
-    }
-    if (starSources) {
-        const result = followReExports(starSources, identifier, true);
-        if (result)
-            return result;
-    }
-    const [id, ...rest] = identifier.split('.');
-    const aliasEntries = aliasByIdentifier.get(id);
-    if (aliasEntries) {
-        for (const { alias, sources } of aliasEntries) {
-            const result = followReExports(sources, [alias, ...rest].join('.'), true);
+        const importedSources = importMaps.import.get(id);
+        if (importedSources) {
+            const result = follow(importedSources, id);
             if (result)
                 return result;
         }
-    }
-    for (const { namespace: ns, sources } of namespaceEdges) {
-        const result = followReExports(sources, `${ns}.${identifier}`, true);
-        if (result)
-            return result;
-    }
-    if (foundNamespace)
-        return [true, foundNamespace];
-    return [false];
+        const importAsMap = importMaps.importAs.get(id);
+        if (importAsMap) {
+            for (const [alias, sources] of importAsMap) {
+                const result = follow(sources, alias);
+                if (result)
+                    return result;
+            }
+        }
+        if (namespace)
+            return [true, namespace];
+        return [false];
+    };
+    return walkDown(filePath, importsForExport, identifier);
 };