knip 6.0.4 → 6.0.6

package/dist/graph/analyze.js

@@ -60,7 +60,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             if (isIgnored &&
                                 (isReferenced || isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports))) {
                                 for (const tagName of exportedItem.jsDocTags) {
-                                    if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
+                                    if (options.tags[1].includes(tagName)) {
                                         collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
                                     }
                                 }
@@ -114,7 +114,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             }
                                             else if (isIgnored) {
                                                 for (const tagName of exportedItem.jsDocTags) {
-                                                    if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
+                                                    if (options.tags[1].includes(tagName)) {
                                                         collector.addTagHint({ type: 'tag', filePath, identifier: id, tagName });
                                                     }
                                                 }

package/dist/graph/build.js

@@ -310,14 +310,18 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 if (!isIgnored)
                     pp.addEntryPath(filePath, { skipExportsAnalysis: true });
             }
+            const wsDependencies = deputy.getDependencies(workspace.name);
             for (const _import of file.imports.imports) {
-                if (_import.filePath) {
-                    const packageName = getPackageNameFromModuleSpecifier(_import.specifier);
-                    if (packageName && isInternalWorkspace(packageName)) {
-                        file.imports.external.add({ ..._import, specifier: packageName });
-                        if (!isGitIgnored(_import.filePath)) {
-                            pp.addProgramPath(_import.filePath);
-                        }
+                if (!_import.filePath)
+                    continue;
+                const packageName = getPackageNameFromModuleSpecifier(_import.specifier);
+                if (!packageName)
+                    continue;
+                const isWorkspace = isInternalWorkspace(packageName);
+                if (isWorkspace || wsDependencies.has(packageName)) {
+                    file.imports.external.add({ ..._import, specifier: packageName });
+                    if (isWorkspace && !isGitIgnored(_import.filePath)) {
+                        pp.addProgramPath(_import.filePath);
                     }
                 }
             }

package/dist/plugins/nx/index.js

@@ -45,7 +45,7 @@ const resolveConfig = async (localConfig, options) => {
             commands = [target.options.command];
         else if (target.options?.commands)
             commands = target.options.commands.map(commandConfig => typeof commandConfig === 'string' ? commandConfig : commandConfig.command);
-        const cwd = target.options?.cwd ? join(options.cwd, target.options.cwd) : undefined;
+        const cwd = target.options?.cwd ? join(options.cwd, target.options.cwd) : options.cwd;
         return options.getInputsFromScripts(commands, { cwd });
     });
     const configInputs = targets.flatMap(target => {

package/dist/types/module-graph.d.ts

@@ -47,7 +47,7 @@ export interface ExportMember extends Position {
     readonly identifier: Identifier;
     readonly type: SymbolType;
     readonly fix: Fix;
-    readonly jsDocTags: Tags;
+    jsDocTags: Tags;
     readonly flags: number;
     hasRefsInFile: boolean;
 }

package/dist/typescript/get-imports-and-exports.js

@@ -11,7 +11,7 @@ import { walkAST } from "./visitors/walk.js";
 const jsDocImportRe = /import\(\s*['"]([^'"]+)['"]\s*\)(?:\.(\w+))?/g;
 const jsDocImportTagRe = /@import\s+(?:\{[^}]*\}|\*\s+as\s+\w+)\s+from\s+['"]([^'"]+)['"]/g;
 const jsxImportSourceRe = /@jsxImportSource\s+(\S+)/;
-const referenceTypesRe = /\/\s*<reference\s+types\s*=\s*"([^"]+)"\s*\/>/;
+const referenceTypesRe = /\s*<reference\s+types\s*=\s*"([^"]+)"\s*\/>/;
 const envRe = /@(?:vitest|jest)-environment\s+(\S+)/g;
 const getImportsAndExports = (filePath, sourceText, resolveModule, options, ignoreExportsUsedInFile, skipExportsForFile, visitor, pluginCtx, cachedParseResult) => {
     const skipExports = skipExportsForFile || !options.isReportExports;
@@ -303,7 +303,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
             addImport(id, undefined, undefined, undefined, comment.start + results.index, modifiers);
         }
         if (comment.type === 'Line') {
-            const refMatch = ('/' + comment.value).match(referenceTypesRe);
+            const refMatch = comment.value.match(referenceTypesRe);
             if (refMatch) {
                 addImport(refMatch[1], undefined, undefined, undefined, comment.start, IMPORT_FLAGS.TYPE_ONLY);
             }

package/dist/typescript/resolve-module-names.js

@@ -4,14 +4,28 @@ import { DEFAULT_EXTENSIONS, DTS_EXTENSIONS } from "../constants.js";
 import { sanitizeSpecifier } from "../util/modules.js";
 import { timerify } from "../util/Performance.js";
 import { dirname, extname, isAbsolute, isInNodeModules, join } from "../util/path.js";
-import { _createSyncModuleResolver, _resolveModuleSync, convertPathsToAlias } from "../util/resolve.js";
+import { _createSyncModuleResolver, _resolveModuleSync } from "../util/resolve.js";
+function compilePathMappings(paths) {
+    if (!paths)
+        return undefined;
+    const mappings = [];
+    for (const key in paths) {
+        const starIdx = key.indexOf('*');
+        if (starIdx >= 0) {
+            mappings.push({ prefix: key.slice(0, starIdx), wildcard: true, values: paths[key] });
+        }
+        else {
+            mappings.push({ prefix: key, wildcard: false, values: paths[key] });
+        }
+    }
+    return mappings.length > 0 ? mappings : undefined;
+}
 export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath) {
     const customCompilerExtensionsSet = new Set(customCompilerExtensions);
     const hasCustomExts = customCompilerExtensionsSet.size > 0;
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions, ...DTS_EXTENSIONS];
-    const alias = convertPathsToAlias(compilerOptions.paths);
     const resolveSync = hasCustomExts ? _createSyncModuleResolver(extensions) : _resolveModuleSync;
