knip 6.23.0 → 6.25.0

package/dist/compilers/less.js

@@ -0,0 +1,37 @@
+import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+const dependencies = ['less'];
+const importMatcher = /@import\s+(?:\([^)]*\)\s+)?(?:url\(\s*['"]?([^'")\s]+)['"]?\s*\)|['"]([^'"]+)['"])/g;
+const isExternalUrl = (s) => s.startsWith('//') || s.startsWith('http://') || s.startsWith('https://');
+const candidates = (specifier) => {
+    const { dir, name } = splitSpec(specifier);
+    if (name.endsWith('.less') || name.endsWith('.css'))
+        return [`${dir}/${name}`];
+    return [`${dir}/${name}.less`];
+};
+export const compiler = text => {
+    if (!text.includes('@import'))
+        return '';
+    const out = [];
+    let i = 0;
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(text))) {
+        let spec = match[1] ?? match[2];
+        if (!spec || isExternalUrl(spec))
+            continue;
+        let isBare = isScopedPackage(spec);
+        if (isTildePackage(spec)) {
+            spec = spec.slice(1);
+            isBare = true;
+        }
+        if (isBare) {
+            out.push(`import _$${i++} from '${spec}';`);
+        }
+        else {
+            for (const s of candidates(spec))
+                out.push(`import _$${i++} from '${s}';`);
+        }
+    }
+    return out.join('\n');
+};
+export default { dependencies, compiler };

package/dist/compilers/mdx.d.ts

@@ -1,6 +1,5 @@
-import type { HasDependency } from './types.ts';
 declare const _default: {
-    condition: (hasDependency: HasDependency) => boolean;
+    dependencies: string[];
     compiler: (text: string) => string;
 };
 export default _default;

package/dist/compilers/mdx.js

@@ -1,5 +1,5 @@
 import { fencedCodeBlockMatcher, frontmatterMatcher, inlineCodeMatcher } from './compilers.js';
