knip 6.13.1 → 6.14.0

package/dist/CacheConsultant.d.ts

@@ -1,9 +1,9 @@
 import type { MainOptions } from './util/create-options.ts';
 import { type FileDescriptor } from './util/file-entry-cache.ts';
 export declare class CacheConsultant<T> {
-    private isEnabled;
     private cache;
+    getFileDescriptor: (filePath: string) => FileDescriptor<T>;
+    reconcile: () => void;
     constructor(name: string, options: MainOptions);
-    getFileDescriptor(filePath: string): FileDescriptor<T>;
-    reconcile(): void;
+    getCachedFile(filePath: string): T | undefined;
 }

package/dist/CacheConsultant.js

@@ -3,24 +3,21 @@ import { timerify } from './util/Performance.js';
 import { version } from './version.js';
 const dummyFileDescriptor = { key: '', changed: true, notFound: true };
 export class CacheConsultant {
-    isEnabled;
     cache;
+    getFileDescriptor = () => dummyFileDescriptor;
+    reconcile = () => { };
     constructor(name, options) {
-        this.isEnabled = options.isCache;
-        if (this.isEnabled) {
-            const cacheName = `${name.replace(/[^a-z0-9]/g, '-').replace(/-*$/, '')}-${options.isProduction ? '-prod' : ''}-${version}`;
-            this.cache = new FileEntryCache(cacheName, options.cacheLocation);
-            this.reconcile = timerify(this.cache.reconcile).bind(this.cache);
-            this.getFileDescriptor = timerify(this.cache.getFileDescriptor).bind(this.cache);
-        }
+        if (!options.isCache)
+            return;
+        const cacheName = `${name.replace(/[^a-z0-9]/g, '-').replace(/-*$/, '')}-${options.isProduction ? '-prod' : ''}-${version}`;
+        this.cache = new FileEntryCache(cacheName, options.cacheLocation);
+        this.getFileDescriptor = timerify(this.cache.getFileDescriptor.bind(this.cache));
+        this.reconcile = timerify(this.cache.reconcile.bind(this.cache));
     }
-    getFileDescriptor(filePath) {
-        if (this.isEnabled && this.cache)
-            return this.cache.getFileDescriptor(filePath);
-        return dummyFileDescriptor;
-    }
-    reconcile() {
-        if (this.isEnabled && this.cache)
-            this.cache.reconcile();
+    getCachedFile(filePath) {
+        if (!this.cache)
+            return undefined;
+        const fd = this.cache.getFileDescriptor(filePath);
+        return !fd.changed ? fd.meta?.data : undefined;
     }
 }

package/dist/ConfigurationChief.d.ts

@@ -35,6 +35,7 @@ export declare class ConfigurationChief {
     availableWorkspaceNames: string[];
     availableWorkspacePkgNames: Set<string>;
     availableWorkspaceDirs: string[];
+    private availableWorkspaceDirsWithSlash;
     workspaceGraph: WorkspaceGraph;
     private workspaceByFileCache;
     constructor(options: MainOptions);

package/dist/ConfigurationChief.js

@@ -8,6 +8,7 @@ import { _dirGlob, removeProductionSuffix } from './util/glob.js';
 import { graphSequencer } from './util/graph-sequencer.js';
 import mapWorkspaces from './util/map-workspaces.js';
 import { join, relative } from './util/path.js';
+import { timerify } from './util/Performance.js';
 import { normalizePluginConfig } from './util/plugin.js';
 import { toRegexOrString } from './util/regex.js';
 import { ELLIPSIS } from './util/string.js';
@@ -63,6 +64,7 @@ export class ConfigurationChief {
     availableWorkspaceNames = [];
     availableWorkspacePkgNames = new Set();
     availableWorkspaceDirs = [];
+    availableWorkspaceDirsWithSlash = [];
     workspaceGraph = new Map();
     workspaceByFileCache = new Map();
     constructor(options) {
@@ -74,6 +76,7 @@ export class ConfigurationChief {
         this.workspaces = options.workspaces;
         this.rawConfig = options.parsedConfig;
         this.config = this.normalize(options.parsedConfig ?? {});
+        this.findWorkspaceByFilePath = timerify(this.findWorkspaceByFilePath.bind(this), 'findWorkspaceByFilePath');
     }
     getConfigurationHints() {
         const hints = [];
@@ -139,6 +142,7 @@ export class ConfigurationChief {
             .sort(byPathDepth)
             .reverse()
             .map(dir => join(this.cwd, dir));
+        this.availableWorkspaceDirsWithSlash = this.availableWorkspaceDirs.map(dir => `${dir}/`);
         this.workspaceGraph = createWorkspaceGraph(this.cwd, this.availableWorkspaceNames, wsPkgNames, packages);
         this.selectedWorkspaces = this.getSelectedWorkspaces();
         this.workspaceFilePathFilter = createWorkspaceFilePathFilter(this.cwd, this.selectedWorkspaces, this.availableWorkspaceNames);
@@ -347,8 +351,13 @@ export class ConfigurationChief {
     findWorkspaceByFilePath(filePath) {
         if (this.workspaceByFileCache.has(filePath))
             return this.workspaceByFileCache.get(filePath);
-        const workspaceDir = this.availableWorkspaceDirs.find(workspaceDir => filePath.startsWith(`${workspaceDir}/`));
-        const workspace = workspaceDir ? this.workspacesByDir.get(workspaceDir) : undefined;
+        let workspace;
+        for (let i = 0; i < this.availableWorkspaceDirsWithSlash.length; i++) {
+            if (filePath.startsWith(this.availableWorkspaceDirsWithSlash[i])) {
+                workspace = this.workspacesByDir.get(this.availableWorkspaceDirs[i]);
+                break;
+            }
+        }
         this.workspaceByFileCache.set(filePath, workspace);
         return workspace;
     }

package/dist/DependencyDeputy.d.ts

@@ -8,6 +8,7 @@ export declare class DependencyDeputy {
     isStrict: boolean;
     isReportDependencies: boolean;
     _manifests: WorkspaceManifests;
+    workspacePkgNames: Set<string>;
     referencedDependencies: Map<string, Set<string>>;
     referencedBinaries: Map<string, Set<string>>;
     hostDependencies: Map<string, HostDependencies>;
@@ -43,8 +44,10 @@ export declare class DependencyDeputy {
         unusedIgnoreBinaries: Set<string | RegExp>;
         unusedIgnoreUnresolved: Set<string | RegExp>;
     } | undefined;
+    setWorkspacePkgNames(pkgNames: Iterable<string>): void;
     getProductionDependencies(workspaceName: string): DependencyArray;
     getDevDependencies(workspaceName: string): DependencyArray;
+    private dependencyCache;
     getDependencies(workspaceName: string): DependencySet;
     setInstalledBinaries(workspaceName: string, installedBinaries: Map<string, Set<string>>): void;
     getInstalledBinaries(workspaceName: string): InstalledBinaries | undefined;

package/dist/DependencyDeputy.js

@@ -10,6 +10,7 @@ export class DependencyDeputy {
     isStrict;
     isReportDependencies;
     _manifests = new Map();
+    workspacePkgNames = new Set();
     referencedDependencies;
     referencedBinaries;
     hostDependencies;
@@ -39,11 +40,7 @@ export class DependencyDeputy {
         const requiredPeerDependencies = peerDependencies.filter(dep => !optionalPeerDependencies.has(dep));
         const devDependencies = Object.keys(manifest.devDependencies ?? {});
         const allDependencies = [...dependencies, ...devDependencies, ...peerDependencies, ...optionalDependencies];
-        const packageNames = [
-            ...dependencies,
-            ...(this.isStrict ? peerDependencies : []),
-            ...(this.isProduction ? [] : devDependencies),
-        ];
+        const packageNames = [...dependencies, ...peerDependencies, ...(this.isProduction ? [] : devDependencies)];
         if (this.isReportDependencies) {
             const { hostDependencies, installedBinaries, hasTypesIncluded } = getDependencyMetaData({
                 packageNames,
@@ -79,6 +76,9 @@ export class DependencyDeputy {
     getWorkspaceManifest(workspaceName) {
         return this._manifests.get(workspaceName);
     }
+    setWorkspacePkgNames(pkgNames) {
+        this.workspacePkgNames = new Set(pkgNames);
+    }
     getProductionDependencies(workspaceName) {
         const manifest = this._manifests.get(workspaceName);
         if (!manifest)
@@ -90,11 +90,15 @@ export class DependencyDeputy {
     getDevDependencies(workspaceName) {
         return this._manifests.get(workspaceName)?.devDependencies ?? [];
     }
+    dependencyCache = new Map();
     getDependencies(workspaceName) {
+        let deps = this.dependencyCache.get(workspaceName);
+        if (deps)
+            return deps;
         const manifest = this._manifests.get(workspaceName);
-        if (!manifest)
-            return new Set();
-        return new Set([...manifest.dependencies, ...manifest.devDependencies]);
+        deps = manifest ? new Set([...manifest.dependencies, ...manifest.devDependencies]) : new Set();
+        this.dependencyCache.set(workspaceName, deps);
+        return deps;
     }
     setInstalledBinaries(workspaceName, installedBinaries) {
         this.installedBinaries.set(workspaceName, installedBinaries);
@@ -153,6 +157,22 @@ export class DependencyDeputy {
             return true;
         if (this._manifests.get(workspace.name)?.engines[packageName])
             return true;
+        if (!this.isStrict && this.workspacePkgNames.has(packageName)) {
+            this.addReferencedDependency(workspace.name, packageName);
+            return true;
+        }
+        if (!this.isStrict) {
+            for (const name of workspaceNames) {
+                const hosts = this.getHostDependenciesFor(name, packageName);
+                if (hosts.length === 0)
+                    continue;
+                const m = this._manifests.get(name);
+                if (m && hosts.some(h => m.allDependencies.has(h.name))) {
+                    this.addReferencedDependency(name, packageName);
+                    return true;
+                }
+            }
+        }
         this.addReferencedDependency(workspace.name, packageName);
         return false;
     }

package/dist/ProjectPrincipal.d.ts

@@ -27,6 +27,7 @@ export declare class ProjectPrincipal {
     private resolveModule;
     resolvedFiles: Set<string>;
     deletedFiles: Set<string>;
+    private onPathAdded;
     constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler);
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
     addPaths(paths: Paths, basePath: string): void;

package/dist/ProjectPrincipal.js

@@ -1,5 +1,5 @@
 import { extractSpecifiers } from './typescript/follow-imports.js';
-import { parseFile } from './typescript/ast-nodes.js';
+import { _parseFile } from './typescript/ast-nodes.js';
 import { CacheConsultant } from './CacheConsultant.js';
 import { getCompilerExtensions } from './compilers/index.js';
 import { DEFAULT_EXTENSIONS } from './constants.js';
@@ -36,6 +36,7 @@ export class ProjectPrincipal {
     resolveModule = () => undefined;
     resolvedFiles = new Set();
     deletedFiles = new Set();
+    onPathAdded;
     constructor(options, toSourceFilePath, findWorkspaceManifestImports) {
         this.cache = new CacheConsultant('root', options);
         this.toSourceFilePath = toSourceFilePath;
@@ -44,6 +45,7 @@ export class ProjectPrincipal {
         this.fileManager = new SourceFileManager({
             compilers: [this.syncCompilers, this.asyncCompilers],
         });
+        this.walkAndAnalyze = timerify(this.walkAndAnalyze.bind(this), 'walkAndAnalyze');
     }
     addCompilers(compilers) {
         for (const [ext, compiler] of compilers[0]) {
@@ -100,6 +102,7 @@ export class ProjectPrincipal {
             this.projectPaths.add(filePath);
             if (options?.skipExportsAnalysis)
                 this.skipExportsAnalysis.add(filePath);
+            this.onPathAdded?.(filePath);
         }
     }
     addEntryPaths(filePaths, options) {
@@ -109,6 +112,7 @@ export class ProjectPrincipal {
     addProgramPath(filePath) {
         if (!isInNodeModules(filePath) && this.hasAcceptedExtension(filePath)) {
             this.programPaths.add(filePath);
+            this.onPathAdded?.(filePath);
         }
     }
     addProjectPath(filePath) {
@@ -134,61 +138,48 @@ export class ProjectPrincipal {
     walkAndAnalyze(analyzeFile) {
         this.resolvedFiles.clear();
         const visited = new Set([...this.entryPaths, ...this.programPaths]);
-        let lastEntrySize = this.entryPaths.size;
-        let lastProgramSize = this.programPaths.size;
-        const rescanFrontier = () => {
-            if (this.entryPaths.size > lastEntrySize || this.programPaths.size > lastProgramSize) {
-                for (const p of this.entryPaths)
-                    visited.add(p);
-                for (const p of this.programPaths)
-                    visited.add(p);
-                lastEntrySize = this.entryPaths.size;
-                lastProgramSize = this.programPaths.size;
-            }
-        };
-        for (const filePath of visited) {
-            const isProjectPath = this.projectPaths.has(filePath);
-            let cachedFile;
-            if (isProjectPath) {
-                const fd = this.cache.getFileDescriptor(filePath);
-                if (!fd.changed && fd.meta?.data)
-                    cachedFile = fd.meta.data;
-            }
-            if (cachedFile) {
-                const internalPaths = analyzeFile(filePath, undefined, '', cachedFile);
-                if (internalPaths)
-                    for (const p of internalPaths)
-                        visited.add(p);
-                rescanFrontier();
-                continue;
-            }
-            const sourceText = this.fileManager.readFile(filePath);
-            if (!sourceText) {
-                if (isProjectPath)
-                    analyzeFile(filePath, undefined, '');
-                continue;
-            }
-            try {
-                const result = parseFile(filePath, sourceText);
-                this.fileManager.sourceTextCache.delete(filePath);
-                if (isProjectPath) {
-                    const internalPaths = analyzeFile(filePath, result, sourceText);
+        this.onPathAdded = p => visited.add(p);
+        try {
+            for (const filePath of visited) {
+                const isProjectPath = this.projectPaths.has(filePath);
+                const cachedFile = isProjectPath ? this.cache.getCachedFile(filePath) : undefined;
+                if (cachedFile) {
+                    const internalPaths = analyzeFile(filePath, undefined, '', cachedFile);
                     if (internalPaths)
                         for (const p of internalPaths)
                             visited.add(p);
+                    continue;
+                }
+                const sourceText = this.fileManager.readFile(filePath);
+                if (!sourceText) {
+                    if (isProjectPath)
+                        analyzeFile(filePath, undefined, '');
+                    continue;
                 }
-                else {
-                    for (const specifier of extractSpecifiers(result, sourceText, filePath)) {
-                        const resolved = this.resolveSpecifier(specifier, filePath);
-                        if (resolved && !isInNodeModules(resolved))
-                            visited.add(resolved);
+                try {
+                    const result = _parseFile(filePath, sourceText);
+                    this.fileManager.sourceTextCache.delete(filePath);
+                    if (isProjectPath) {
+                        const internalPaths = analyzeFile(filePath, result, sourceText);
+                        if (internalPaths)
+                            for (const p of internalPaths)
+                                visited.add(p);
+                    }
+                    else {
+                        for (const specifier of extractSpecifiers(result, sourceText, filePath)) {
+                            const resolved = this.resolveSpecifier(specifier, filePath);
+                            if (resolved && !isInNodeModules(resolved))
+                                visited.add(resolved);
+                        }
                     }
                 }
-                rescanFrontier();
-            }
-            catch {
+                catch {
+                }
             }
         }
+        finally {
+            this.onPathAdded = undefined;
+        }
         this.resolvedFiles = visited;
     }
     getUsedResolvedFiles() {
@@ -199,7 +190,7 @@ export class ProjectPrincipal {
             if (!sourceText)
                 continue;
             try {
-                const result = parseFile(filePath, sourceText);
+                const result = _parseFile(filePath, sourceText);
                 for (const specifier of extractSpecifiers(result, sourceText, filePath)) {
                     const resolved = this.resolveSpecifier(specifier, filePath);
                     if (resolved && !isInNodeModules(resolved))
@@ -221,9 +212,9 @@ export class ProjectPrincipal {
     analyzeSourceFile(filePath, options, ignoreExportsUsedInFile, parseResult, sourceText, cachedFile) {
         if (cachedFile)
             return cachedFile;
-        const fd = this.cache.getFileDescriptor(filePath);
-        if (!fd.changed && fd.meta?.data)
-            return fd.meta.data;
+        const cached = this.cache.getCachedFile(filePath);
+        if (cached)
+            return cached;
         sourceText ??= this.fileManager.readFile(filePath);
         const skipExports = this.skipExportsAnalysis.has(filePath);
         if (options.isFixExports || options.isFixTypes) {

package/dist/WorkspaceWorker.js

@@ -7,7 +7,7 @@ import { getFilteredScripts } from './manifest/helpers.js';
 import { PluginEntries, Plugins } from './plugins.js';
 import { createManifest } from './util/package-json.js';
 import { collectStringLiterals, isExternalReExportsOnly } from './typescript/ast-helpers.js';
-import { parseFile } from './typescript/ast-nodes.js';
+import { _parseFile } from './typescript/ast-nodes.js';
 import { compact } from './util/array.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './util/glob.js';
@@ -57,7 +57,7 @@ export class WorkspaceWorker {
         this.readFile = readFile;
         this.options = options;
         this.cache = new CacheConsultant(`plugins-${name}`, options);
-        this.getConfigurationHints = timerify(this.getConfigurationHints.bind(this), 'worker.getConfigurationHints');
+        this.getConfigurationHints = timerify(this.getConfigurationHints.bind(this), 'getConfigurationHints');
     }
     async init() {
         this.enabledPlugins = await this.determineEnabledPlugins();
@@ -310,7 +310,7 @@ export class WorkspaceWorker {
                     }
                     else {
                         const sourceText = this.readFile(configFilePath);
-                        parsed = sourceText ? parseFile(configFilePath, sourceText) : undefined;
+                        parsed = sourceText ? _parseFile(configFilePath, sourceText) : undefined;
                         parsedConfigCache.set(configFilePath, parsed);
                     }
                 }

package/dist/cli.js

@@ -68,7 +68,7 @@ const main = async () => {
             console.log(`\n${perfObserver.getTimerifiedFunctionsTable()}`);
         if (perfObserver.isMemoryUsageEnabled && !args['memory-realtime'])
             console.log(`\n${perfObserver.getMemoryUsageTable()}`);
-        if (perfObserver.isEnabled) {
+        if (perfObserver.isEnabled || perfObserver.isDurationEnabled) {
             const duration = perfObserver.getCurrentDurationInMs();
             console.log('\nTotal running time:', prettyMilliseconds(duration));
             perfObserver.reset();

package/dist/graph/build.js

@@ -44,6 +44,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         });
         counselor.addWorkspace(manifest);
     }
+    deputy.setWorkspacePkgNames(chief.availableWorkspacePkgNames);
     collector.addIgnorePatterns(chief.config.ignore.map(id => ({ pattern: prependDir(options.cwd, id), id })));
     collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(id => ({ pattern: prependDir(options.cwd, id), id })));
     if (options.configFilePath) {

package/dist/plugins/nuxt/helpers.js

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { Visitor } from 'oxc-parser';
 import { scriptBodies } from '../../compilers/compilers.js';
-import { parseFile } from '../../typescript/ast-nodes.js';
+import { _parseFile } from '../../typescript/ast-nodes.js';
 import { basename, dirname, isInNodeModules, join } from '../../util/path.js';
 export const getVueSfc = (cwd) => {
     try {
@@ -23,7 +23,7 @@ const readFile = (filePath) => {
         return '';
     }
 };
-export const readAndParseFile = (filePath) => parseFile(filePath, readFile(filePath));
+export const readAndParseFile = (filePath) => _parseFile(filePath, readFile(filePath));
 export const collectIdentifiers = (source, fileName) => {
     const identifiers = new Set();
     const visitor = new Visitor({
@@ -31,7 +31,7 @@ export const collectIdentifiers = (source, fileName) => {
             identifiers.add(node.name);
         },
     });
-    visitor.visit(parseFile(fileName, source).program);
+    visitor.visit(_parseFile(fileName, source).program);
     return identifiers;
 };
 export const collectTemplateInfo = (tree) => {

package/dist/plugins/nx/index.js

@@ -35,9 +35,7 @@ const resolveConfig = async (localConfig, options) => {
         .map(target => target?.executor)
         .filter(executor => executor && !executor.startsWith('.'))
         .map(executor => executor?.split(':')[0]);
-    const expand = (value) => value
-        .replaceAll('{projectRoot}', options.configFileDir)
-        .replaceAll('{workspaceRoot}', options.rootCwd);
+    const expand = (value) => value.replaceAll('{projectRoot}', options.configFileDir).replaceAll('{workspaceRoot}', options.rootCwd);
     const resolveTargetCwd = (targetCwd) => {
         if (!targetCwd)
             return options.cwd;

package/dist/plugins/sst/resolveFromAST.js

@@ -1,6 +1,6 @@
 import { Visitor } from 'oxc-parser';
 import { collectPropertyValues, getImportMap } from '../../typescript/ast-helpers.js';
-import { parseFile } from '../../typescript/ast-nodes.js';
+import { _parseFile } from '../../typescript/ast-nodes.js';
 import { toDeferResolveProductionEntry } from '../../util/input.js';
 import { dirname } from '../../util/path.js';
 import { _resolveSync } from '../../util/resolve.js';
@@ -27,7 +27,7 @@ export const getInputsFromHandlers = (program, options) => {
                             if (resolvedPath) {
                                 const stackText = options.readFile(resolvedPath);
                                 if (stackText) {
-                                    const stackResult = parseFile('stack.ts', stackText);
+                                    const stackResult = _parseFile('stack.ts', stackText);
                                     addHandlers(collectPropertyValues(stackResult.program, 'handler'));
                                 }
                             }

package/dist/run.js

@@ -9,6 +9,7 @@ import { IssueCollector } from './IssueCollector.js';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import watchReporter from './reporters/watch.js';
 import { debugLogObject } from './util/debug.js';
+import { flushGitignoreCache, initGitignoreCache } from './util/gitignore-cache.js';
 import { flushGlobCache, initGlobCache } from './util/glob-cache.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { getModuleSourcePathHandler, getWorkspaceManifestHandler } from './util/to-source-path.js';
@@ -16,8 +17,10 @@ import { getSessionHandler } from './util/watch.js';
 export const run = async (options) => {
     debugLogObject('*', 'Unresolved configuration', options);
     debugLogObject('*', 'Included issue types', options.includedIssueTypes);
-    if (options.isCache)
+    if (options.isCache) {
         initGlobCache(options.cacheLocation);
+        initGitignoreCache(options.cacheLocation);
+    }
     const chief = new ConfigurationChief(options);
     const deputy = new DependencyDeputy(options);
     const streamer = new ConsoleStreamer(options);
@@ -83,8 +86,10 @@ export const run = async (options) => {
     const { issues, counters, tagHints, configurationHints } = collector.getIssues();
     if (!options.isWatch)
         streamer.clear();
-    if (options.isCache)
+    if (options.isCache) {
         flushGlobCache();
+        flushGitignoreCache();
+    }
     return {
         results: {
             issues,

package/dist/typescript/ast-helpers.js

@@ -1,7 +1,7 @@
 import { Visitor } from 'oxc-parser';
 import stripJsonComments from 'strip-json-comments';
 import { extname, isInternal } from '../util/path.js';
-import { getStringValue, isStringLiteral, parseFile } from './ast-nodes.js';
+import { _parseFile, getStringValue, isStringLiteral } from './ast-nodes.js';
 export const getPropertyKey = (prop) => prop?.key?.type === 'Identifier' ? prop.key.name : getStringValue(prop?.key);
 export const getImportMap = (program) => {
     const importMap = new Map();
@@ -191,7 +191,7 @@ export const collectStringLiterals = (sourceText, filePath) => {
             collectJsonStringLiterals(JSON.parse(stripJsonComments(sourceText, { trailingCommas: true })), literals);
             return literals;
         }
-        const result = parseFile(filePath, sourceText);
+        const result = _parseFile(filePath, sourceText);
         const visitor = new Visitor({
             Literal(node) {
                 if (typeof node.value === 'string')

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

@@ -2,7 +2,7 @@ import { type TSEnumDeclaration, type TSModuleDeclaration } from 'oxc-parser';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile } from '../types/config.ts';
 import type { SymbolType } from '../types/issues.ts';
 import type { ExportMember } from '../types/module-graph.ts';
-export declare const parseFile: (filePath: string, sourceText: string) => import("oxc-parser").ParseResult;
+export declare const _parseFile: (filePath: string, sourceText: string) => import("oxc-parser").ParseResult;
 export type ResolveModule = (specifier: string, containingFile: string) => ResolvedModule | undefined;
 export interface ResolvedModule {
     resolvedFileName: string;

package/dist/typescript/ast-nodes.js

@@ -1,16 +1,18 @@
 import { parseSync, rawTransferSupported, } from 'oxc-parser';
 import { DEFAULT_EXTENSIONS, FIX_FLAGS, SYMBOL_TYPE } from '../constants.js';
 import { extname } from '../util/path.js';
+import { timerify } from '../util/Performance.js';
 import { EMPTY_TAGS } from './visitors/jsdoc.js';
 const defaultParseOptions = {
     sourceType: 'unambiguous',
     experimentalRawTransfer: rawTransferSupported(),
 };
-export const parseFile = (filePath, sourceText) => {
+const parseFile = (filePath, sourceText) => {
     const ext = extname(filePath);
     const parseFileName = DEFAULT_EXTENSIONS.has(ext) ? filePath : `${filePath}.ts`;
     return parseSync(parseFileName, sourceText, defaultParseOptions);
 };
+export const _parseFile = timerify(parseFile);
 export const buildLineStarts = (sourceText) => {
     const starts = [0];
     for (let i = 0; i < sourceText.length; i++) {

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

@@ -6,9 +6,9 @@ import { timerify } from '../util/Performance.js';
 import { dirname, isInNodeModules, resolve } from '../util/path.js';
 import { shouldIgnore } from '../util/tag.js';
 import { extractImportsFromComments } from './comments.js';
-import { buildLineStarts, getLineAndCol, parseFile, shouldCountRefs, } from './ast-nodes.js';
+import { _parseFile, buildLineStarts, getLineAndCol, shouldCountRefs, } from './ast-nodes.js';
 import { buildJSDocTagLookup } from './visitors/jsdoc.js';
-import { walkAST } from './visitors/walk.js';
+import { _walkAST } from './visitors/walk.js';
 const getImportsAndExports = (filePath, sourceText, resolveModule, options, ignoreExportsUsedInFile, skipExportsForFile, visitor, pluginCtx, cachedParseResult) => {
     const skipExports = skipExportsForFile || !options.isReportExports;
     const isDts = filePath.endsWith('.d.ts') || filePath.endsWith('.d.cts') || filePath.endsWith('.d.mts');
@@ -159,7 +159,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
             }
         }
     };
-    const result = cachedParseResult ?? parseFile(filePath, sourceText);
+    const result = cachedParseResult ?? _parseFile(filePath, sourceText);
     const lineStarts = buildLineStarts(sourceText);
     const getJSDocTags = buildJSDocTagLookup(result.comments, sourceText);
     let hasNodeModuleImport = false;
@@ -255,7 +255,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         pluginCtx.addScript = (s) => scripts.add(s);
         pluginCtx.addImport = (spec, pos, mod) => addImport(spec, undefined, undefined, undefined, pos, mod);
     }
-    const localRefs = walkAST(result.program, sourceText, filePath, {
+    const localRefs = _walkAST(result.program, sourceText, filePath, {
         lineStarts,
         skipExports,
         options,

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

@@ -81,5 +81,6 @@ export interface WalkState extends WalkContext {
 }
 export declare const isShadowed: (name: string, pos: number) => boolean;
 export declare function buildVisitor(pluginVisitorObjects: PluginVisitorObject[], includeLocalRefs?: boolean): Visitor;
-export declare function walkAST(program: Program, sourceText: string, filePath: string, ctx: WalkContext): Set<string> | undefined;
+declare function walkAST(program: Program, sourceText: string, filePath: string, ctx: WalkContext): Set<string> | undefined;
+export declare const _walkAST: typeof walkAST;
 export {};

package/dist/typescript/visitors/walk.js

@@ -2,6 +2,7 @@ import { Visitor, visitorKeys, } from 'oxc-parser';
 import { FIX_FLAGS, IMPORT_FLAGS, OPAQUE, SYMBOL_TYPE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
 import { isInNodeModules } from '../../util/path.js';
+import { timerify } from '../../util/Performance.js';
 import { getLineAndCol, getStringValue, isStringLiteral } from '../ast-nodes.js';
 import { EMPTY_TAGS } from './jsdoc.js';
 import { handleCallExpression, handleNewExpression } from './calls.js';
@@ -673,7 +674,7 @@ export function buildVisitor(pluginVisitorObjects, includeLocalRefs) {
     }
     return new Visitor(merged);
 }
-export function walkAST(program, sourceText, filePath, ctx) {
+function walkAST(program, sourceText, filePath, ctx) {
     const isJS = filePath.endsWith('.js') || filePath.endsWith('.mjs') || filePath.endsWith('.cjs') || filePath.endsWith('.jsx');
     state = {
         ...ctx,
@@ -780,3 +781,4 @@ export function walkAST(program, sourceText, filePath, ctx) {
     state = undefined;
     return localRefs;
 }
+export const _walkAST = timerify(walkAST);

package/dist/util/Performance.d.ts

@@ -13,6 +13,7 @@ declare class Performance {
     isEnabled: boolean;
     isTimerifyFunctions: boolean;
     isMemoryUsageEnabled: boolean;
+    isDurationEnabled: boolean;
     startTime: number;
     endTime: number;
     perfEntries: PerformanceEntry[];
@@ -21,7 +22,8 @@ declare class Performance {
     memId?: string;
     fnObserver?: PerformanceObserver;
     memObserver?: PerformanceObserver;
-    constructor({ isTimerifyFunctions, isMemoryUsageEnabled }: {
+    constructor({ isTimerifyFunctions, isMemoryUsageEnabled, isDurationEnabled }: {
+        isDurationEnabled?: boolean | undefined;
         isMemoryUsageEnabled?: boolean | undefined;
         isTimerifyFunctions?: boolean | undefined;
     });