knip 2.41.6 → 2.43.0

package/dist/ProjectPrincipal.d.ts

@@ -4,6 +4,7 @@ import { SourceFileManager } from './typescript/SourceFileManager.js';
 import type { PrincipalOptions } from './PrincipalFactory.js';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
 import type { ExportItem, ExportItemMember } from './types/exports.js';
+import type { ProgramMaybe53 } from './typescript/SourceFile.js';
 import type { GlobbyFilterFunction } from 'globby';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
@@ -20,7 +21,7 @@ export declare class ProjectPrincipal {
         compilerHost: ts.CompilerHost;
         resolveModuleNames: ReturnType<typeof createCustomModuleResolver>;
         lsFindReferences: ts.LanguageService['findReferences'];
-        program?: ts.Program;
+        program?: ProgramMaybe53;
     };
     constructor({ compilerOptions, cwd, compilers, isGitIgnored }: PrincipalOptions);
     private createProgram;

package/dist/ProjectPrincipal.js

@@ -111,7 +111,13 @@ export class ProjectPrincipal {
         if (!sourceFile)
             throw new Error(`Unable to find ${filePath}`);
         const skipExports = this.skipExportsAnalysis.has(filePath);
-        const { imports, exports, scripts } = getImportsAndExports(sourceFile, { skipTypeOnly, skipExports });
+        const getResolvedModule = specifier => this.backend.program?.getResolvedModule
+            ? this.backend.program.getResolvedModule(sourceFile, specifier, undefined)
+            : sourceFile.resolvedModules?.get(specifier, undefined);
+        const { imports, exports, scripts } = getImportsAndExports(sourceFile, getResolvedModule, {
+            skipTypeOnly,
+            skipExports,
+        });
         const { internal, unresolved, external } = imports;
         const unresolvedImports = new Set();
         unresolved.forEach(specifier => {

package/dist/plugins/babel/helpers.d.ts

@@ -1,5 +1,4 @@
-export declare const resolvePluginName: (pluginName: string) => string;
-export declare const resolvePresetName: (pluginName: string) => string;
+export declare const resolveName: (identifier: string, namespace: 'preset' | 'plugin') => string;
 export declare const api: {
     assertVersion: () => boolean;
     cache: {

package/dist/plugins/babel/helpers.js

@@ -1,24 +1,32 @@
-export const resolvePluginName = (pluginName) => {
-    if (!/babel/.test(pluginName))
-        return `babel-plugin-${pluginName}`;
-    if (pluginName.startsWith('@babel/')) {
-        if (pluginName.startsWith('@babel/plugin'))
-            return pluginName;
-        const [, name] = pluginName.split('/');
-        return `@babel/plugin-${name}`;
+import { isAbsolute, isInternal } from '../../util/path.js';
+export const resolveName = (identifier, namespace) => {
+    if (isAbsolute(identifier) || isInternal(identifier))
+        return identifier;
+    if (identifier.startsWith('module:'))
+        return identifier.replace(/^module:/, '');
+    if (identifier.startsWith('@')) {
+        const [scope, name, ...rest] = identifier.split('/');
+        if (rest.length > 0)
+            return identifier;
+        if (scope) {
+            if (!name)
+                return [scope, `babel-${namespace}`].join('/');
+            if (scope === '@babel') {
+                if (name.startsWith(namespace))
+                    return identifier;
+                return `@babel/${namespace}-${name}`;
+            }
+            if (name.includes(`babel-${namespace}`))
+                return identifier;
+            return [scope, `babel-${namespace}-${name}`].join('/');
+        }
     }
-    return pluginName;
-};
-export const resolvePresetName = (pluginName) => {
-    if (!/babel/.test(pluginName))
-        return `babel-preset-${pluginName}`;
-    if (pluginName.startsWith('@babel/')) {
-        if (pluginName.startsWith('@babel/preset'))
-            return pluginName;
-        const [, name] = pluginName.split('/');
-        return `@babel/preset-${name}`;
-    }
-    return pluginName;
+    const [name, ...rest] = identifier.split('/');
+    if (rest.length > 0)
+        return identifier;
+    if (name.startsWith(`babel-${namespace}`))
+        return identifier;
+    return `babel-${namespace}-${name}`;
 };
 const cacheFn = () => void 0;
 cacheFn.forever = () => cacheFn;

package/dist/plugins/babel/index.js

@@ -1,22 +1,20 @@
 import { compact } from '../../util/array.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
-import { resolvePresetName, resolvePluginName, api } from './helpers.js';
+import { resolveName, api } from './helpers.js';
 export const NAME = 'Babel';
 export const ENABLERS = [/^@babel\//];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = [
-    'babel.config.json',
-    'babel.config.js',
-    '.babelrc.json',
-    '.babelrc.js',
+    'babel.config.{json,js,cjs,mjs,cts}',
+    '.babelrc.{json,js,cjs,mjs,cts}',
     '.babelrc',
     'package.json',
 ];
-const getItemName = (value) => typeof value === 'string' ? [value] : Array.isArray(value) ? [value[0]] : [];
+const getName = (value) => typeof value === 'string' ? [value] : Array.isArray(value) ? [value[0]] : [];
 export const getDependenciesFromConfig = (config) => {
-    const presets = config.presets?.flatMap(getItemName).map(resolvePresetName) ?? [];
-    const plugins = config.plugins?.flatMap(getItemName).map(resolvePluginName) ?? [];
+    const presets = config.presets?.flatMap(getName).map(name => resolveName(name, 'preset')) ?? [];
+    const plugins = config.plugins?.flatMap(getName).map(name => resolveName(name, 'plugin')) ?? [];
     const nested = config.env ? Object.values(config.env).flatMap(getDependenciesFromConfig) : [];
     return compact([...presets, ...plugins, ...nested]);
 };

package/dist/types/issues.js

@@ -7,4 +7,4 @@ export var SymbolType;
     SymbolType["CLASS"] = "class";
     SymbolType["MEMBER"] = "member";
     SymbolType["UNKNOWN"] = "unknown";
-})(SymbolType || (SymbolType = {}));
+})(SymbolType = SymbolType || (SymbolType = {}));

package/dist/typescript/SourceFile.d.ts

@@ -15,4 +15,8 @@ export interface BoundSourceFile extends ts.SourceFile {
     scriptKind?: ts.ScriptKind;
     pragmas?: Map<string, PragmaMap | PragmaMap[]>;
 }
+export interface ProgramMaybe53 extends ts.Program {
+    getResolvedModule?: (f: ts.SourceFile, moduleName: string, mode: ts.ResolutionMode) => ts.ResolvedModuleWithFailedLookupLocations | undefined;
+}
+export type GetResolvedModule = (name: string) => ts.ResolvedModuleWithFailedLookupLocations | undefined;
 export {};

package/dist/typescript/getImportsAndExports.d.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import type { BoundSourceFile } from './SourceFile.js';
+import type { BoundSourceFile, GetResolvedModule } from './SourceFile.js';
 import type { ExportItems as Exports, ExportItem } from '../types/exports.js';
 import type { Imports } from '../types/imports.js';
 export type GetImportsAndExportsOptions = {
@@ -15,7 +15,7 @@ export type AddImportOptions = {
 export type AddExportOptions = ExportItem & {
     identifier: string;
 };
-export declare const getImportsAndExports: (sourceFile: BoundSourceFile, options: GetImportsAndExportsOptions) => {
+export declare const getImportsAndExports: (sourceFile: BoundSourceFile, getResolvedModule: GetResolvedModule, options: GetImportsAndExportsOptions) => {
     imports: {
         internal: Imports;
         external: Set<string>;

package/dist/typescript/getImportsAndExports.js

@@ -13,7 +13,7 @@ const getVisitors = (sourceFile) => ({
     import: getImportVisitors(sourceFile),
     script: getScriptVisitors(sourceFile),
 });
-export const getImportsAndExports = (sourceFile, options) => {
+export const getImportsAndExports = (sourceFile, getResolvedModule, options) => {
     const internalImports = new Map();
     const externalImports = new Set();
     const unresolvedImports = new Set();
@@ -50,7 +50,7 @@ export const getImportsAndExports = (sourceFile, options) => {
         const { specifier, symbol, identifier = '__anonymous', isReExport = false } = options;
         if (isBuiltin(specifier))
             return;
-        const module = sourceFile.resolvedModules?.get(specifier, undefined);
+        const module = getResolvedModule(specifier);
         if (module?.resolvedModule) {
             const filePath = module.resolvedModule.resolvedFileName;
             if (filePath) {

package/dist/typescript/visitors/exports/exportDeclaration.js

@@ -6,7 +6,12 @@ export default visit(() => true, node => {
         if (node.exportClause && ts.isNamedExports(node.exportClause)) {
             const type = node.isTypeOnly ? SymbolType.TYPE : SymbolType.UNKNOWN;
             return node.exportClause.elements.map(element => {
-                return { node: element, identifier: element.name.getText(), type, pos: element.name.pos };
+                return {
+                    node: element,
+                    identifier: element.name.getText(),
+                    type,
+                    pos: element.name.flowNode?.node?.pos ?? element.name.pos,
+                };
             });
         }
     }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.41.6";
+export declare const version = "2.43.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.41.6';
+export const version = '2.43.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.41.6",
+  "version": "2.43.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",