knip 6.44.0 → 6.44.1

package/README.md

@@ -50,8 +50,7 @@ following projects:
 [2]: https://img.shields.io/npm/v/knip?color=f56e0f
 [3]: https://img.shields.io/badge/dynamic/json?url=https://npm-gapless.webpro.nl/downloads/range/last-month/knip&query=$.totalCompact&label=downloads&suffix=/month&color=f56e0f
 [4]: https://github.com/webpro-nl/knip
-[5]:
-  https://img.shields.io/github/stars/webpro-nl/knip?style=flat&color=f56e0f
+[5]: https://img.shields.io/github/stars/webpro-nl/knip?style=flat&color=f56e0f
 [6]: https://knip.dev
 [7]: https://www.npmx.dev/package/@knip/create-config
 [8]: https://www.npmx.dev/package/@knip/language-server
@@ -69,7 +68,6 @@ following projects:
 [20]: https://github.com/pnpm/pnpm/tree/main/deps/graph-sequencer
 [21]: https://github.com/pnpm/pnpm/blob/main/LICENSE
 [22]: https://github.com/jaredwray/cacheable/tree/main/packages/file-entry-cache
-[23]:
-  https://github.com/jaredwray/cacheable/blob/main/packages/file-entry-cache/LICENSE
+[23]: https://github.com/jaredwray/cacheable/blob/main/packages/file-entry-cache/LICENSE
 [24]: https://github.com/npm/json-parse-even-better-errors
 [25]: https://github.com/npm/json-parse-even-better-errors/blob/main/LICENSE.md

package/dist/DependencyDeputy.js

@@ -1,5 +1,5 @@
 import { isBuiltin } from 'node:module';
-import { DT_SCOPE, IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_RUNTIME_DEPENDENCIES, ROOT_WORKSPACE_NAME, } from './constants.js';
+import { DT_SCOPE, IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_RUNTIME_DEPENDENCIES, PROTOCOL_CLOUDFLARE, ROOT_WORKSPACE_NAME, } from './constants.js';
 import { getDependencyMetaData } from './manifest/index.js';
 import { PackagePeeker } from './PackagePeeker.js';
 import { getDefinitelyTypedFor, getPackageFromDefinitelyTyped, getPackageNameFromModuleSpecifier, isDefinitelyTyped, } from './util/modules.js';