-    const resolveWithAlias = alias ? _createSyncModuleResolver(extensions, alias) : undefined;
+    const pathMappings = compilePathMappings(compilerOptions.paths);
     const rootDirs = compilerOptions.rootDirs;
     function toSourcePath(resolvedFileName) {
         if (!hasCustomExts || !customCompilerExtensionsSet.has(extname(resolvedFileName))) {
@@ -27,24 +41,27 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
         };
     }
     function resolveModuleName(name, containingFile) {
-        const sanitizedSpecifier = sanitizeSpecifier(name);
-        if (isBuiltin(sanitizedSpecifier))
+        const specifier = sanitizeSpecifier(name);
+        if (isBuiltin(specifier))
             return undefined;
-        const resolvedFileName = resolveSync(sanitizedSpecifier, containingFile);
+        const resolvedFileName = resolveSync(specifier, containingFile);
         if (resolvedFileName)
             return toResult(resolvedFileName);
-        if (resolveWithAlias) {
-            const aliasResolved = resolveWithAlias(sanitizedSpecifier, containingFile);
-            if (aliasResolved)
-                return toResult(aliasResolved);
-        }
-        const candidate = isAbsolute(sanitizedSpecifier)
-            ? sanitizedSpecifier
-            : join(dirname(containingFile), sanitizedSpecifier);
-        if (existsSync(candidate)) {
-            return { resolvedFileName: candidate, isExternalLibraryImport: false };
+        if (pathMappings) {
+            for (const { prefix, wildcard, values } of pathMappings) {
+                if (wildcard ? specifier.startsWith(prefix) : specifier === prefix) {
+                    const captured = wildcard ? specifier.slice(prefix.length) : '';
+                    for (const value of values) {
+                        const starIdx = value.indexOf('*');
+                        const mapped = starIdx >= 0 ? value.slice(0, starIdx) + captured + value.slice(starIdx + 1) : value;
+                        const resolved = resolveSync(mapped, containingFile);
+                        if (resolved)
+                            return toResult(resolved);
+                    }
+                }
+            }
         }
-        if (rootDirs && !isAbsolute(sanitizedSpecifier)) {
+        if (rootDirs && !isAbsolute(specifier)) {
             const containingDir = dirname(containingFile);
             for (const srcRoot of rootDirs) {
                 if (!containingDir.startsWith(srcRoot))
@@ -53,13 +70,17 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                 for (const targetRoot of rootDirs) {
                     if (targetRoot === srcRoot)
                         continue;
-                    const mapped = join(targetRoot, relPath, sanitizedSpecifier);
+                    const mapped = join(targetRoot, relPath, specifier);
                     const resolved = resolveSync(mapped, containingFile);
                     if (resolved)
                         return toResult(resolved);
                 }
             }
         }
+        const candidate = isAbsolute(specifier) ? specifier : join(dirname(containingFile), specifier);
+        if (existsSync(candidate)) {
+            return { resolvedFileName: candidate, isExternalLibraryImport: false };
+        }
     }
     return timerify(resolveModuleName);
 }

package/dist/typescript/visitors/helpers.js

@@ -1,6 +1,7 @@
 import { parseSync, rawTransferSupported, } from 'oxc-parser';
 import { DEFAULT_EXTENSIONS, FIX_FLAGS, SYMBOL_TYPE } from "../../constants.js";
 import { extname } from "../../util/path.js";
+import { EMPTY_TAGS } from "./jsdoc.js";
 const defaultParseOptions = {
     sourceType: 'unambiguous',
     experimentalRawTransfer: rawTransferSupported(),
@@ -57,6 +58,18 @@ export function extractNamespaceMembers(decl, options, lineStarts, getJSDocTags,
     const members = [];
     const addMember = (name, pos, stmtStart, stmtEnd) => {
         const fullName = prefix ? `${prefix}.${name}` : name;
+        const tags = getJSDocTags(stmtStart);
+        const existing = members.find(m => m.identifier === fullName);
+        if (existing) {
+            if (tags.size) {
+                if (existing.jsDocTags === EMPTY_TAGS)
+                    existing.jsDocTags = new Set(tags);
+                else
+                    for (const t of tags)
+                        existing.jsDocTags.add(t);
+            }
+            return;
+        }
         const { line, col } = getLineAndCol(lineStarts, pos);
         const fix = options.isFixExports
             ? [stmtStart, stmtEnd, FIX_FLAGS.OBJECT_BINDING | FIX_FLAGS.WITH_NEWLINE]
@@ -69,7 +82,7 @@ export function extractNamespaceMembers(decl, options, lineStarts, getJSDocTags,
             col,
             fix,
             hasRefsInFile: false,
-            jsDocTags: getJSDocTags(stmtStart),
+            jsDocTags: tags,
             flags: 0,
         });
     };

package/dist/typescript/visitors/walk.js

@@ -150,7 +150,7 @@ const _addParamShadows = (params, body) => {
     if (!body || !params)
         return;
     const range = [body.start, body.end];
-    const items = Array.isArray(params) ? params : params.items ?? params;
+    const items = Array.isArray(params) ? params : (params.items ?? params);
     for (const param of items)
         _collectBindingNames(param, range);
 };

package/dist/util/resolve.d.ts

@@ -1,5 +1,4 @@
 export declare const _resolveModuleSync: (specifier: string, basePath: string) => string | undefined;
-export declare const _createSyncModuleResolver: (extensions: string[], alias?: Record<string, string[]>) => (specifier: string, basePath: string) => string | undefined;
-export declare function convertPathsToAlias(paths: Record<string, string[]> | undefined): Record<string, string[]> | undefined;
+export declare const _createSyncModuleResolver: (extensions: string[]) => (specifier: string, basePath: string) => string | undefined;
 export declare function clearResolverCache(): void;
 export declare const _resolveSync: (specifier: string, baseDir: string) => string | undefined;

package/dist/util/resolve.js

@@ -34,18 +34,7 @@ const createSyncModuleResolver = (extensions, alias) => {
 };
 const resolveModuleSync = createSyncModuleResolver([...DEFAULT_EXTENSIONS, ...DTS_EXTENSIONS, '.json', '.jsonc']);
 export const _resolveModuleSync = timerify(resolveModuleSync, 'resolveModuleSync');
-export const _createSyncModuleResolver = (extensions, alias) => timerify(createSyncModuleResolver(extensions, alias), 'resolveModuleSync');
-export function convertPathsToAlias(paths) {
-    if (!paths)
-        return undefined;
-    const alias = {};
-    for (const key in paths) {
-        const stripWildcard = key.endsWith('/*');
-        const aliasKey = stripWildcard ? key.slice(0, -2) : key;
-        alias[aliasKey] = stripWildcard ? paths[key].map(v => (v.endsWith('/*') ? v.slice(0, -2) : v)) : paths[key];
-    }
-    return alias;
-}
+export const _createSyncModuleResolver = (extensions) => timerify(createSyncModuleResolver(extensions), 'resolveModuleSync');
 const createSyncResolver = (extensions) => {
     const resolver = new ResolverFactory({
         extensions,

package/dist/util/tag.js

@@ -4,11 +4,11 @@ export const splitTags = (rawTags) => {
     return tags.reduce(([incl, excl], tag) => {
         const match = tag.match(/[a-zA-Z]+/);
         if (match)
-            (tag.startsWith('-') ? excl : incl).push(match[0]);
+            (tag.startsWith('-') ? excl : incl).push(`@${match[0]}`);
         return [incl, excl];
     }, [[], []]);
 };
-const hasTag = (tags, jsDocTags) => tags.some(tag => jsDocTags.has(`@${tag}`));
+const hasTag = (tags, jsDocTags) => tags.some(tag => jsDocTags.has(tag));
 export const shouldIgnore = (jsDocTags, tags) => {
     const [includeJSDocTags, excludeJSDocTags] = tags;
     if (includeJSDocTags.length > 0 && !hasTag(includeJSDocTags, jsDocTags))

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.0.4";
+export declare const version = "6.0.6";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.0.4';
+export const version = '6.0.6';

package/package.json

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