knip 5.74.0 → 5.75.1

package/dist/graph-explorer/utils.js

@@ -1,9 +1,61 @@
+import { getCachedExportedIdentifiers, setCachedExportedIdentifiers } from './cache.js';
+import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from './visitors.js';
+export const getExportedIdentifiers = (graph, filePath, visited = new Set()) => {
+    if (visited.has(filePath))
+        return new Map();
+    visited.add(filePath);
+    const cached = getCachedExportedIdentifiers(graph, filePath);
+    if (cached)
+        return cached;
+    const node = graph.get(filePath);
+    if (!node)
+        return new Map();
+    const identifiers = new Map();
+    const addIdentifier = (identifier, isDuplicate = false) => {
+        if (identifiers.has(identifier)) {
+            identifiers.set(identifier, true);
+        }
+        else {
+            identifiers.set(identifier, isDuplicate);
+        }
+    };
+    for (const identifier of node.exports.keys()) {
+        if (identifier === 'default')
+            continue;
+        addIdentifier(identifier);
+    }
+    if (node.imports?.internal) {
+        for (const [importedPath, importDetails] of node.imports.internal) {
+            forEachPassThroughReExport(importDetails, (id, _sources) => {
+                if (id !== 'default')
+                    addIdentifier(id);
+            });
+            forEachAliasReExport(importDetails, (_id, alias, _sources) => {
+                addIdentifier(alias);
+            });
+            forEachNamespaceReExport(importDetails, (namespace, _sources) => {
+                addIdentifier(namespace, true);
+            });
+            const starSources = getStarReExportSources(importDetails);
+            if (starSources) {
+                const nestedIdentifiers = getExportedIdentifiers(graph, importedPath, new Set(visited));
+                for (const [nestedId, isNestedDuplicate] of nestedIdentifiers) {
+                    if (nestedId !== 'default')
+                        addIdentifier(nestedId, isNestedDuplicate);
+                }
+            }
+        }
+    }
+    setCachedExportedIdentifiers(graph, filePath, identifiers);
+    return identifiers;
+};
 export const hasStrictlyEnumReferences = (importsForExport, identifier) => {
     if (!importsForExport || !importsForExport.refs.has(identifier))
         return false;
-    for (const ref of importsForExport.refs)
+    for (const ref of importsForExport.refs) {
         if (ref.startsWith(`${identifier}.`))
             return false;
+    }
     return true;
 };
 export const getIssueType = (hasOnlyNsReference, isType) => {
@@ -11,3 +63,12 @@ export const getIssueType = (hasOnlyNsReference, isType) => {
         return isType ? 'nsTypes' : 'nsExports';
     return isType ? 'types' : 'exports';
 };
+export const findImportRef = (graph, importingFile, importedFile, identifier) => {
+    const node = graph.get(importingFile);
+    if (!node)
+        return undefined;
+    for (const _import of node.imports.imports) {
+        if (_import.filePath === importedFile && _import.identifier === identifier)
+            return _import;
+    }
+};

package/dist/graph-explorer/walk-up.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleGraph } from '../types/module-graph.js';
+import { RE_EXPORT_KIND } from './constants.js';
+type ReExportKind = (typeof RE_EXPORT_KIND)[keyof typeof RE_EXPORT_KIND];
+type Visitor = (filePath: string, identifier: string, via: ReExportKind) => 'continue' | 'stop' | undefined;
+export declare const walkUp: (graph: ModuleGraph, filePath: string, identifier: string, visitor: Visitor, visited?: Set<string>) => boolean;
+export {};

package/dist/graph-explorer/walk-up.js