-const mdxDependencies = [
+const dependencies = [
     '@mdx-js/esbuild',
     '@mdx-js/loader',
     '@mdx-js/mdx',
@@ -10,13 +10,19 @@ const mdxDependencies = [
     '@mdx-js/vue',
     'remark-mdx',
 ];
-const condition = (hasDependency) => mdxDependencies.some(hasDependency);
 const mdxImportMatcher = /^import[^'"]+['"][^'"]+['"]/gm;
-const compiler = (text) => [
-    ...text
+const compiler = (text) => {
+    if (!text.includes('import'))
+        return '';
+    const imports = [];
+    const source = text
         .replace(frontmatterMatcher, '')
         .replace(fencedCodeBlockMatcher, '')
-        .replace(inlineCodeMatcher, '')
-        .matchAll(mdxImportMatcher),
-].join('\n');
-export default { condition, compiler };
+        .replace(inlineCodeMatcher, '');
+    let match;
+    mdxImportMatcher.lastIndex = 0;
+    while ((match = mdxImportMatcher.exec(source)))
+        imports.push(match[0]);
+    return imports.join('\n');
+};
+export default { dependencies, compiler };

package/dist/compilers/scss.d.ts

@@ -1,6 +1,7 @@
-import type { CompilerSync, HasDependency } from './types.ts';
+import type { CompilerSync } from './types.ts';
+export declare const compiler: CompilerSync;
 declare const _default: {
-    condition: (hasDependency: HasDependency) => boolean;
+    dependencies: string[];
     compiler: CompilerSync;
 };
 export default _default;

package/dist/compilers/scss.js

@@ -1,13 +1,8 @@
-import { basename, dirname } from '../util/path.js';
-const condition = (hasDependency) => hasDependency('sass') || hasDependency('sass-embedded') || hasDependency('node-sass');
+import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+const dependencies = ['sass', 'sass-embedded', 'node-sass'];
 const importMatcher = /@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
-const isAlias = (s) => (s.charCodeAt(0) === 64 && s.charCodeAt(1) === 47) || s.charCodeAt(0) === 126 || s.charCodeAt(0) === 35;
-const isScopedPackage = (s) => s.charCodeAt(0) === 64 && s.charCodeAt(1) !== 47;
-const isTildePackage = (s) => s.charCodeAt(0) === 126 && s.charCodeAt(1) !== 47;
 const candidates = (specifier) => {
-    const spec = specifier.startsWith('.') || isAlias(specifier) ? specifier : `./${specifier}`;
-    const name = basename(spec);
-    const dir = dirname(spec);
+    const { dir, name } = splitSpec(specifier);
     const hasExt = name.endsWith('.scss') || name.endsWith('.sass');
     const bases = hasExt ? [name] : [`${name}.scss`, `${name}.sass`];
     const out = [];
@@ -18,10 +13,14 @@ const candidates = (specifier) => {
     }
     return out;
 };
-const compiler = text => {
+export const compiler = text => {
+    if (!text.includes('@use') && !text.includes('@import') && !text.includes('@forward'))
+        return '';
     const out = [];
     let i = 0;
-    for (const match of text.matchAll(importMatcher)) {
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(text))) {
         let spec = match[2];
         if (!spec || spec.startsWith('sass:'))
             continue;
@@ -30,10 +29,14 @@ const compiler = text => {
             spec = spec.slice(1);
             isBare = true;
         }
-        const specs = isBare ? [spec] : candidates(spec);
-        for (const s of specs)
-            out.push(`import _$${i++} from '${s}';`);
+        if (isBare) {
+            out.push(`import _$${i++} from '${spec}';`);
+        }
+        else {
+            for (const s of candidates(spec))
+                out.push(`import _$${i++} from '${s}';`);
+        }
     }
     return out.join('\n');
 };
-export default { condition, compiler };
+export default { dependencies, compiler };

package/dist/compilers/shared.d.ts

@@ -0,0 +1,6 @@
+export declare const isScopedPackage: (s: string) => boolean;
+export declare const isTildePackage: (s: string) => boolean;
+export declare const splitSpec: (specifier: string) => {
+    dir: string;
+    name: string;
+};

package/dist/compilers/shared.js

@@ -0,0 +1,9 @@
+import { basename, dirname } from '../util/path.js';
+const isAlias = (s) => (s.charCodeAt(0) === 64 && s.charCodeAt(1) === 47) || s.charCodeAt(0) === 126 || s.charCodeAt(0) === 35;
+export const isScopedPackage = (s) => s.charCodeAt(0) === 64 && s.charCodeAt(1) !== 47;
+export const isTildePackage = (s) => s.charCodeAt(0) === 126 && s.charCodeAt(1) !== 47;
+const ensureRelative = (spec) => (spec.startsWith('.') || isAlias(spec) ? spec : `./${spec}`);
+export const splitSpec = (specifier) => {
+    const spec = ensureRelative(specifier);
+    return { dir: dirname(spec), name: basename(spec) };
+};

package/dist/compilers/style-preprocessors.d.ts

@@ -0,0 +1,2 @@
+import type { CompilerSync } from './types.ts';
+export declare const stylePreprocessorImports: CompilerSync;

package/dist/compilers/style-preprocessors.js

@@ -0,0 +1,41 @@
+import { getStyleLang, styleExtractor } from './compilers.js';
+import { compiler as lessCompiler } from './less.js';
+import { compiler as scssCompiler } from './scss.js';
+import { compiler as stylusCompiler } from './stylus.js';
+export const stylePreprocessorImports = (text, path) => {
+    let scss = '';
+    let less = '';
+    let stylus = '';
+    styleExtractor.lastIndex = 0;
+    let match;
+    while ((match = styleExtractor.exec(text))) {
+        const attrs = match[1];
+        const body = match[2];
+        if (!body)
+            continue;
+        switch (getStyleLang(attrs)) {
+            case 'scss':
+            case 'sass':
+                scss = scss ? `${scss}\n${body}` : body;
+                break;
+            case 'less':
+                less = less ? `${less}\n${body}` : body;
+                break;
+            case 'styl':
+            case 'stylus':
+                stylus = stylus ? `${stylus}\n${body}` : body;
+        }
+    }
+    let out = scss ? scssCompiler(scss, path) : '';
+    if (less) {
+        const imports = lessCompiler(less, path);
+        if (imports)
+            out = out ? `${out}\n${imports}` : imports;
+    }
+    if (stylus) {
+        const imports = stylusCompiler(stylus, path);
+        if (imports)
+            out = out ? `${out}\n${imports}` : imports;
+    }
+    return out;
+};

package/dist/compilers/stylus.d.ts

@@ -0,0 +1,7 @@
+import type { CompilerSync } from './types.ts';
+export declare const compiler: CompilerSync;
+declare const _default: {
+    dependencies: string[];
+    compiler: CompilerSync;
+};
+export default _default;

package/dist/compilers/stylus.js

@@ -0,0 +1,36 @@
+import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+const dependencies = ['stylus'];
+const importMatcher = /@(?:import|require)\s+['"]([^'"]+)['"]/g;
+const candidates = (specifier) => {
+    const { dir, name } = splitSpec(specifier);
+    if (name.endsWith('.styl') || name.endsWith('.stylus') || name.endsWith('.css'))
+        return [`${dir}/${name}`];
+    return [`${dir}/${name}.styl`, `${dir}/${name}/index.styl`];
+};
+export const compiler = text => {
+    if (!text.includes('@import') && !text.includes('@require'))
+        return '';
+    const out = [];
+    let i = 0;
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(text))) {
+        let spec = match[1];
+        if (!spec || spec.includes('*'))
+            continue;
+        let isBare = isScopedPackage(spec);
+        if (isTildePackage(spec)) {
+            spec = spec.slice(1);
+            isBare = true;
+        }
+        if (isBare) {
+            out.push(`import _$${i++} from '${spec}';`);
+        }
+        else {
+            for (const s of candidates(spec))
+                out.push(`import _$${i++} from '${s}';`);
+        }
+    }
+    return out.join('\n');
+};
+export default { dependencies, compiler };

package/dist/constants.d.ts

@@ -16,7 +16,7 @@ export declare const IGNORED_DEPENDENCIES: Set<string>;
 export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;
 export declare const FOREIGN_FILE_EXTENSIONS: Set<string>;
 export declare const IGNORE_DEFINITELY_TYPED: Set<string>;
-export declare const ISSUE_TYPES: readonly ['files', 'dependencies', 'devDependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved', 'exports', 'nsExports', 'types', 'nsTypes', 'enumMembers', 'namespaceMembers', 'duplicates', 'catalog'];
+export declare const ISSUE_TYPES: readonly ['files', 'dependencies', 'devDependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved', 'exports', 'nsExports', 'types', 'nsTypes', 'enumMembers', 'namespaceMembers', 'duplicates', 'catalog', 'cycles'];
 export declare const ISSUE_TYPE_TITLE: {
     readonly files: 'Unused files';
     readonly dependencies: 'Unused dependencies';
@@ -33,6 +33,7 @@ export declare const ISSUE_TYPE_TITLE: {
     readonly namespaceMembers: 'Unused exported namespace members';
     readonly duplicates: 'Duplicate exports';
     readonly catalog: 'Unused catalog entries';
+    readonly cycles: 'Circular dependencies';
 };
 export declare const SYMBOL_TYPE: {
     readonly CLASS: 'class';
@@ -53,6 +54,7 @@ export declare const FIX_FLAGS: {
 };
 export declare const SIDE_EFFECTS = "__side-effects";
 export declare const OPAQUE = "__opaque";
+export declare const SCRIPT_INTERPOLATION = "$__knip__";
 export declare const IMPORT_FLAGS: {
     readonly NONE: 0;
     readonly RE_EXPORT: number;
@@ -62,4 +64,6 @@ export declare const IMPORT_FLAGS: {
     readonly OPTIONAL: number;
     readonly SIDE_EFFECTS: number;
     readonly OPAQUE: number;
+    readonly AUGMENT: number;
+    readonly DYNAMIC: number;
 };

package/dist/constants.js

@@ -155,6 +155,8 @@ export const FOREIGN_FILE_EXTENSIONS = new Set([
     '.sass',
     '.scss',
     '.sh',
+    '.styl',
+    '.stylus',
     '.svg',
     '.ttf',
     '.webp',
@@ -184,6 +186,7 @@ export const ISSUE_TYPES = [
     'namespaceMembers',
     'duplicates',
     'catalog',
+    'cycles',
 ];
 export const ISSUE_TYPE_TITLE = {
     files: 'Unused files',
@@ -201,6 +204,7 @@ export const ISSUE_TYPE_TITLE = {
     namespaceMembers: 'Unused exported namespace members',
     duplicates: 'Duplicate exports',
     catalog: 'Unused catalog entries',
+    cycles: 'Circular dependencies',
 };
 export const SYMBOL_TYPE = {
     CLASS: 'class',
@@ -221,6 +225,7 @@ export const FIX_FLAGS = {
 };
 export const SIDE_EFFECTS = '__side-effects';
 export const OPAQUE = '__opaque';
+export const SCRIPT_INTERPOLATION = '$__knip__';
 export const IMPORT_FLAGS = {
     NONE: 0,
     RE_EXPORT: 1 << 0,
@@ -230,4 +235,6 @@ export const IMPORT_FLAGS = {
     OPTIONAL: 1 << 4,
     SIDE_EFFECTS: 1 << 5,
     OPAQUE: 1 << 6,
+    AUGMENT: 1 << 7,
+    DYNAMIC: 1 << 8,
 };

package/dist/graph/analyze.js

@@ -1,12 +1,27 @@
 import { createGraphExplorer } from '../graph-explorer/explorer.js';
-import { getIssueType, hasStrictlyEnumReferences } from '../graph-explorer/utils.js';
+import { getIgnoredCycleImportFlags, getIssueType, getRuntimeImport, hasStrictlyEnumReferences, } from '../graph-explorer/utils.js';
 import traceReporter from '../reporters/trace.js';
 import { shouldCountRefs } from '../typescript/ast-nodes.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
-import { perfObserver } from '../util/Performance.js';
+import { relative } from '../util/path.js';
+import { perfObserver, timerify } from '../util/Performance.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler, isAlwaysIgnored } from '../util/tag.js';
 import { INTERNAL_TAG } from '../constants.js';
+const toCyclePathKey = (path) => {
+    const length = path.length > 1 && path[0] === path[path.length - 1] ? path.length - 1 : path.length;
+    return path.slice(0, length).join('\0');
+};
+const getAllowedCyclePaths = (cycles) => {
+    if (!cycles.allow?.length)
+        return;
+    const paths = new Set();
+    for (const path of cycles.allow)
+        if (path.length > 0)
+            paths.add(toCyclePathKey(path));
+    return paths;
+};
+const isAllowedCycle = (symbols, paths) => paths?.has(toCyclePathKey(symbols.map(s => s.symbol))) ?? false;
 export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, graph, streamer, unreferencedFiles, options, }) => {
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
@@ -210,6 +225,26 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 }
             }
         }
+        if (options.isReportCycles) {
+            const cyclesConfig = chief.config.cycles;
+            const allowedCyclePaths = getAllowedCyclePaths(cyclesConfig);
+            const ignoredFlags = getIgnoredCycleImportFlags(cyclesConfig.dynamicImports ?? false);
+            for (const cycle of timerify(explorer.findAllCycles, 'findAllCycles')(ignoredFlags)) {
+                const filePath = cycle[0];
+                const ws = chief.findWorkspaceByFilePath(filePath);
+                if (!ws)
+                    continue;
+                const symbols = cycle.slice(0, -1).map((file, index) => {
+                    const node = graph.get(file);
+                    const edge = node && getRuntimeImport(node, cycle[index + 1], ignoredFlags);
+                    return edge ? { symbol: relative(options.cwd, file), ...edge } : { symbol: relative(options.cwd, file) };
+                });
+                if (isAllowedCycle(symbols, allowedCyclePaths))
+                    continue;
+                const symbol = symbols.map(s => s.symbol).join(' → ');
+                collector.addIssue({ type: 'cycles', filePath, workspace: ws.name, symbol, symbols, fixes: [] });
+            }
+        }
         const unusedFiles = options.isReportFiles
             ? [...unreferencedFiles].filter(filePath => !analyzedFiles.has(filePath))
             : [];

package/dist/graph/build.js

@@ -10,6 +10,7 @@ import { tryRealpath } from '../util/fs.js';
 import { createManifest } from '../util/package-json.js';
 import { _glob, _syncGlob, negate, prependDirToPattern as prependDir } from '../util/glob.js';
 import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
+import { resolveImportGlobs } from '../typescript/glob-imports.js';
 import { loadTSConfig } from '../util/load-tsconfig.js';
 import { createFileNode, updateImportMap } from '../util/module-graph.js';
 import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
@@ -28,6 +29,17 @@ export async function build({ chief, collector, counselor, deputy, principal, is
     const handleInput = createInputHandler(deputy, chief, isGitIgnored, addIssue, externalRefsFromInputs, options);
     const rawRootManifest = chief.getManifestForWorkspace('.');
     const rootManifest = rawRootManifest ? createManifest(rawRootManifest) : undefined;
+    const manifestsByWorkspaceName = new Map();
+    const getManifest = (dir) => {
+        const workspace = chief.findWorkspaceByFilePath(`${dir}/`);
+        if (!workspace)
+            return undefined;
+        if (!manifestsByWorkspaceName.has(workspace.name)) {
+            const raw = chief.getManifestForWorkspace(workspace.name);
+            manifestsByWorkspaceName.set(workspace.name, raw ? createManifest(raw) : undefined);
+        }
+        return manifestsByWorkspaceName.get(workspace.name);
+    };
     for (const workspace of workspaces) {
         const { name, dir, manifestPath, manifestStr } = workspace;
         const manifest = chief.getManifestForWorkspace(name);
@@ -70,6 +82,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             rootManifest,
             handleInput: (input) => handleInput(input, workspace),
             findWorkspaceByFilePath: chief.findWorkspaceByFilePath.bind(chief),
+            getManifest,
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
             ignoredWorkspacePatterns: chief.getIgnoredWorkspacesFor(name),
             enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
@@ -78,7 +91,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             options,
         });
         await worker.init();
-        const compilers = getIncludedCompilers(chief.config.syncCompilers, chief.config.asyncCompilers, dependencies);
+        const compilers = getIncludedCompilers(chief.config.syncCompilers, chief.config.asyncCompilers, dependencies, dep => deputy.addReferencedDependency(name, dep));
         const registerCompiler = async ({ extension, compiler }) => {
             const ext = normalizeCompilerExtension(extension);
             if (compilers[0].has(ext))
@@ -359,6 +372,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                     dependencies,
                     manifest: createManifest(manifest),
                     rootManifest,
+                    getManifest,
                 };
                 const inputs = _getInputsFromScripts(file.scripts, opts);
                 for (const input of inputs) {
@@ -369,6 +383,13 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                         pp.addEntryPath(specifierFilePath, { skipExportsAnalysis: true });
                 }
             }
+            if (file.importGlobs.length > 0) {
+                const globbed = resolveImportGlobs(file.importGlobs, filePath, pp.resolveGlobPattern, workspace.dir);
+                for (const importedFilePath of globbed) {
+                    if (!isGitIgnored(importedFilePath))
+                        pp.addEntryPath(importedFilePath, { skipExportsAnalysis: true });
+                }
+            }
             file.imports.unresolved = unresolvedImports;
             const pluginRefs = externalRefsFromInputs?.get(filePath);
             if (pluginRefs)
@@ -380,6 +401,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 node.exports = file.exports;
                 node.duplicates = file.duplicates;
                 node.scripts = file.scripts;
+                node.importGlobs = file.importGlobs;
                 updateImportMap(node, file.imports.internal, graph);
                 node.internalImportCache = file.imports.internal;
             }

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

@@ -13,6 +13,7 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
     resolveDefinition: (filePath: string, identifier: string) => import("./operations/resolve-definition.ts").DefinitionResult | null;
     getUsage: (filePath: string, identifier: string) => import("./operations/get-usage.ts").UsageResult;
     findCycles: (filePath: string, maxDepth?: number) => import("../session/types.ts").Cycle[];
+    findAllCycles: (ignoredFlags?: number) => import("../session/types.ts").Cycle[];
     getContention: (filePath: string) => Map<string, import("../session/types.ts").ContentionDetails>;
     invalidateCache: () => void;
 };

package/dist/graph-explorer/explorer.js

@@ -1,5 +1,6 @@
 import { invalidateCache as invalidateCacheInternal } from './cache.js';
 import { buildExportsTree } from './operations/build-exports-tree.js';
+import { findAllCycles } from './operations/find-all-cycles.js';
 import { findCycles } from './operations/find-cycles.js';
 import { getContention } from './operations/get-contention.js';
 import { getDependencyUsage } from './operations/get-dependency-usage.js';
@@ -16,6 +17,7 @@ export const createGraphExplorer = (graph, entryPaths) => {
         resolveDefinition: (filePath, identifier) => resolveDefinition(graph, filePath, identifier),
         getUsage: (filePath, identifier) => getUsage(graph, entryPaths, filePath, identifier),
         findCycles: (filePath, maxDepth) => findCycles(graph, filePath, maxDepth),
+        findAllCycles: (ignoredFlags) => findAllCycles(graph, ignoredFlags),
         getContention: (filePath) => getContention(graph, filePath),
         invalidateCache: () => invalidateCacheInternal(graph),
     };

package/dist/graph-explorer/operations/find-all-cycles.d.ts

@@ -0,0 +1,3 @@
+import type { Cycle } from '../../session/types.ts';
+import type { ModuleGraph } from '../../types/module-graph.ts';
+export declare const findAllCycles: (graph: ModuleGraph, ignoredFlags?: number) => Cycle[];

package/dist/graph-explorer/operations/find-all-cycles.js

@@ -0,0 +1,43 @@
+import { getRuntimeSuccessors } from '../utils.js';
+const UNVISITED = undefined;
+const ON_STACK = 1;
+const DONE = 2;
+export const findAllCycles = (graph, ignoredFlags) => {
+    const cycles = [];
+    const state = new Map();
+    for (const root of graph.keys()) {
+        if (state.get(root) !== UNVISITED)
+            continue;
+        const path = [];
+        const indexOnPath = new Map();
+        const successorsStack = [];
+        const push = (filePath) => {
+            state.set(filePath, ON_STACK);
+            indexOnPath.set(filePath, path.length);
+            path.push(filePath);
+            const node = graph.get(filePath);
+            successorsStack.push((node ? getRuntimeSuccessors(node, ignoredFlags) : new Set()).values());
+        };
+        push(root);
+        while (path.length > 0) {
+            const current = path[path.length - 1];
+            const next = successorsStack[successorsStack.length - 1].next();
+            if (next.done) {
+                state.set(current, DONE);
+                indexOnPath.delete(current);
+                path.pop();
+                successorsStack.pop();
+                continue;
+            }
+            const successor = next.value;
+            const successorState = state.get(successor);
+            if (successorState === ON_STACK) {
+                cycles.push([...path.slice(indexOnPath.get(successor)), successor]);
+            }
+            else if (successorState === UNVISITED) {
+                push(successor);
+            }
+        }
+    }
+    return cycles;
+};

package/dist/graph-explorer/operations/find-cycles.js

@@ -1,3 +1,4 @@
+import { getRuntimeSuccessors } from '../utils.js';
 export const findCycles = (graph, filePath, maxDepth = 16) => {
     const cycles = [];
     const visited = new Set();
@@ -7,16 +8,9 @@ export const findCycles = (graph, filePath, maxDepth = 16) => {
         if (path.length > maxDepth)
             return;
         const node = graph.get(currentPath);
-        if (!node?.imports?.internal)
+        if (!node)
             return;
-        const nonTypeOnlyImports = new Set();
-        for (const _import of node.imports.imports) {
-            if (_import.filePath && !_import.isTypeOnly)
-                nonTypeOnlyImports.add(_import.filePath);
-        }
-        for (const [importedPath] of node.imports.internal) {
-            if (!nonTypeOnlyImports.has(importedPath))
-                continue;
+        for (const importedPath of getRuntimeSuccessors(node)) {
             if (importedPath === filePath) {
                 cycles.push([...path, importedPath]);
                 continue;

package/dist/graph-explorer/utils.d.ts

@@ -1,5 +1,14 @@
-import type { Import, ImportMaps, ModuleGraph } from '../types/module-graph.ts';
+import type { FileNode, Import, ImportMaps, ModuleGraph } from '../types/module-graph.ts';
+export declare const getIgnoredCycleImportFlags: (includeDynamicImports: boolean) => number;
 export declare const getExportedIdentifiers: (graph: ModuleGraph, filePath: string, visited?: Set<string>) => Map<string, boolean>;
+export declare const getRuntimeSuccessors: (node: FileNode, ignoredFlags?: number) => Set<string>;
+export declare const getRuntimeImport: (node: FileNode, filePath: string, ignoredFlags?: number) => {
+    kind: string;
+    specifier: string;
+    pos: number;
+    line: number;
+    col: number;
+} | undefined;
 export declare const hasStrictlyEnumReferences: (importsForExport: ImportMaps | undefined, identifier: string) => boolean;
 export declare const getIssueType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "nsTypes" | "types";
 export declare const findImportRef: (graph: ModuleGraph, importingFile: string, importedFile: string, identifier: string) => Import | undefined;

package/dist/graph-explorer/utils.js

@@ -1,5 +1,8 @@
+import { IMPORT_FLAGS, IMPORT_STAR, OPAQUE, SIDE_EFFECTS } from '../constants.js';
 import { getCachedExportedIdentifiers, setCachedExportedIdentifiers } from './cache.js';
 import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from './visitors.js';
+const IGNORED_CYCLE_IMPORT_FLAGS = IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.DYNAMIC;
+export const getIgnoredCycleImportFlags = (includeDynamicImports) => includeDynamicImports ? IMPORT_FLAGS.ENTRY : IGNORED_CYCLE_IMPORT_FLAGS;
 export const getExportedIdentifiers = (graph, filePath, visited = new Set()) => {
     if (visited.has(filePath))
         return new Map();
@@ -49,6 +52,56 @@ export const getExportedIdentifiers = (graph, filePath, visited = new Set()) =>
     setCachedExportedIdentifiers(graph, filePath, identifiers);
     return identifiers;
 };
+export const getRuntimeSuccessors = (node, ignoredFlags = IGNORED_CYCLE_IMPORT_FLAGS) => {
+    const successors = new Set();
+    for (const _import of node.imports.imports) {
+        if (_import.filePath &&
+            !_import.isTypeOnly &&
+            !(_import.modifiers & ignoredFlags) &&
+            node.imports.internal.has(_import.filePath)) {
+            successors.add(_import.filePath);
+        }
+    }
+    return successors;
+};
+const getImportKind = (importMaps, identifier, modifiers) => {
+    if (modifiers & IMPORT_FLAGS.DYNAMIC)
+        return 'dynamicImport';
+    if (identifier === IMPORT_STAR && importMaps.reExport.has(IMPORT_STAR))
+        return 'reExportStar';
+    if (identifier && importMaps.reExportNs.has(identifier))
+        return 'reExportNS';
+    if (identifier && importMaps.reExportAs.has(identifier))
+        return 'reExportAs';
+    if (identifier && importMaps.reExport.has(identifier))
+        return 'reExport';
+    if (identifier === IMPORT_STAR && importMaps.importNs.size > 0)
+        return 'importNS';
+    if (identifier && importMaps.importAs.has(identifier))
+        return 'importAs';
+    if (identifier === OPAQUE)
+        return 'dynamicImport';
+    if (identifier === SIDE_EFFECTS)
+        return 'sideEffectImport';
+    return 'import';
+};
+export const getRuntimeImport = (node, filePath, ignoredFlags = IGNORED_CYCLE_IMPORT_FLAGS) => {
+    const importMaps = node.imports.internal.get(filePath);
+    if (!importMaps)
+        return;
+    let result;
+    for (const _import of node.imports.imports) {
+        if (_import.filePath !== filePath || _import.isTypeOnly || _import.modifiers & ignoredFlags)
+            continue;
+        if (!result || _import.line < result.line || (_import.line === result.line && _import.col < result.col)) {
+            result = _import;
+        }
+    }
+    if (!result)
+        return;
+    const { specifier, pos, line, col, identifier, modifiers } = result;
+    return { kind: getImportKind(importMaps, identifier, modifiers), specifier, pos, line, col };
+};
 export const hasStrictlyEnumReferences = (importsForExport, identifier) => {
     if (!importsForExport || !importsForExport.refs.has(identifier))
         return false;