@@ -127,7 +127,7 @@ export class DependencyDeputy {
     maybeAddReferencedExternalDependency(workspace, packageName, { specifier, isDevOnly, isTypeOnly, isResolved, isPublishedType, isCaught }) {
         if (!this.isReportDependencies)
             return true;
-        if (specifier.startsWith('node:') || isBuiltin(specifier))
+        if (specifier.startsWith('node:') || specifier.startsWith(PROTOCOL_CLOUDFLARE) || isBuiltin(specifier))
             return true;
         if (IGNORED_RUNTIME_DEPENDENCIES.has(packageName))
             return true;

package/dist/ProjectPrincipal.d.ts

@@ -2,6 +2,7 @@ import type { ParseResult } from 'oxc-parser';
 import { CacheConsultant } from './CacheConsultant.ts';
 import type { Compilers } from './compilers/types.ts';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, PluginVisitorContext, PluginVisitorObject } from './types/config.ts';
+import type { ConfigurationFiles } from './session/configuration.ts';
 import type { FileNode } from './types/module-graph.ts';
 import type { Paths } from './types/project.ts';
 import type { ResolveGlobPattern } from './typescript/resolve-module-names.ts';
@@ -39,7 +40,7 @@ export declare class ProjectPrincipal {
     addCompilers(workspaceName: string, compilers: Compilers): void;
     addPaths(paths: Paths, basePath: string, scope: string): void;
     addRootDirs(rootDirs: string[] | undefined, scope: string): void;
-    collectConfigurationImports(paths: Set<string>): void;
+    collectConfigurationImports(configurationFiles: ConfigurationFiles): void;
     init(): void;
     private hasAcceptedExtension;
     addEntryPath(filePath: string, options?: {

package/dist/ProjectPrincipal.js

@@ -100,8 +100,8 @@ export class ProjectPrincipal {
         const scoped = this.rootDirs.get(scope) ?? [];
         this.rootDirs.set(scope, compact([...scoped, ...rootDirs]));
     }
-    collectConfigurationImports(paths) {
-        for (const filePath of paths) {
+    collectConfigurationImports(configurationFiles) {
+        for (const filePath of configurationFiles.paths) {
             if (!DEFAULT_EXTENSIONS.has(extname(filePath)))
                 continue;
             const source = this.fileManager.readRawFile(filePath);
@@ -111,7 +111,7 @@ export class ProjectPrincipal {
                 for (const specifier of extractSpecifiers(_parseFile(filePath, source), source, filePath)) {
                     const resolved = this.resolveSpecifier(specifier, filePath);
                     if (resolved && !isInNodeModules(resolved))
-                        paths.add(resolved);
+                        configurationFiles.addImport(filePath, resolved);
                 }
             }
             catch { }

package/dist/binaries/resolvers/bun.js

@@ -56,7 +56,12 @@ const commands = new Set([
 ]);
 export const resolve = (_binary, words, options) => {
     const binary = toCommandBinary(_binary, options);
-    const parsed = parseArgs(words, { string: ['cwd'] });
+    const parsed = parseArgs(words, {
+        string: ['cwd'],
+        boolean: ['bun', 'hot', 'if-present', 'silent', 'smol', 'watch'],
+        alias: { bun: 'b' },
+        isStorePositions: true,
+    });
     const [command, script] = parsed._;
     if (command === 'x') {
         const wordsForX = words.filter(word => word.value !== 'x');
@@ -81,7 +86,7 @@ export const resolve = (_binary, words, options) => {
     const dir = parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const opts = dir ? { cwd: dir } : {};
     if (command !== 'run')
-        return [binary, ...fromArgs(words, opts)];
+        return [binary, ...fromArgs(dir ? words : words.slice(parsed.positionalIndices[0]), opts)];
     const input = toBinary(filePath, { optional: true });
     if (dir)
         input.dir = dir;

package/dist/constants.d.ts

@@ -11,6 +11,7 @@ export declare const BETA_TAG = "@beta";
 export declare const ALIAS_TAG = "@alias";
 export declare const DT_SCOPE = "@types";
 export declare const PROTOCOL_VIRTUAL = "virtual:";
+export declare const PROTOCOL_CLOUDFLARE = "cloudflare:";
 export declare const IGNORED_GLOBAL_BINARIES: Set<string>;
 export declare const IGNORED_DEPENDENCIES: Set<string>;
 export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;

package/dist/constants.js

@@ -20,6 +20,7 @@ export const BETA_TAG = '@beta';
 export const ALIAS_TAG = '@alias';
 export const DT_SCOPE = '@types';
 export const PROTOCOL_VIRTUAL = 'virtual:';
+export const PROTOCOL_CLOUDFLARE = 'cloudflare:';
 export const IGNORED_GLOBAL_BINARIES = new Set([
     'amplify',
     'aws',

package/dist/plugins/babel/index.js

@@ -5,7 +5,12 @@ import { api, resolveName } from './helpers.js';
 const title = 'Babel';
 const enablers = [/^@babel\//];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['babel.config.{json,js,cjs,mjs,cts,ts}', '.babelrc.{json,js,cjs,mjs,cts}', '.babelrc', 'package.json'];
+const config = [
+    'babel.config.{json,js,cjs,mjs,cts,ts,mts}',
+    '.babelrc.{json,js,cjs,mjs,cts}',
+    '.babelrc',
+    'package.json',
+];
 const getName = (value) => [Array.isArray(value) ? value[0] : value].filter(name => typeof name === 'string');
 export const getDependenciesFromConfig = (config) => {
     const presets = config.presets?.flatMap(getName).map(name => resolveName(name, 'preset')) ?? [];

package/dist/plugins/cspell/index.js

@@ -5,10 +5,17 @@ const enablers = ['cspell'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = [
     'package.json',
-    'cspell.config.{js,cjs,mjs,ts,mts,json,yaml,yml}',
-    'cspell.{json,yaml,yml}',
+    '{.,}cspell.config.{js,cjs,mjs,ts,cts,mts,json,jsonc,yaml,yml,toml}',
+    '{.,}cspell.{jsonc,yaml,yml}',
     '.c{s,S}pell.json',
     'c{s,S}pell.json',
+    '.vscode/c{s,S}pell.json',
+    '.vscode/.cspell.json',
+    '.config/{.,}cspell.config.{js,cjs,mjs,ts,cts,mts,json,jsonc,yaml,yml,toml}',
+    '.config/.c{s,S}pell.json',
+    '.config/c{s,S}pell.json',
+    '.config/{.,}cspell.jsonc',
+    '.config/cspell.{yaml,yml}',
 ];
 const resolveConfig = config => {
     return [config?.import ?? []].flat().map(id => toDeferResolve(id));

package/dist/plugins/eleventy/index.js

@@ -8,7 +8,7 @@ const title = 'Eleventy';
 const enablers = ['@11ty/eleventy'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['.eleventy.js', 'eleventy.config.{js,cjs,mjs}'];
-const production = ['posts/**/*.11tydata.js', '_data/**/*.{js,cjs,mjs}'];
+const production = ['posts/**/*.11tydata.{js,cjs,mjs}', '_data/**/*.{js,cjs,mjs}'];
 const resolveConfig = async (localConfig, options) => {
     const { configFileDir } = options;
     const dummyUserConfig = new DummyEleventyConfig();
@@ -38,7 +38,7 @@ const resolveConfig = async (localConfig, options) => {
         .concat([
         join(inputDir, dataDir, '**/*.{js,cjs,mjs}'),
         join(inputDir, `**/*.{${typeof templateFormats === 'string' ? templateFormats : templateFormats.join(',')}}`),
-        join(inputDir, '**/*.11tydata.js'),
+        join(inputDir, '**/*.11tydata.{js,cjs,mjs}'),
         ...copiedEntries,
     ].map(id => toProductionEntry(id)));
 };

package/dist/plugins/mocha/index.js

@@ -4,7 +4,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Mocha';
 const enablers = ['mocha'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.mocharc.{js,cjs,json,jsonc,yml,yaml}', 'package.json'];
+const config = ['.mocharc.{js,cjs,mjs,json,jsonc,yml,yaml}', 'package.json'];
 const entry = ['**/test/*.{js,cjs,mjs}'];
 const defaultExtensions = ['js', 'cjs', 'mjs'];
 const builtInReporters = new Set([

package/dist/plugins/npm-package-json-lint/index.js

@@ -7,7 +7,7 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const packageJsonPath = 'npmpackagejsonlint';
 const config = ['package.json', ...toCosmiconfig('npmpackagejsonlint')];
 const resolveConfig = localConfig => {
-    return localConfig?.extends ? [localConfig.extends].map(id => toDependency(id)) : [];
+    return localConfig?.extends ? [localConfig.extends].flat().map(id => toDependency(id)) : [];
 };
 const plugin = {
     title,

package/dist/plugins/npm-package-json-lint/types.d.ts

@@ -1,3 +1,3 @@
 export type NpmPkgJsonLintConfig = {
-    extends?: string;
+    extends?: string | string[];
 };

package/dist/plugins/relay/index.js

@@ -5,7 +5,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Relay';
 const enablers = ['vite-plugin-relay', '@swc/plugin-relay', 'babel-plugin-relay'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['relay.config.json', 'relay.config.js'];
+const config = ['package.json', 'relay.config.json', 'relay.config.js'];
 const resolveConfig = async (config) => {
     const projects = 'projects' in config ? Object.values(config.projects) : [config];
     return projects.map(project => {

package/dist/plugins/release-it/index.js

@@ -3,7 +3,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Release It!';
 const enablers = ['release-it'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.release-it.{json,js,cjs,ts,yml,yaml,toml}', 'package.json'];
+const config = ['.release-it.{json,jsonc,json5,js,mjs,cjs,ts,mts,cts,yml,yaml,toml}', 'package.json'];
 const resolveConfig = (config, options) => {
     const plugins = config.plugins ? Object.keys(config.plugins) : [];
     const scripts = config.hooks ? Object.values(config.hooks).flat() : [];

package/dist/plugins/rsbuild/index.js

@@ -1,6 +1,7 @@
-import { toProductionEntry } from '../../util/input.js';
+import { toDeferResolve, toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 import { resolveConfig as resolveRspackConfig } from '../rspack/index.js';
+import { getSwcPluginSpecifiers } from '../webpack/index.js';
 const title = 'Rsbuild';
 const enablers = ['@rsbuild/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -17,6 +18,22 @@ const getConfigs = async (configOrFn) => {
         configs.push(await configOrFn(params));
     return configs;
 };
+const getAliases = (chain) => {
+    const aliases = {};
+    for (const item of [chain].flat()) {
+        if (typeof item === 'function')
+            continue;
+        for (const key in item) {
+            const targets = [];
+            for (const target of [item[key]].flat())
+                if (typeof target === 'string')
+                    targets.push(target);
+            if (targets.length > 0)
+                aliases[key] = targets;
+        }
+    }
+    return aliases;
+};
 const resolveConfig = async (configOrFn, options) => {
     const entries = new Set();
     const inputs = [];
@@ -48,6 +65,17 @@ const resolveConfig = async (configOrFn, options) => {
     };
     const checkConfig = async (localConfig, config) => {
         checkSource(localConfig.source);
+        const alias = localConfig.resolve?.alias;
+        if (alias) {
+            for (const input of await resolveRspackConfig({ resolve: { alias: getAliases(alias) } }, options)) {
+                inputs.push(input);
+            }
+        }
+        const swc = localConfig.tools?.swc;
+        if (swc && typeof swc === 'object') {
+            for (const specifier of getSwcPluginSpecifiers(swc))
+                inputs.push(toDeferResolve(specifier));
+        }
         if (!localConfig.tools?.rspack)
             return;
         const target = localConfig.output?.target ?? config.output?.target ?? 'web';

package/dist/plugins/rsbuild/types.d.ts

@@ -1,4 +1,5 @@
 import type { Configuration } from 'webpack';
+import type { SWCConfig } from '../swc/types.ts';
 type EntryDescription = Record<string, unknown>;
 type Entry = Record<string, string | string[] | (EntryDescription & {
     html?: boolean;
@@ -12,18 +13,25 @@ type RspackConfigUtils = {
     isWebWorker: boolean;
 };
 type RspackConfig = Configuration | ((config: Configuration, utils: RspackConfigUtils) => Configuration | void | Promise<Configuration | void>);
+type AliasObject = Record<string, string | false | (string | false)[]>;
+type Alias = AliasObject | ((aliases: AliasObject) => AliasObject | void);
+export type AliasChain = Alias | Alias[];
 export type RsbuildConfig = {
     plugins?: unknown[];
     mode?: 'development' | 'production' | 'none';
     output?: {
         target?: RspackConfigUtils['target'];
     };
+    resolve?: {
+        alias?: AliasChain;
+    };
     source?: {
         entry?: Entry;
         preEntry?: string | string[];
     };
     tools?: {
         rspack?: RspackConfig | RspackConfig[];
+        swc?: SWCConfig | ((config: SWCConfig) => SWCConfig | void);
     };
     environments?: {
         [k: string]: Omit<RsbuildConfig, 'environments'>;

package/dist/plugins/svgr/index.js

@@ -1,9 +1,10 @@
 import { toDependency } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { toCosmiconfig } from '../../util/plugin-config.js';
 const title = 'SVGR';
 const enablers = ['@svgr/cli', '@svgr/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.svgrrc', '.svgrrc.{yaml,yml,json,js}', 'svgr.config.{js,cjs}', 'package.json'];
+const config = ['package.json', ...toCosmiconfig('svgr')];
 const resolveConfig = async (config) => {
     const inputs = [];
     if (config.plugins) {

package/dist/plugins/swc/index.js

@@ -6,9 +6,14 @@ const enablers = ['@swc/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['.swcrc'];
 const resolveConfig = async (config) => {
-    const inputs = config?.jsc?.experimental?.plugins ?? [];
-    const externalHelpers = config.jsc?.externalHelpers ? ['@swc/helpers'] : [];
-    return compact([...inputs.map(([id]) => id), ...externalHelpers]).map(id => toDependency(id));
+    const dependencies = [];
+    for (const item of [config].flat()) {
+        for (const [id] of item?.jsc?.experimental?.plugins ?? [])
+            dependencies.push(id);
+        if (item?.jsc?.externalHelpers)
+            dependencies.push('@swc/helpers');
+    }
+    return compact(dependencies).map(id => toDependency(id));
 };
 const plugin = {
     title,

package/dist/plugins/webpack/index.d.ts

@@ -1,5 +1,7 @@
 import type { Plugin, ResolveConfig } from '../../types/config.ts';
+import type { SWCConfig } from '../swc/types.ts';
 import type { WebpackConfig } from './types.ts';
+export declare const getSwcPluginSpecifiers: (options: SWCConfig) => string[];
 export declare const findWebpackDependenciesFromConfig: ResolveConfig<WebpackConfig>;
 declare const plugin: Plugin;
 export default plugin;

package/dist/plugins/webpack/index.js

@@ -59,10 +59,8 @@ const resolveRuleSetDependencies = (rule) => {
     });
 };
 const isSwcLoader = (loader) => loader === 'builtin:swc-loader' || loader.endsWith('/swc-loader') || loader === 'swc-loader';
-const resolveSwcPluginDependencies = (use) => {
-    if (!hasLoaderOptions(use) || !isSwcLoader(use.loader))
-        return [];
-    const plugins = use.options.jsc?.experimental?.plugins;
+export const getSwcPluginSpecifiers = (options) => {
+    const plugins = options.jsc?.experimental?.plugins;
     if (!Array.isArray(plugins))
         return [];
     return plugins.flatMap(plugin => {
@@ -73,6 +71,11 @@ const resolveSwcPluginDependencies = (use) => {
         return [];
     });
 };
+const resolveSwcPluginDependencies = (use) => {
+    if (!hasLoaderOptions(use) || !isSwcLoader(use.loader))
+        return [];
+    return getSwcPluginSpecifiers(use.options);
+};
 const resolveUseItem = (use) => {
     if (!use)
         return [];

package/dist/session/configuration.d.ts

@@ -5,8 +5,11 @@ export declare class SessionConfigurationChangedError extends Error {
 }
 export declare class ConfigurationFiles {
     paths: Set<string>;
+    private importers;
     private matchers;
     constructor(options: MainOptions);
     addPatterns(dir: string, patterns: string[]): void;
+    addImport(importer: string, imported: string): void;
+    getAffected(changes: WatchChange[], cwd: string): Set<string>;
     getChange(changes: WatchChange[], cwd: string): SessionConfigurationChangedError | undefined;
 }

package/dist/session/configuration.js

@@ -8,6 +8,7 @@ export class SessionConfigurationChangedError extends Error {
 }
 export class ConfigurationFiles {
     paths = new Set();
+    importers = new Map();
     matchers = [];
     constructor(options) {
         const manifests = [];
@@ -32,6 +33,24 @@ export class ConfigurationFiles {
         if (included.length > 0)
             this.matchers.push({ dir, isMatch: picomatch(included, { dot: true, ignore: excluded }) });
     }
+    addImport(importer, imported) {
+        this.paths.add(imported);
+        const importers = this.importers.get(imported);
+        if (importers)
+            importers.add(importer);
+        else
+            this.importers.set(imported, new Set([importer]));
+    }
+    getAffected(changes, cwd) {
+        const affected = new Set();
+        for (const change of changes)
+            affected.add(toAbsolute(toPosix(change.filePath), cwd));
+        for (const filePath of affected) {
+            for (const importer of this.importers.get(filePath) ?? [])
+                affected.add(importer);
+        }
+        return affected;
+    }
     getChange(changes, cwd) {
         for (const change of changes) {
             const filePath = toAbsolute(toPosix(change.filePath), cwd);

package/dist/session/session.js

@@ -49,9 +49,10 @@ export const createSession = async (options) => {
             clearModuleResolutionCaches();
             clearGlobCache();
             clearGitignoreCache();
-            if (current.session.configurationFiles)
-                unload(current.session.configurationFiles.paths);
-            const nextOptions = await createOptions(current.options.createdFrom);
+            const { configurationFiles } = current.session;
+            if (configurationFiles)
+                unload(configurationFiles.getAffected(changes, current.options.cwd));
+            const nextOptions = await createOptions(current.options.createdFrom, true);
             current = await initialize({ ...nextOptions, isCache: false });
             Object.assign(results, current.results);
             return { duration: performance.now() - startTime, mem: process.memoryUsage().heapUsed };

package/dist/typescript/visitors/imports.d.ts

@@ -1,5 +1,6 @@
-import type { ArrayExpression, Expression, ImportExpression, VariableDeclarator } from 'oxc-parser';
+import type { ArrayExpression, CallExpression, Expression, ImportExpression, VariableDeclarator } from 'oxc-parser';
 import type { WalkState } from './walk.ts';
 export declare function getPromiseAllElements(expression: Expression): ArrayExpression['elements'] | undefined;
 export declare function handleVariableDeclarator(node: VariableDeclarator, s: WalkState): void;
+export declare function handleImportThen(node: CallExpression, s: WalkState): void;
 export declare function handleImportExpression(node: ImportExpression, s: WalkState): void;

package/dist/typescript/visitors/imports.js

@@ -25,46 +25,8 @@ export function handleVariableDeclarator(node, s) {
         importExpr = init;
     }
     if (importExpr && isStringLiteral(importExpr.source)) {
-        s.handledImportExpressions.add(importExpr.start);
-        const specifier = getStringValue(importExpr.source);
         const caughtFlag = init.type === 'AwaitExpression' && s.caughtTryBlockEnds.length > 0 ? IMPORT_FLAGS.CAUGHT : IMPORT_FLAGS.NONE;
-        if (node.id.type === 'ObjectPattern') {
-            for (const prop of node.id.properties) {
-                if (prop.type === 'Property') {
-                    const importedName = prop.key?.type === 'Identifier'
-                        ? prop.key.name
-                        : prop.key?.type === 'Literal' && typeof prop.key.value === 'string'
-                            ? prop.key.value
-                            : undefined;
-                    const localName = prop.value?.type === 'Identifier' ? prop.value.name : importedName;
-                    const alias = localName !== importedName ? localName : undefined;
-                    s.addImport(specifier, importedName, alias, undefined, prop.key?.start ?? prop.start, IMPORT_FLAGS.DYNAMIC | caughtFlag);
-                }
-                else if (prop.type === 'RestElement' && prop.argument?.type === 'Identifier') {
-                    s.addImport(specifier, IMPORT_STAR, prop.argument.name, undefined, prop.start, IMPORT_FLAGS.DYNAMIC | caughtFlag);
-                }
-            }
-        }
-        else if (node.id.type === 'Identifier') {
-            if (init.type === 'AwaitExpression') {
-                s.addImport(specifier, 'default', node.id.name, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | caughtFlag);
-                const resolved = s.resolveModule(specifier, s.filePath);
-                if (resolved && !resolved.isExternalLibraryImport && !isInNodeModules(resolved.resolvedFileName)) {
-                    s.localImportMap.set(node.id.name, {
-                        importedName: IMPORT_STAR,
-                        filePath: resolved.resolvedFileName,
-                        isNamespace: true,
-                        isDynamicImport: true,
-                    });
-                }
-            }
-            else {
-                s.addImport(specifier, undefined, undefined, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.OPAQUE | caughtFlag);
-            }
-        }
-        else {
-            s.addImport(specifier, undefined, undefined, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.OPAQUE | caughtFlag);
-        }
+        handleDynamicImportBinding(node.id, importExpr, init.type === 'AwaitExpression', caughtFlag, s);
         return;
     }
     if (init.type === 'CallExpression' &&
@@ -268,6 +230,62 @@ export function handleVariableDeclarator(node, s) {
         }
     }
 }
+function handleDynamicImportBinding(id, importExpr, isAwaited, caughtFlag, s) {
+    s.handledImportExpressions.add(importExpr.start);
+    const specifier = getStringValue(importExpr.source);
+    if (id.type === 'ObjectPattern') {
+        for (const prop of id.properties) {
+            if (prop.type === 'Property') {
+                const importedName = prop.key?.type === 'Identifier'
+                    ? prop.key.name
+                    : prop.key?.type === 'Literal' && typeof prop.key.value === 'string'
+                        ? prop.key.value
+                        : undefined;
+                const localName = prop.value?.type === 'Identifier' ? prop.value.name : importedName;
+                const alias = localName !== importedName ? localName : undefined;
+                s.addImport(specifier, importedName, alias, undefined, prop.key?.start ?? prop.start, IMPORT_FLAGS.DYNAMIC | caughtFlag);
+            }
+            else if (prop.type === 'RestElement' && prop.argument?.type === 'Identifier') {
+                s.addImport(specifier, IMPORT_STAR, prop.argument.name, undefined, prop.start, IMPORT_FLAGS.DYNAMIC | caughtFlag);
+            }
+        }
+    }
+    else if (id.type === 'Identifier') {
+        if (isAwaited) {
+            s.addImport(specifier, 'default', id.name, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | caughtFlag);
+            const resolved = s.resolveModule(specifier, s.filePath);
+            if (resolved && !resolved.isExternalLibraryImport && !isInNodeModules(resolved.resolvedFileName)) {
+                s.localImportMap.set(id.name, {
+                    importedName: IMPORT_STAR,
+                    filePath: resolved.resolvedFileName,
+                    isNamespace: true,
+                    isDynamicImport: true,
+                });
+            }
+        }
+        else {
+            s.addImport(specifier, undefined, undefined, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.OPAQUE | caughtFlag);
+        }
+    }
+    else {
+        s.addImport(specifier, undefined, undefined, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.OPAQUE | caughtFlag);
+    }
+}
+export function handleImportThen(node, s) {
+    const callee = node.callee;
+    if (callee.type !== 'MemberExpression' || callee.computed || callee.property.name !== 'then')
+        return;
+    if (callee.object.type !== 'ImportExpression' || !isStringLiteral(callee.object.source))
+        return;
+    const fn = node.arguments[0];
+    if (fn?.type !== 'ArrowFunctionExpression' && fn?.type !== 'FunctionExpression')
+        return;
+    const param = fn.params[0];
+    if (param?.type !== 'Identifier' && param?.type !== 'ObjectPattern')
+        return;
+    const caughtFlag = s.caughtImportExpressions.has(callee.object.start) ? IMPORT_FLAGS.CAUGHT : IMPORT_FLAGS.NONE;
+    handleDynamicImportBinding(param, callee.object, true, caughtFlag, s);
+}
 export function handleImportExpression(node, s) {
     if (s.handledImportExpressions.has(node.start))
         return;

package/dist/typescript/visitors/walk.js

@@ -7,7 +7,7 @@ import { collectAugmentationRefs, getLineAndCol, getStringValue, isStringLiteral
 import { EMPTY_TAGS } from './jsdoc.js';
 import { handleCallExpression, handleNewExpression, trackCustomElementRegistry } from './calls.js';
 import { handleExportAssignment, handleExportDefault, handleExportNamed, handleExpressionStatement, } from './exports.js';
-import { getPromiseAllElements, handleImportExpression, handleVariableDeclarator } from './imports.js';
+import { getPromiseAllElements, handleImportExpression, handleImportThen, handleVariableDeclarator, } from './imports.js';
 import { handleJSXMemberExpression, handleMemberExpression } from './members.js';
 let state;
 const _getFix = (start, end, flags) => state.options.isFixExports ? [start, end, flags ?? FIX_FLAGS.NONE] : undefined;
@@ -419,6 +419,7 @@ const coreVisitorObject = {
         }
     },
     CallExpression(node) {
+        handleImportThen(node, state);
         handleCallExpression(node, state);
     },
     NewExpression(node) {

package/dist/util/create-options.d.ts

@@ -3,7 +3,7 @@ import { type ParsedCLIArgs } from './cli-arguments.ts';
 interface CreateOptions extends Partial<Options> {
     args?: ParsedCLIArgs;
 }
-export declare const createOptions: (options: CreateOptions) => Promise<{
+export declare const createOptions: (options: CreateOptions, isReload?: boolean) => Promise<{
     createdFrom: CreateOptions;
     cacheLocation: string;
     catalog: import("../CatalogCounselor.ts").CatalogContainer[];

package/dist/util/create-options.js

@@ -8,12 +8,12 @@ import { findFile, loadJSON } from './fs.js';
 import { getIncludedIssueTypes, shorthandCycles, shorthandDeps, shorthandExports, shorthandFiles, } from './get-included-issue-types.js';
 import { defaultRules } from './issue-initializers.js';
 import { loadResolvedConfigFile } from './load-config.js';
-import { _load } from './loader.js';
+import { _load, unload } from './loader.js';
 import { logWarning } from './log.js';
 import { getKeysByValue } from './object.js';
 import { isAbsolute, isInternal, join, resolveCwd, toAbsolute } from './path.js';
 import { splitTags } from './tag.js';
-export const createOptions = async (options) => {
+export const createOptions = async (options, isReload = false) => {
     const { args = {} } = options;
     const cwd = resolveCwd(options.cwd ?? args.directory ?? '.');
     const manifestPath = findFile(cwd, 'package.json');
@@ -32,6 +32,8 @@ export const createOptions = async (options) => {
     if (args.config && !configFilePath && !manifest.knip) {
         throw new ConfigurationError(`Unable to find ${args.config} or package.json#knip`);
     }
+    if (options.isSession && !isReload && configFilePath)
+        unload([configFilePath]);
     const loadedConfig = Object.assign({}, manifest.knip, configFilePath ? await loadResolvedConfigFile(configFilePath, args) : {});
     const validIssueTypes = new Set(ISSUE_TYPES);
     for (const key of ['rules', 'include', 'exclude']) {

package/dist/util/loader.js

@@ -6,26 +6,15 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { LoaderError } from './errors.js';
-import { findFile, loadFile, loadJSON, loadJSONC, loadTOML, loadYAML, parseJSONC, parseYAML } from './fs.js';
+import { loadFile, loadJSON, loadJSONC, loadTOML, loadYAML, parseJSONC, parseYAML } from './fs.js';
 import { jiti } from './jiti.js';
 import { timerify } from './Performance.js';
-import { dirname, extname, isInternal, toNative } from './path.js';
-const unloaded = new Map();
-const isNativeModule = (filePath) => {
-    const ext = extname(filePath);
-    if (ext !== '.js')
-        return ext === '.mjs';
-    for (let dir = dirname(filePath); dir !== dirname(dir); dir = dirname(dir)) {
-        const manifestPath = findFile(dir, 'package.json');
-        if (manifestPath)
-            return JSON.parse(readFileSync(manifestPath, 'utf8')).type === 'module';
-    }
-    return false;
-};
+import { extname, isInternal, toNative } from './path.js';
+const versions = new Map();
+const isReloadable = (ext) => ext === '.js' || ext === '.mjs' || ext === '.cjs';
 const reload = async (filePath, version) => {
     let imported;
     try {
@@ -67,8 +56,9 @@ const load = async (filePath) => {
         if (ext === '.toml') {
             return await loadTOML(filePath);
         }
-        const version = unloaded.get(filePath);
-        if (version && isNativeModule(filePath))
+        const version = versions.get(filePath) ?? 0;
+        versions.set(filePath, version);
+        if (version && isReloadable(ext))
             return await reload(filePath, version);
         return await jiti.import(filePath, { default: true });
     }
@@ -82,6 +72,8 @@ export const unload = (filePaths) => {
     for (const filePath of filePaths) {
         delete cache[filePath];
         delete cache[toNative(filePath)];
-        unloaded.set(filePath, (unloaded.get(filePath) ?? 0) + 1);
+        const version = versions.get(filePath);
+        if (version !== undefined)
+            versions.set(filePath, version + 1);
     }
 };

package/dist/util/modules.js

@@ -1,5 +1,5 @@
 import { readFileSync } from 'node:fs';
-import { DT_SCOPE, PROTOCOL_VIRTUAL } from '../constants.js';
+import { DT_SCOPE, PROTOCOL_CLOUDFLARE, PROTOCOL_VIRTUAL } from '../constants.js';
 import { isAbsolute, isInNodeModules, join, toPosix } from './path.js';
 export const getPackageNameFromModuleSpecifier = (specifier) => {
     if (!isStartsLikePackageName(specifier) && !isTildePackageName(specifier))
@@ -89,6 +89,7 @@ const CHAR_HASH = 35;
 const CHAR_QUESTION = 63;
 export const sanitizeSpecifier = (specifier) => {
     if (specifier.startsWith('node:') ||
+        specifier.startsWith(PROTOCOL_CLOUDFLARE) ||
         isAbsolute(specifier) ||
         specifier.charCodeAt(0) === CHAR_COLON ||
         specifier.startsWith(PROTOCOL_VIRTUAL)) {

package/dist/util/watch.js

@@ -16,7 +16,7 @@ export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceF
     const deleted = new Set();
     const modified = new Set();
     if (configurationFiles)
-        principal.collectConfigurationImports(configurationFiles.paths);
+        principal.collectConfigurationImports(configurationFiles);
     const processFileChanges = async (changes) => {
         const startTime = performance.now();
         let hasRelevantChanges = false;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.44.0";
+export declare const version = "6.44.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.44.0';
+export const version = '6.44.1';

package/package.json

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