knip 5.70.2 → 5.72.0

package/dist/plugins/vitest/index.js

@@ -13,7 +13,7 @@ const entry = ['**/*.{bench,test,test-d,spec}.?(c|m)[jt]s?(x)', ...mocks];
 const isVitestCoverageCommand = /vitest(.+)--coverage(?:\.enabled(?:=true)?)?/;
 const hasScriptWithCoverage = (scripts) => scripts ? Object.values(scripts).some(script => isVitestCoverageCommand.test(script)) : false;
 const findConfigDependencies = (localConfig, options) => {
-    const { manifest, cwd: dir } = options;
+    const { manifest, configFileDir: dir } = options;
     const testConfig = localConfig.test;
     if (!testConfig)
         return [];

package/dist/reporters/codeclimate.js

@@ -1,7 +1,6 @@
 import { createHash } from 'node:crypto';
-import { ISSUE_TYPE_TITLE } from '../constants.js';
 import { toRelative } from '../util/path.js';
-import { getIssueTypeTitle } from './util/util.js';
+import { getIssuePrefix, getIssueTypeTitle } from './util/util.js';
 export default async ({ report, issues, cwd }) => {
     const entries = [];
     for (const [type, isReportType] of Object.entries(report)) {
@@ -52,15 +51,12 @@ function convertSeverity(severity) {
             return 'info';
     }
 }
-function getPrefix(type) {
-    return ISSUE_TYPE_TITLE[type].replace(/ies$/, 'y').replace(/s$/, '');
-}
 function getIssueDescription({ type, symbol, symbols, parentSymbol }) {
     const symbolDescription = symbols ? `${symbols.map(s => s.symbol).join(', ')}` : symbol;
-    return `${getPrefix(type)}: ${symbolDescription}${parentSymbol ? ` (${parentSymbol})` : ''}`;
+    return `${getIssuePrefix(type)}: ${symbolDescription}${parentSymbol ? ` (${parentSymbol})` : ''}`;
 }
 function getSymbolDescription({ type, symbol, parentSymbol, }) {
-    return `${getPrefix(type)}: ${symbol.symbol}${parentSymbol ? ` (${parentSymbol})` : ''}`;
+    return `${getIssuePrefix(type)}: ${symbol.symbol}${parentSymbol ? ` (${parentSymbol})` : ''}`;
 }
 function createLocation(filePath, cwd, line, col) {
     if (col !== undefined) {

package/dist/reporters/util/util.d.ts

@@ -1,5 +1,5 @@
 import { ISSUE_TYPE_TITLE } from '../../constants.js';
-import type { Issue, IssueSeverity, IssueSymbol } from '../../types/issues.js';
+import type { Issue, IssueSeverity, IssueSymbol, IssueType } from '../../types/issues.js';
 import { Table } from '../../util/table.js';
 export declare const dim: import("picocolors/types.js").Formatter;
 export declare const bright: import("picocolors/types.js").Formatter;
@@ -23,4 +23,5 @@ export declare const convert: (issue: Issue | IssueSymbol) => {
 export declare const getTableForType: (issues: Issue[], cwd: string, options?: {
     isUseColors?: boolean;
 }) => Table;
+export declare const getIssuePrefix: (type: IssueType) => string;
 export {};

package/dist/reporters/util/util.js

@@ -54,3 +54,4 @@ export const getTableForType = (issues, cwd, options = { isUseColors: true }) =>
     }
     return table;
 };
+export const getIssuePrefix = (type) => ISSUE_TYPE_TITLE[type].replace(/ies$/, 'y').replace(/s$/, '');

package/dist/reporters/watch.js

@@ -23,7 +23,7 @@ export default (options, { issues, streamer, duration, size }) => {
     }
     const mem = perfObserver.getCurrentMemUsageInMb();
     const ms = duration ?? perfObserver.getCurrentDurationInMs();
-    const summary = `${size} files in ${prettyMilliseconds(ms)} (${mem}MB)`;
+    const summary = `${size} files (${prettyMilliseconds(ms)} • ${mem}MB)`;
     const messages = totalIssues === 0
         ? ['✂️  Excellent, Knip found no issues.', '', picocolors.gray(summary)]
         : [...lines, '', picocolors.gray(summary)];

package/dist/run.d.ts

@@ -0,0 +1,25 @@
+import { ConsoleStreamer } from './ConsoleStreamer.js';
+import type { MainOptions } from './util/create-options.js';
+export declare const run: (options: MainOptions) => Promise<{
+    results: {
+        issues: import("./types/issues.js").Issues;
+        counters: import("./types/issues.js").Counters;
+        tagHints: Set<import("./types/issues.js").TagHint>;
+        configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
+        includedWorkspaceDirs: string[];
+    };
+    watchHandler: {
+        listener: import("fs").WatchListener<string | Buffer<ArrayBufferLike>>;
+        handleFileChanges: (changes: {
+            type: "added" | "deleted" | "modified";
+            filePath: string;
+        }[]) => Promise<{
+            duration: number;
+            mem: number;
+        }>;
+        getEntryPaths: () => Set<string>;
+        getGraph: () => import("./types/module-graph.js").ModuleGraph;
+        getIssues: () => import("./types/issues.js").Issues;
+    } | undefined;
+    streamer: ConsoleStreamer;
+}>;

package/dist/run.js

@@ -0,0 +1,107 @@
+import { watch } from 'node:fs';
+import { formatly } from 'formatly';
+import { CatalogCounselor } from './CatalogCounselor.js';
+import { ConfigurationChief } from './ConfigurationChief.js';
+import { ConsoleStreamer } from './ConsoleStreamer.js';
+import { DependencyDeputy } from './DependencyDeputy.js';
+import { analyze } from './graph/analyze.js';
+import { build } from './graph/build.js';
+import { IssueCollector } from './IssueCollector.js';
+import { IssueFixer } from './IssueFixer.js';
+import { PrincipalFactory } from './PrincipalFactory.js';
+import watchReporter from './reporters/watch.js';
+import { debugLogArray, debugLogObject } from './util/debug.js';
+import { getGitIgnoredHandler } from './util/glob-core.js';
+import { getWatchHandler } from './util/watch.js';
+export const run = async (options) => {
+    debugLogObject('*', 'Unresolved configuration', options);
+    debugLogObject('*', 'Included issue types', options.includedIssueTypes);
+    const chief = new ConfigurationChief(options);
+    const deputy = new DependencyDeputy(options);
+    const factory = new PrincipalFactory();
+    const streamer = new ConsoleStreamer(options);
+    const fixer = new IssueFixer(options);
+    const collector = new IssueCollector(options);
+    const counselor = new CatalogCounselor(options);
+    streamer.cast('Reading workspace configuration');
+    const workspaces = await chief.getWorkspaces();
+    const isGitIgnored = await getGitIgnoredHandler(options);
+    collector.setIgnoreIssues(chief.config.ignoreIssues);
+    debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
+    debugLogObject('*', 'Included workspace configs', () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors })));
+    const { graph, entryPaths, analyzedFiles, unreferencedFiles, analyzeSourceFile } = await build({
+        chief,
+        collector,
+        counselor,
+        deputy,
+        factory,
+        isGitIgnored,
+        streamer,
+        workspaces,
+        options,
+    });
+    const reAnalyze = await analyze({
+        analyzedFiles,
+        counselor,
+        chief,
+        collector,
+        deputy,
+        entryPaths,
+        factory,
+        fixer,
+        graph,
+        streamer,
+        unreferencedFiles,
+        options,
+    });
+    let watchHandler;
+    if (options.isWatch) {
+        const isIgnored = (filePath) => (!!options.cacheLocation && filePath.startsWith(options.cacheLocation)) ||
+            filePath.includes('/.git/') ||
+            isGitIgnored(filePath);
+        const onFileChange = options.isWatch
+            ? ({ issues, duration }) => watchReporter(options, { issues, streamer, size: analyzedFiles.size, duration })
+            : undefined;
+        watchHandler = await getWatchHandler(options, {
+            analyzedFiles,
+            analyzeSourceFile,
+            chief,
+            collector,
+            analyze: reAnalyze,
+            factory,
+            graph,
+            isIgnored,
+            onFileChange,
+            unreferencedFiles,
+            entryPaths,
+        });
+        if (options.isWatch)
+            watch('.', { recursive: true }, watchHandler.listener);
+    }
+    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
+    if (options.isFix) {
+        const touchedFiles = await fixer.fixIssues(issues);
+        if (options.isFormat) {
+            const report = await formatly(Array.from(touchedFiles));
+            if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
+                debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
+            }
+            else {
+                debugLogObject('*', 'Formatting files failed', report);
+            }
+        }
+    }
+    if (!options.isWatch)
+        streamer.clear();
+    return {
+        results: {
+            issues,
+            counters,
+            tagHints,
+            configurationHints,
+            includedWorkspaceDirs: chief.includedWorkspaces.map(w => w.dir),
+        },
+        watchHandler,
+        streamer,
+    };
+};