@@ -0,0 +1,67 @@
+import { RE_EXPORT_KIND, STOP } from './constants.js';
+import { forEachAliasReExport, getNamespaceReExportSources, getPassThroughReExportSources, getStarReExportSources, } from './visitors.js';
+export const walkUp = (graph, filePath, identifier, visitor, visited = new Set()) => {
+    const key = `${filePath}:${identifier}`;
+    if (visited.has(key))
+        return false;
+    visited.add(key);
+    const node = graph.get(filePath);
+    if (!node)
+        return false;
+    const nodeExport = node.exports.get(identifier);
+    if (nodeExport && !nodeExport.isReExport) {
+        return visitor(filePath, identifier, RE_EXPORT_KIND.SELF) === STOP;
+    }
+    const starResolvers = [];
+    if (node.imports?.internal) {
+        for (const [importedFrom, importDetails] of node.imports.internal) {
+            let done = false;
+            if (!done) {
+                if (getPassThroughReExportSources(importDetails, identifier)) {
+                    if (visitor(importedFrom, identifier, RE_EXPORT_KIND.PASSTHROUGH) === STOP) {
+                        done = true;
+                    }
+                    else if (walkUp(graph, importedFrom, identifier, visitor, visited)) {
+                        done = true;
+                    }
+                }
+            }
+            if (!done) {
+                forEachAliasReExport(importDetails, (id, alias) => {
+                    if (alias !== identifier)
+                        return;
+                    if (visitor(importedFrom, id, RE_EXPORT_KIND.ALIAS) === STOP) {
+                        done = true;
+                        return false;
+                    }
+                    if (walkUp(graph, importedFrom, id, visitor, visited)) {
+                        done = true;
+                        return false;
+                    }
+                });
+            }
+            if (!done) {
+                if (getNamespaceReExportSources(importDetails, identifier)) {
+                    if (visitor(importedFrom, identifier, RE_EXPORT_KIND.NAMESPACE) === STOP) {
+                        done = true;
+                    }
+                }
+            }
+            if (!done) {
+                if (getStarReExportSources(importDetails)) {
+                    starResolvers.push(() => {
+                        if (visitor(importedFrom, identifier, RE_EXPORT_KIND.STAR) === STOP)
+                            return true;
+                        return walkUp(graph, importedFrom, identifier, visitor, visited);
+                    });
+                }
+            }
+            if (done)
+                return true;
+        }
+    }
+    for (const resolveStar of starResolvers)
+        if (resolveStar())
+            return true;
+    return false;
+};

package/dist/reporters/util/configuration-hints.d.ts