package/dist/schema/configuration.d.ts

@@ -477,6 +477,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    svgr: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     syncpack: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -1073,6 +1078,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         }, z.core.$strip>]>>;
+        svgr: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+            config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        }, z.core.$strip>]>>;
         syncpack: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
             config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.d.ts

@@ -481,6 +481,11 @@ export declare const pluginsSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>;
+    svgr: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>;
     syncpack: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.js

@@ -105,6 +105,7 @@ export const pluginsSchema = z.object({
     stylelint: pluginSchema,
     svelte: pluginSchema,
     svgo: pluginSchema,
+    svgr: pluginSchema,
     syncpack: pluginSchema,
     tailwind: pluginSchema,
     taskfile: pluginSchema,

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'astro-db' | 'ava' | 'babel' | 'biome' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'mdx' | 'mdxlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'oxlint' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pnpm' | 'postcss' | 'preconstruct' | 'prettier' | 'prisma' | 'react-cosmos' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'svgo' | 'syncpack' | 'tailwind' | 'taskfile' | 'travis' | 'ts-node' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yarn' | 'yorkie';
-export declare const pluginNames: readonly ["angular", "astro", "astro-db", "ava", "babel", "biome", "bumpp", "bun", "c8", "capacitor", "changelogen", "changelogithub", "changesets", "commitizen", "commitlint", "convex", "create-typescript-app", "cspell", "cucumber", "cypress", "danger", "dependency-cruiser", "docusaurus", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-action", "github-actions", "glob", "graphql-codegen", "hardhat", "husky", "i18next-parser", "jest", "karma", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "mdx", "mdxlint", "metro", "mocha", "moonrepo", "msw", "nano-staged", "nest", "netlify", "next", "node", "node-modules-inspector", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "oxlint", "playwright", "playwright-ct", "playwright-test", "plop", "pnpm", "postcss", "preconstruct", "prettier", "prisma", "react-cosmos", "react-router", "relay", "release-it", "remark", "remix", "rollup", "rsbuild", "rslib", "rspack", "rstest", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "sst", "starlight", "storybook", "stryker", "stylelint", "svelte", "svgo", "syncpack", "tailwind", "taskfile", "travis", "ts-node", "tsdown", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yarn", "yorkie"];
+export type PluginName = 'angular' | 'astro' | 'astro-db' | 'ava' | 'babel' | 'biome' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'mdx' | 'mdxlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'oxlint' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pnpm' | 'postcss' | 'preconstruct' | 'prettier' | 'prisma' | 'react-cosmos' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'svgo' | 'svgr' | 'syncpack' | 'tailwind' | 'taskfile' | 'travis' | 'ts-node' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yarn' | 'yorkie';
+export declare const pluginNames: readonly ["angular", "astro", "astro-db", "ava", "babel", "biome", "bumpp", "bun", "c8", "capacitor", "changelogen", "changelogithub", "changesets", "commitizen", "commitlint", "convex", "create-typescript-app", "cspell", "cucumber", "cypress", "danger", "dependency-cruiser", "docusaurus", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-action", "github-actions", "glob", "graphql-codegen", "hardhat", "husky", "i18next-parser", "jest", "karma", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "mdx", "mdxlint", "metro", "mocha", "moonrepo", "msw", "nano-staged", "nest", "netlify", "next", "node", "node-modules-inspector", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "oxlint", "playwright", "playwright-ct", "playwright-test", "plop", "pnpm", "postcss", "preconstruct", "prettier", "prisma", "react-cosmos", "react-router", "relay", "release-it", "remark", "remix", "rollup", "rsbuild", "rslib", "rspack", "rstest", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "sst", "starlight", "storybook", "stryker", "stylelint", "svelte", "svgo", "svgr", "syncpack", "tailwind", "taskfile", "travis", "ts-node", "tsdown", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yarn", "yorkie"];

package/dist/types/PluginNames.js

@@ -94,6 +94,7 @@ export const pluginNames = [
     'stylelint',
     'svelte',
     'svgo',
+    'svgr',
     'syncpack',
     'tailwind',
     'taskfile',

package/dist/types/issues.d.ts

@@ -1,13 +1,13 @@
 import type { SYMBOL_TYPE } from '../constants.js';
 import type { Fixes } from './exports.js';
 export type SymbolType = (typeof SYMBOL_TYPE)[keyof typeof SYMBOL_TYPE];
-export type IssueSymbol = {
+export interface IssueSymbol {
     symbol: string;
     pos?: number;
     line?: number;
     col?: number;
-};
-export type Issue = {
+}
+export interface Issue {
     type: SymbolIssueType;
     filePath: string;
     workspace: string;
@@ -22,7 +22,7 @@ export type Issue = {
     col?: number;
     fixes: Fixes;
     isFixed?: boolean;
-};
+}
 export type IssueSet = Set<string>;
 export type IssueRecords = Record<string, Record<string, Issue>>;
 export type Issues = {

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

@@ -1,12 +1,17 @@
 import type ts from 'typescript';
 import type { Fix, Fixes } from './exports.js';
 import type { IssueSymbol, SymbolType } from './issues.js';
-type Identifier = string;
+export type Identifier = string;
 type FilePath = string;
 type NamespaceOrAlias = string;
 type Reference = string;
 type References = Set<Reference>;
 type Tags = Set<string>;
+interface SourceLocation {
+    pos: number;
+    line: number;
+    col: number;
+}
 export type IdToFileMap = Map<Identifier, Set<FilePath>>;
 export type IdToNsToFileMap = Map<Identifier, Map<NamespaceOrAlias, Set<FilePath>>>;
 export type ImportMaps = {
@@ -19,24 +24,18 @@ export type ImportMaps = {
     reExportedNs: IdToFileMap;
 };
 export type ImportMap = Map<FilePath, ImportMaps>;
-export type Import = {
+export interface Import extends SourceLocation {
     specifier: string;
     filePath: string | undefined;
     identifier: string | undefined;
-    pos?: number;
-    line?: number;
-    col?: number;
     isTypeOnly: boolean;
-};
-export interface Export {
+}
+export interface Export extends SourceLocation {
     identifier: Identifier;
-    pos: number;
-    line: number;
-    col: number;
     type: SymbolType;
     members: ExportMember[];
     jsDocTags: Tags;
-    refs: [number, boolean];
+    self: [number, boolean];
     fixes: Fixes;
     symbol?: ts.Symbol;
     isReExport?: boolean;
@@ -47,7 +46,7 @@ export type ExportMember = {
     line: number;
     col: number;
     type: SymbolType;
-    refs: [number, boolean];
+    self: [number, boolean];
     fix: Fix;
     symbol?: ts.Symbol;
     jsDocTags: Tags;
@@ -67,7 +66,6 @@ export type FileNode = {
     scripts: Set<string>;
     imported?: ImportMaps;
     internalImportCache?: ImportMap;
-    traceRefs: References;
 };
 export type ModuleGraph = Map<FilePath, FileNode>;
 export {};

package/dist/typescript/ast-helpers.d.ts

@@ -40,7 +40,7 @@ export declare const getLineAndCharacterOfPosition: (node: ts.Node, pos: number)
     col: number;
     pos: number;
 };
-export declare const getAccessMembers: (typeChecker: ts.TypeChecker, node: ts.Identifier) => string[];
+export declare const getAccessMembers: (typeChecker: ts.TypeChecker, node: ts.Node) => string[];
 export declare const isDestructuring: (node: ts.Node) => boolean;
 export declare const getDestructuredNames: (name: ts.ObjectBindingPattern) => [string[], boolean];
 export declare const isConsiderReferencedNS: (node: ts.Identifier) => boolean;
@@ -58,6 +58,10 @@ export declare const isModuleExportsAccess: (node: ts.PropertyAccessExpression)
 export declare const getImportMap: (sourceFile: ts.SourceFile) => Map<string, string>;
 export declare const getDefaultImportName: (importMap: ReturnType<typeof getImportMap>, specifier: string) => string | undefined;
 export declare const getPropertyValues: (node: ts.ObjectLiteralExpression, propertyName: string) => Set<string>;
+export declare function getThenBindings(callExpression: ts.CallExpression): {
+    identifier: string;
+    pos: number;
+}[] | undefined;
 export declare const getAccessedIdentifiers: (identifier: string, scope: ts.Node) => {
     identifier: string;
     pos: number;

package/dist/typescript/ast-helpers.js

@@ -198,12 +198,10 @@ export const getDestructuredNames = (name) => {
     return [members, hasSpread];
 };
 export const isConsiderReferencedNS = (node) => ts.isPropertyAssignment(node.parent) ||
-    ts.isShorthandPropertyAssignment(node.parent) ||
     (ts.isCallExpression(node.parent) && node.parent.arguments.includes(node)) ||
     ts.isSpreadAssignment(node.parent) ||
     ts.isArrayLiteralExpression(node.parent) ||
     ts.isExportAssignment(node.parent) ||
-    (ts.isVariableDeclaration(node.parent) && node.parent.initializer === node) ||
     ts.isTypeQueryNode(node.parent.parent);
 export const isInOpaqueExpression = (node) => ts.isAwaitExpression(node.parent)
     ? isInOpaqueExpression(node.parent)
@@ -263,6 +261,18 @@ export const getImportMap = (sourceFile) => {
                     importMap.set(element.name.text, importPath);
             }
         }
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (declaration.initializer &&
+                    isRequireCall(declaration.initializer) &&
+                    ts.isIdentifier(declaration.name) &&
+                    ts.isStringLiteral(declaration.initializer.arguments[0])) {
+                    const importName = declaration.name.text;
+                    const importPath = stripQuotes(declaration.initializer.arguments[0].text);
+                    importMap.set(importName, importPath);
+                }
+            }
+        }
     }
     return importMap;
 };
@@ -304,6 +314,32 @@ const isMatchAlias = (expression, identifier) => {
         expression = expression.expression;
     return expression && ts.isIdentifier(expression) && expression.escapedText === identifier;
 };
+export function getThenBindings(callExpression) {
+    if (!ts.isFunctionLike(callExpression.arguments[0]))
+        return;
+    const fn = callExpression.arguments[0];
+    const param = fn.parameters[0];
+    if (!param)
+        return;
+    if (ts.isIdentifier(param.name)) {
+        const paramName = param.name.escapedText;
+        const identifiers = [];
+        for (const node of findDescendants(fn.body, ts.isPropertyAccessExpression)) {
+            if (ts.isIdentifier(node.expression) && node.expression.escapedText === paramName) {
+                identifiers.push({ identifier: String(node.name.escapedText), pos: node.name.pos });
+            }
+        }
+        if (identifiers.length > 0)
+            return identifiers;
+    }
+    else if (ts.isObjectBindingPattern(param.name)) {
+        return param.name.elements.map(element => {
+            const identifier = (element.propertyName ?? element.name).getText();
+            const alias = element.propertyName ? element.name.getText() : undefined;
+            return { identifier, alias, pos: element.pos };
+        });
+    }
+}
 export const getAccessedIdentifiers = (identifier, scope) => {
     const identifiers = [];
     function visit(node) {
@@ -328,6 +364,15 @@ export const getAccessedIdentifiers = (identifier, scope) => {
                 }
             }
         }
+        else if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            isMatchAlias(node.expression.expression, identifier) &&
+            node.expression.name.escapedText === 'then') {
+            const accessed = getThenBindings(node);
+            if (accessed)
+                for (const acc of accessed)
+                    identifiers.push(acc);
+        }
         ts.forEachChild(node, visit);
     }
     visit(scope);