@@ -1,4 +1,5 @@
-import type { ConfigurationHintType, ReporterOptions } from '../../types/issues.js';
+import type { Results } from '../../run.js';
+import type { ConfigurationHint, ConfigurationHintType, ReporterOptions } from '../../types/issues.js';
 interface PrintHintOptions {
     type: ConfigurationHintType;
     identifier: string | RegExp;
@@ -11,4 +12,11 @@ declare const hintPrinters: Map<ConfigurationHintType, {
     print: (options: PrintHintOptions) => string;
 }>;
 export { hintPrinters };
+export interface ProcessedHint extends ConfigurationHint {
+    message: string;
+}
+export declare const finalizeConfigurationHints: (results: Results, options: {
+    cwd: string;
+    configFilePath?: string;
+}) => ProcessedHint[];
 export declare const printConfigurationHints: ({ cwd, counters, issues, tagHints, configurationHints, isTreatConfigHintsAsErrors, includedWorkspaceDirs, configFilePath, }: ReporterOptions) => void;

package/dist/reporters/util/configuration-hints.js

@@ -59,51 +59,54 @@ const hintTypesOrder = [
     ['entry-empty', 'project-empty', 'entry-redundant', 'project-redundant'],
     ['package-entry'],
 ];
-export const printConfigurationHints = ({ cwd, counters, issues, tagHints, configurationHints, isTreatConfigHintsAsErrors, includedWorkspaceDirs, configFilePath, }) => {
-    if (counters.files > 20) {
-        const workspaces = includedWorkspaceDirs
+export const finalizeConfigurationHints = (results, options) => {
+    if (results.counters.files > 20) {
+        const workspaces = results.includedWorkspaceDirs
             .sort(byPathDepth)
             .reverse()
             .map(dir => ({ dir, size: 0 }));
-        for (const filePath of issues.files) {
+        for (const filePath of results.issues.files) {
             const workspace = workspaces.find(ws => filePath.startsWith(ws.dir));
             if (workspace)
                 workspace.size++;
         }
         if (workspaces.length === 1) {
-            configurationHints.add({ type: 'top-level-unconfigured', identifier: '.', size: workspaces[0].size });
+            results.configurationHints.add({ type: 'top-level-unconfigured', identifier: '.', size: workspaces[0].size });
         }
         else {
             const topWorkspaces = workspaces.sort((a, b) => b.size - a.size).filter(ws => ws.size > 1);
             for (const { dir, size } of topWorkspaces) {
-                const identifier = toRelative(dir, cwd) || '.';
-                configurationHints.add({ type: 'workspace-unconfigured', workspaceName: identifier, identifier, size });
+                const identifier = toRelative(dir, options.cwd) || '.';
+                results.configurationHints.add({ type: 'workspace-unconfigured', workspaceName: identifier, identifier, size });
             }
         }
     }
-    if (configurationHints.size > 0) {
+    const hintsByType = new Map();
+    for (const hint of results.configurationHints) {
+        const hints = hintsByType.get(hint.type) ?? [];
+        hintsByType.set(hint.type, [...hints, hint]);
+    }
+    return hintTypesOrder.flatMap(hintTypes => hintTypes.flatMap(hintType => {
+        const hints = hintsByType.get(hintType) ?? [];
+        const topHints = hints.length > 10 ? Array.from(hints).slice(0, 10) : hints;
+        const row = topHints.map(hint => {
+            hint.filePath = relative(options.cwd, hint.filePath ?? options.configFilePath ?? '');
+            const hintPrinter = hintPrinters.get(hint.type);
+            const message = hintPrinter ? hintPrinter.print({ ...hint, configFilePath: options.configFilePath }) : '';
+            return { ...hint, message };
+        });
+        if (hints.length !== topHints.length) {
+            const more = hints.length - topHints.length;
+            row.push({ type: hintType, identifier: `...${more} more similar hints`, filePath: '', message: '' });
+        }
+        return row;
+    }));
+};
+export const printConfigurationHints = ({ cwd, counters, issues, tagHints, configurationHints, isTreatConfigHintsAsErrors, includedWorkspaceDirs, configFilePath, }) => {
+    const rows = finalizeConfigurationHints({ issues, counters, configurationHints, tagHints, includedWorkspaceDirs }, { cwd, configFilePath });
+    if (rows.length > 0) {
         const getTitle = isTreatConfigHintsAsErrors ? getColoredTitle : getDimmedTitle;
         console.log(getTitle('Configuration hints', configurationHints.size));
-        const hintsByType = new Map();
-        for (const hint of configurationHints) {
-            const hints = hintsByType.get(hint.type) ?? [];
-            hintsByType.set(hint.type, [...hints, hint]);
-        }
-        const rows = hintTypesOrder.flatMap(hintTypes => hintTypes.flatMap(hintType => {
-            const hints = hintsByType.get(hintType) ?? [];
-            const topHints = hints.length > 10 ? Array.from(hints).slice(0, 10) : hints;
-            const row = topHints.map(hint => {
-                hint.filePath = relative(cwd, hint.filePath ?? configFilePath ?? '');
-                const hintPrinter = hintPrinters.get(hint.type);
-                const message = hintPrinter ? hintPrinter.print({ ...hint, configFilePath }) : '';
-                return { ...hint, message };
-            });
-            if (hints.length !== topHints.length) {
-                const identifier = dim(`...${hints.length - topHints.length} more similar hints`);
-                row.push({ type: hintType, identifier, filePath: '', message: '' });
-            }
-            return row;
-        }));
         console.warn(getTableForHints(rows).toString());
     }
     if (tagHints.size > 0) {

package/dist/run.d.ts

@@ -1,5 +1,6 @@
 import { ConsoleStreamer } from './ConsoleStreamer.js';
 import type { MainOptions } from './util/create-options.js';
+export type Results = Awaited<ReturnType<typeof run>>['results'];
 export declare const run: (options: MainOptions) => Promise<{
     results: {
         issues: import("./types/issues.js").Issues;
@@ -8,18 +9,20 @@ export declare const run: (options: MainOptions) => Promise<{
         configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
         includedWorkspaceDirs: string[];
     };
-    watchHandler: {
+    session: {
         listener: import("fs").WatchListener<string | Buffer<ArrayBufferLike>>;
-        handleFileChanges: (changes: {
-            type: "added" | "deleted" | "modified";
-            filePath: string;
-        }[]) => Promise<{
+        handleFileChanges: (changes: import("./util/watch.js").WatchChange[]) => Promise<{
             duration: number;
             mem: number;
         }>;
         getEntryPaths: () => Set<string>;
         getGraph: () => import("./types/module-graph.js").ModuleGraph;
-        getIssues: () => import("./types/issues.js").Issues;
+        getIssues: () => {
+            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>;
+        };
     } | undefined;
     streamer: ConsoleStreamer;
 }>;

package/dist/run.js

@@ -12,7 +12,7 @@ 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';
+import { getSessionHandler } from './util/watch.js';
 export const run = async (options) => {
     debugLogObject('*', 'Unresolved configuration', options);
     debugLogObject('*', 'Included issue types', options.includedIssueTypes);
@@ -54,15 +54,15 @@ export const run = async (options) => {
         unreferencedFiles,
         options,
     });
-    let watchHandler;
-    if (options.isWatch) {
+    let session;
+    if (options.isWatch || options.isSession) {
         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, {
+        session = await getSessionHandler(options, {
             analyzedFiles,
             analyzeSourceFile,
             chief,
@@ -76,10 +76,10 @@ export const run = async (options) => {
             entryPaths,
         });
         if (options.isWatch)
-            watch('.', { recursive: true }, watchHandler.listener);
+            watch('.', { recursive: true }, session.listener);
     }
     const { issues, counters, tagHints, configurationHints } = collector.getIssues();
-    if (options.isFix) {
+    if (options.isFix && !options.isSession) {
         const touchedFiles = await fixer.fixIssues(issues);
         if (options.isFormat) {
             const report = await formatly(Array.from(touchedFiles));
@@ -101,7 +101,7 @@ export const run = async (options) => {
             configurationHints,
             includedWorkspaceDirs: chief.includedWorkspaces.map(w => w.dir),
         },
-        watchHandler,
+        session,
         streamer,
     };
 };

package/dist/session/build-maps.d.ts

@@ -0,0 +1,6 @@
+import type { GraphExplorer } from '../graph-explorer/explorer.js';
+import type { FileNode, ModuleGraph } from '../types/module-graph.js';
+import type { Export, ImportLookup, InternalImport } from './types.js';
+export declare const buildImportLookup: (fileNode: FileNode) => ImportLookup;
+export declare const buildExportsMap: (fileNode: FileNode, filePath: string, graph: ModuleGraph, entryPaths: Set<string>, explorer: GraphExplorer, importLookup: ImportLookup) => Map<string, Export>;
+export declare const buildInternalImports: (fileNode: FileNode, explorer: GraphExplorer, importLookup: ImportLookup) => InternalImport[];

package/dist/session/build-maps.js

@@ -0,0 +1,150 @@
+import { IMPORT_STAR } from '../constants.js';
+import { getExportedIdentifiers } from '../graph-explorer/utils.js';
+import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from '../graph-explorer/visitors.js';
+const FALLBACK_LOCATION = { identifier: undefined, pos: 0, line: 0, col: 0 };
+export const buildImportLookup = (fileNode) => {
+    const imports = new Map();
+    for (const _import of fileNode.imports.imports) {
+        if (!_import.filePath || !_import.identifier)
+            continue;
+        let fileMap = imports.get(_import.filePath);
+        if (!fileMap) {
+            fileMap = new Map();
+            imports.set(_import.filePath, fileMap);
+        }
+        const list = fileMap.get(_import.identifier) ?? [];
+        list.push(_import);
+        fileMap.set(_import.identifier, list);
+    }
+    return imports;
+};
+const excludeReExports = (location) => location.via !== 'reExport' &&
+    location.via !== 'reExportAs' &&
+    location.via !== 'reExportNS' &&
+    location.via !== 'reExportStar';
+export const buildExportsMap = (fileNode, filePath, graph, entryPaths, explorer, importLookup) => {
+    const exportsMap = new Map();
+    const getImport = (importedFilePath, id) => importLookup.get(importedFilePath)?.get(id)?.[0] ?? FALLBACK_LOCATION;
+    const addExport = (identifier, sourceFilePath, pos, line, col, childExports) => {
+        if (exportsMap.has(identifier))
+            return;
+        const usage = explorer.getUsage(sourceFilePath, identifier);
+        const usageEntryPaths = new Set();
+        for (const location of usage.locations)
+            if (location.isEntry)
+                usageEntryPaths.add(location.filePath);
+        if (entryPaths.has(sourceFilePath))
+            usageEntryPaths.add(sourceFilePath);
+        exportsMap.set(identifier, {
+            filePath,
+            identifier,
+            pos,
+            line,
+            col,
+            importLocations: usage.locations
+                .filter(excludeReExports)
+                .sort((a, b) => a.filePath.localeCompare(b.filePath) || a.line - b.line || a.col - b.col),
+            entryPaths: usageEntryPaths,
+            exports: childExports,
+        });
+    };
+    for (const _export of fileNode.exports.values()) {
+        addExport(_export.identifier, filePath, _export.pos, _export.line, _export.col, undefined);
+    }
+    for (const [importedFilePath, importMaps] of fileNode.imports.internal) {
+        forEachPassThroughReExport(importMaps, (id, _sources) => {
+            if (exportsMap.has(id))
+                return;
+            const directImport = getImport(importedFilePath, id);
+            addExport(id, filePath, directImport.pos, directImport.line, directImport.col, undefined);
+        });
+        forEachAliasReExport(importMaps, (id, alias, _sources) => {
+            if (exportsMap.has(alias))
+                return;
+            const aliasImport = getImport(importedFilePath, id);
+            addExport(alias, filePath, aliasImport.pos, aliasImport.line, aliasImport.col, undefined);
+        });
+        forEachNamespaceReExport(importMaps, (namespace, _sources) => {
+            if (exportsMap.has(namespace))
+                return;
+            const namespaceImport = getImport(importedFilePath, namespace) ?? getImport(importedFilePath, IMPORT_STAR);
+            const childExports = [];
+            const exportedIdentifiers = getExportedIdentifiers(graph, importedFilePath);
+            for (const identifier of exportedIdentifiers.keys()) {
+                const usage = explorer.getUsage(importedFilePath, identifier);
+                const usageEntryPaths = new Set();
+                for (const location of usage.locations)
+                    if (location.isEntry)
+                        usageEntryPaths.add(location.filePath);
+                if (entryPaths.has(importedFilePath))
+                    usageEntryPaths.add(importedFilePath);
+                childExports.push({
+                    filePath,
+                    identifier,
+                    pos: namespaceImport.pos,
+                    line: namespaceImport.line,
+                    col: namespaceImport.col,
+                    importLocations: usage.locations,
+                    entryPaths: usageEntryPaths,
+                    exports: undefined,
+                });
+            }
+            addExport(namespace, filePath, namespaceImport.pos, namespaceImport.line, namespaceImport.col, childExports);
+        });
+        const starSources = getStarReExportSources(importMaps);
+        if (starSources) {
+            const starImport = getImport(importedFilePath, IMPORT_STAR);
+            const exportedIdentifiers = getExportedIdentifiers(graph, importedFilePath);
+            for (const [nestedIdentifier] of exportedIdentifiers) {
+                if (nestedIdentifier === 'default')
+                    continue;
+                addExport(nestedIdentifier, importedFilePath, starImport.pos, starImport.line, starImport.col, undefined);
+            }
+        }
+    }
+    return exportsMap;
+};
+export const buildInternalImports = (fileNode, explorer, importLookup) => {
+    const getImport = (importedFilePath, id) => importLookup.get(importedFilePath)?.get(id)?.[0] ?? FALLBACK_LOCATION;
+    const internalImports = [];
+    const addInternalImport = (importedFilePath, identifier, alias = identifier, importLine, importCol) => {
+        const resolution = explorer.resolveDefinition(importedFilePath, identifier);
+        const location = resolution?.type === 'symbol' && resolution.exportNode
+            ? {
+                filePath: resolution.filePath,
+                pos: resolution.exportNode.pos,
+                line: resolution.exportNode.line,
+                col: resolution.exportNode.col,
+            }
+            : { filePath: importedFilePath, pos: 0, line: 0, col: 0 };
+        internalImports.push({
+            identifier: alias,
+            filePath: location.filePath,
+            pos: location.pos,
+            line: location.line,
+            col: location.col,
+            importLine,
+            importCol,
+        });
+    };
+    for (const [importedFilePath, importMaps] of fileNode.imports.internal) {
+        for (const identifier of importMaps.imported.keys()) {
+            const _import = getImport(importedFilePath, identifier);
+            addInternalImport(importedFilePath, identifier, _import.identifier, _import.line, _import.col);
+        }
+        for (const [identifier, aliasMap] of importMaps.importedAs) {
+            for (const [alias] of aliasMap) {
+                const _import = getImport(importedFilePath, identifier);
+                addInternalImport(importedFilePath, identifier, alias, _import.line, _import.col);
+            }
+        }
+        if (importMaps.importedNs.size > 0) {
+            const _import = getImport(importedFilePath, IMPORT_STAR);
+            for (const namespace of importMaps.importedNs.keys()) {
+                addInternalImport(importedFilePath, namespace, namespace, _import.line, _import.col);
+            }
+        }
+    }
+    internalImports.sort((a, b) => a.importLine - b.importLine || a.importCol - b.importCol);
+    return internalImports;
+};

package/dist/session/file-descriptor.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleGraph } from '../types/module-graph.js';
+import type { File } from './types.js';
+export interface FileDescriptorOptions {
+    isShowContention?: boolean;
+}
+export declare const buildFileDescriptor: (filePath: string, cwd: string, graph: ModuleGraph, entryPaths: Set<string>, options?: FileDescriptorOptions) => File | null;

package/dist/session/file-descriptor.js

@@ -0,0 +1,43 @@
+import { createGraphExplorer } from '../graph-explorer/explorer.js';
+import { toAbsolute } from '../util/path.js';
+import { buildExportsMap, buildImportLookup, buildInternalImports } from './build-maps.js';
+export const buildFileDescriptor = (filePath, cwd, graph, entryPaths, options = {}) => {
+    const absolutePath = toAbsolute(filePath, cwd);
+    const node = graph.get(absolutePath);
+    if (!node)
+        return null;
+    const explorer = createGraphExplorer(graph, entryPaths);
+    const metrics = { imports: 0, exports: 0, cycles: 0, contention: 0 };
+    let t0 = performance.now();
+    const importLookup = buildImportLookup(node);
+    const internalImports = buildInternalImports(node, explorer, importLookup);
+    metrics.imports = performance.now() - t0;
+    t0 = performance.now();
+    const exportsMap = buildExportsMap(node, absolutePath, graph, entryPaths, explorer, importLookup);
+    const exports = Array.from(exportsMap.values()).sort((a, b) => (a.line ?? 0) - (b.line ?? 0) || (a.col ?? 0) - (b.col ?? 0));
+    metrics.exports = performance.now() - t0;
+    t0 = performance.now();
+    const cycles = explorer.findCycles(absolutePath);
+    metrics.cycles = performance.now() - t0;
+    t0 = performance.now();
+    const contention = Object.create(null);
+    if (options.isShowContention !== false) {
+        const contentionMap = explorer.getContention(absolutePath);
+        for (const identifier of exportsMap.keys()) {
+            const details = contentionMap.get(identifier);
+            if (!details)
+                continue;
+            if (details.branching.length === 0 && details.conflict.length === 0)
+                continue;
+            contention[identifier] = details;
+        }
+    }
+    metrics.contention = performance.now() - t0;
+    return {
+        internalImports,
+        exports,
+        cycles,
+        contention,
+        metrics,
+    };
+};

package/dist/session/index.d.ts

@@ -0,0 +1,10 @@
+export { IMPORT_STAR, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.js';
+export { finalizeConfigurationHints } from '../reporters/util/configuration-hints.js';
+export { getIssuePrefix } from '../reporters/util/util.js';
+export type { Results } from '../run.js';
+export type { Issue, Issues, IssueType, Rules } from '../types/issues.js';
+export type { PackageJson } from '../types/package-json.js';
+export { createOptions, type MainOptions } from '../util/create-options.js';
+export { buildFileDescriptor, type FileDescriptorOptions } from './file-descriptor.js';
+export { createSession, type Session } from './session.js';
+export type { ContentionDetails, Export, File, SourceLocation } from './types.js';

package/dist/session/index.js

@@ -0,0 +1,6 @@
+export { IMPORT_STAR, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.js';
+export { finalizeConfigurationHints } from '../reporters/util/configuration-hints.js';
+export { getIssuePrefix } from '../reporters/util/util.js';
+export { createOptions } from '../util/create-options.js';
+export { buildFileDescriptor } from './file-descriptor.js';
+export { createSession } from './session.js';

package/dist/session/session.d.ts

@@ -0,0 +1,20 @@
+import type { CollectorIssues } from '../IssueCollector.js';
+import { type ProcessedHint } from '../reporters/util/configuration-hints.js';
+import { type Results } from '../run.js';
+import type { MainOptions } from '../util/create-options.js';
+import type { WatchChange } from '../util/watch.js';
+import { type FileDescriptorOptions } from './file-descriptor.js';
+import type { File } from './types.js';
+type WatchUpdate = {
+    duration: number;
+    mem: number;
+};
+export interface Session {
+    handleFileChanges(changes: WatchChange[]): Promise<WatchUpdate>;
+    getIssues(): CollectorIssues;
+    getResults(): Results;
+    getConfigurationHints(): ProcessedHint[];
+    describeFile(filePath: string, options?: FileDescriptorOptions): File | null;
+}
+export declare const createSession: (options: MainOptions) => Promise<Session>;
+export {};

package/dist/session/session.js

@@ -0,0 +1,18 @@
+import { finalizeConfigurationHints } from '../reporters/util/configuration-hints.js';
+import { run } from '../run.js';
+import { buildFileDescriptor } from './file-descriptor.js';
+export const createSession = async (options) => {
+    const { session, results } = await run(options);
+    if (!session)
+        throw new Error('Unable to initialize watch session');
+    return createSessionAdapter(session, results, options);
+};
+const createSessionAdapter = (session, results, options) => {
+    return {
+        handleFileChanges: session.handleFileChanges,
+        getIssues: session.getIssues,
+        getResults: () => results,
+        getConfigurationHints: () => finalizeConfigurationHints(results, options),
+        describeFile: (filePath, opts) => buildFileDescriptor(filePath, options.cwd, session.getGraph(), session.getEntryPaths(), opts),
+    };
+};

package/dist/session/types.d.ts

@@ -0,0 +1,35 @@
+import type { RE_EXPORT_KIND } from '../graph-explorer/constants.js';
+import type { Import, Position } from '../types/module-graph.js';
+export interface SourceLocation extends Position {
+    filePath: string;
+    identifier: string;
+}
+export interface InternalImport extends SourceLocation {
+    importLine: number;
+    importCol: number;
+}
+export interface Export extends SourceLocation {
+    importLocations: SourceLocation[];
+    entryPaths: Set<string>;
+    exports: Export[] | undefined;
+}
+export interface ContentionDetails {
+    branching: string[];
+    conflict: string[];
+}
+export interface FileMetrics {
+    imports: number;
+    exports: number;
+    cycles: number;
+    contention: number;
+}
+export interface File {
+    exports: Export[];
+    internalImports: InternalImport[];
+    cycles: Cycle[];
+    contention: Record<string, ContentionDetails>;
+    metrics: FileMetrics;
+}
+export type ImportLookup = Map<string, Map<string, Import[]>>;
+export type Cycle = string[];
+export type ReExportKind = (typeof RE_EXPORT_KIND)[keyof typeof RE_EXPORT_KIND];

package/dist/session/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/issues.d.ts

@@ -63,7 +63,7 @@ export type ReporterOptions = {
     options: string;
     preprocessorOptions: string;
     includedWorkspaceDirs: string[];
-    configFilePath?: string;
+    configFilePath: string | undefined;
     maxShowIssues?: number;
 };
 export type Reporter = (options: ReporterOptions) => void;