@taiga-ui/eslint-plugin-experience-next 0.503.0 → 0.504.0

package/README.md

@@ -80,7 +80,7 @@ from third-party plugins. The exact severities and file globs live in
 | [flat-exports](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/flat-exports.md)                                                                       | Spread nested arrays when exporting Angular entity collections                                      |     | 🔧  |     |
 | [host-attributes-sort](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/host-attributes-sort.md)                                                       | Sort Angular host metadata attributes using configurable attribute groups                           | ✅  | 🔧  |     |
 | [html-logical-properties](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/html-logical-properties.md)                                                 | Enforce logical CSS properties over directional ones in Angular template style bindings             | ✅  | 🔧  |     |
-| [import-integrity](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/import-integrity.md)                                                               | Fast import default, namespace, cycle, duplicate, named-as-default, and self-import checks          | ✅  | 🔧  |     |
+| [import-integrity](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/import-integrity.md)                                                               | Fast import default, namespace, cycle, duplicate, named-as-default, self-import, and path checks    | ✅  | 🔧  |     |
 | [injection-token-description](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/injection-token-description.md)                                         | Require `InjectionToken` descriptions to include the token name                                     | ✅  | 🔧  |     |
 | [no-commonjs-import-patterns](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-commonjs-import-patterns.md)                                         | Disallow legacy CommonJS interop import patterns                                                    | ✅  |     |     |
 | [no-deep-imports](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-deep-imports.md)                                                                 | Disables deep imports of Taiga UI packages                                                          | ✅  | 🔧  |     |

package/index.d.ts

@@ -38,7 +38,7 @@ declare const plugin: {
         'html-logical-properties': import("eslint").Rule.RuleModule & {
             name: string;
         };
-        'import-integrity': import("@typescript-eslint/utils/ts-eslint").RuleModule<"duplicateImport" | "importCycle" | "missingDefaultExport" | "namedAsDefault" | "namedAsDefaultMember" | "selfImport" | "unknownNamespaceMember", [({
+        'import-integrity': import("@typescript-eslint/utils/ts-eslint").RuleModule<"duplicateImport" | "importCycle" | "missingDefaultExport" | "namedAsDefault" | "namedAsDefaultMember" | "selfImport" | "unknownNamespaceMember" | "uselessPathSegments", [({
             checkCycles?: boolean;
             checkDefaultImports?: boolean;
             checkDuplicateImports?: boolean;
@@ -46,6 +46,7 @@ declare const plugin: {
             checkNamedAsDefaultMembers?: boolean;
             checkNamespaceMembers?: boolean;
             checkSelfImports?: boolean;
+            checkUselessPathSegments?: boolean;
             ignoreExternalDefaultImports?: boolean;
         } | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;

package/index.esm.js

@@ -890,7 +890,7 @@ var recommended = defineConfig([
             'import/no-named-as-default-member': 'off', // Covered by @taiga-ui/experience-next/import-integrity.
             'import/no-self-import': 'off', // Covered by @taiga-ui/experience-next/import-integrity.
             'import/no-unresolved': 'off',
-            'import/no-useless-path-segments': ['error', { noUselessIndex: true }],
+            'import/no-useless-path-segments': 'off', // Covered by @taiga-ui/experience-next/import-integrity.
             'import/no-webpack-loader-syntax': 'error',
             'lines-around-comment': [
                 'error',
@@ -247754,9 +247754,37 @@ function resolveModuleFileName(program, containingFile, moduleSpecifier) {
     }
     return resolved.resolvedFileName;
 }
-function getModuleSpecifierPath(moduleSpecifier) {
+function splitModuleSpecifierQuery(moduleSpecifier) {
     const queryIndex = moduleSpecifier.indexOf('?');
-    return queryIndex === -1 ? moduleSpecifier : moduleSpecifier.slice(0, queryIndex);
+    return queryIndex === -1
+        ? { path: moduleSpecifier, query: '' }
+        : {
+            path: moduleSpecifier.slice(0, queryIndex),
+            query: moduleSpecifier.slice(queryIndex),
+        };
+}
+function getModuleSpecifierPath(moduleSpecifier) {
+    return splitModuleSpecifierQuery(moduleSpecifier).path;
+}
+function toRelativeImportPath(relativePath) {
+    const stripped = relativePath.replaceAll(/\/$/g, '');
+    return /^\.{1,2}$|^\.{1,2}\//.test(stripped) ? stripped : `./${stripped}`;
+}
+function normalizeImportPath(moduleSpecifierPath) {
+    return toRelativeImportPath(path.posix.normalize(moduleSpecifierPath));
+}
+function countRelativeParents(pathSegments) {
+    return pathSegments.filter((segment) => segment === '..').length;
+}
+function isIndexModulePath(moduleSpecifierPath) {
+    return /(?:^|\/)index(?:\.[cm]?[jt]sx?)?$/.test(moduleSpecifierPath);
+}
+function quoteModuleSpecifier(source, moduleSpecifier) {
+    const quote = source.raw.startsWith('"') ? '"' : "'";
+    const escaped = moduleSpecifier
+        .replaceAll('\\', '\\\\')
+        .replaceAll(quote, `\\${quote}`);
+    return `${quote}${escaped}${quote}`;
 }
 function resolveModuleKey(program, containingFile, moduleSpecifier, canonicalFileName) {
     const moduleSpecifierPath = getModuleSpecifierPath(moduleSpecifier);
@@ -247860,149 +247888,14 @@ function getRuntimeModuleSpecifier(statement) {
     }
     return null;
 }
-function buildDependenciesByFileName(program, canonicalFileName) {
-    const sourceFiles = program.getSourceFiles().filter(isProjectCodeFile);
-    const projectFileNames = new Set(sourceFiles.map((sourceFile) => canonicalFileName(sourceFile.fileName)));
-    const dependenciesByFileName = new Map();
-    const displayFileNameByFileName = new Map();
-    for (const sourceFile of sourceFiles) {
-        const fileName = canonicalFileName(sourceFile.fileName);
-        const edges = [];
-        displayFileNameByFileName.set(fileName, sourceFile.fileName);
-        for (const statement of sourceFile.statements) {
-            const moduleSpecifier = getRuntimeModuleSpecifier(statement);
-            if (!moduleSpecifier) {
-                continue;
-            }
-            const resolvedFileName = resolveModuleFileName(program, sourceFile.fileName, moduleSpecifier);
-            if (!resolvedFileName) {
-                continue;
-            }
-            const targetFileName = canonicalFileName(resolvedFileName);
-            if (!projectFileNames.has(targetFileName)) {
-                continue;
-            }
-            edges.push({
-                isImport: ts.isImportDeclaration(statement),
-                moduleSpecifier,
-                targetFileName,
-            });
-        }
-        dependenciesByFileName.set(fileName, edges);
-    }
-    return { dependenciesByFileName, displayFileNameByFileName };
-}
-function findStronglyConnectedComponents(dependenciesByFileName) {
-    let nextComponentId = 0;
-    let nextIndex = 0;
-    const componentIdByFileName = new Map();
-    const componentSizeById = new Map();
-    const nodeStateByFileName = new Map();
-    const stack = [];
-    function visit(fileName) {
-        const state = {
-            index: nextIndex,
-            lowLink: nextIndex,
-            onStack: true,
-        };
-        nextIndex += 1;
-        nodeStateByFileName.set(fileName, state);
-        stack.push(fileName);
-        for (const edge of dependenciesByFileName.get(fileName) ?? []) {
-            const targetState = nodeStateByFileName.get(edge.targetFileName);
-            if (!targetState) {
-                visit(edge.targetFileName);
-                const visitedTargetState = nodeStateByFileName.get(edge.targetFileName);
-                if (visitedTargetState) {
-                    state.lowLink = Math.min(state.lowLink, visitedTargetState.lowLink);
-                }
-                continue;
-            }
-            if (targetState.onStack) {
-                state.lowLink = Math.min(state.lowLink, targetState.index);
-            }
-        }
-        if (state.lowLink !== state.index) {
-            return;
-        }
-        const componentId = nextComponentId;
-        let componentSize = 0;
-        let shouldPop = stack.length > 0;
-        nextComponentId += 1;
-        while (shouldPop) {
-            const memberFileName = stack.pop();
-            if (!memberFileName) {
-                shouldPop = false;
-                continue;
-            }
-            const memberState = nodeStateByFileName.get(memberFileName);
-            if (memberState) {
-                memberState.onStack = false;
-            }
-            componentSize += 1;
-            componentIdByFileName.set(memberFileName, componentId);
-            shouldPop = stack.length > 0 && memberFileName !== fileName;
-        }
-        componentSizeById.set(componentId, componentSize);
-    }
-    for (const fileName of dependenciesByFileName.keys()) {
-        if (!nodeStateByFileName.has(fileName)) {
-            visit(fileName);
-        }
-    }
-    return { componentIdByFileName, componentSizeById };
-}
-function collectSelfCycles(dependenciesByFileName) {
-    const selfCycleFileNames = new Set();
-    for (const [fileName, edges] of dependenciesByFileName) {
-        if (edges.some((edge) => edge.targetFileName === fileName)) {
-            selfCycleFileNames.add(fileName);
-        }
-    }
-    return selfCycleFileNames;
-}
-function buildSccHasImportEdge(dependenciesByFileName, componentIdByFileName) {
-    const result = new Map();
-    for (const [fileName, edges] of dependenciesByFileName) {
-        const sourceComponentId = componentIdByFileName.get(fileName);
-        if (sourceComponentId === undefined || result.get(sourceComponentId) === true) {
-            continue;
-        }
-        for (const edge of edges) {
-            if (edge.isImport &&
-                componentIdByFileName.get(edge.targetFileName) === sourceComponentId) {
-                result.set(sourceComponentId, true);
-                break;
-            }
-        }
-    }
-    return result;
-}
-function buildBarrelFileNames(dependenciesByFileName) {
-    const result = new Set();
-    for (const [fileName, edges] of dependenciesByFileName) {
-        if (edges.some((edge) => !edge.isImport)) {
-            result.add(fileName);
-        }
-    }
-    return result;
-}
 function getImportGraph(program) {
     const cached = importGraphCacheByProgram.get(program);
     if (cached) {
         return cached;
     }
-    const canonicalFileName = createCanonicalFileName();
-    const { dependenciesByFileName, displayFileNameByFileName } = buildDependenciesByFileName(program, canonicalFileName);
-    const { componentIdByFileName, componentSizeById } = findStronglyConnectedComponents(dependenciesByFileName);
     const cache = {
-        barrelFileNames: buildBarrelFileNames(dependenciesByFileName),
-        componentIdByFileName,
-        componentSizeById,
-        dependenciesByFileName,
-        displayFileNameByFileName,
-        sccHasImportEdgeById: buildSccHasImportEdge(dependenciesByFileName, componentIdByFileName),
-        selfCycleFileNames: collectSelfCycles(dependenciesByFileName),
+        dependenciesByFileName: new Map(),
+        displayFileNameByFileName: new Map(),
     };
     importGraphCacheByProgram.set(program, cache);
     return cache;
@@ -248092,76 +247985,136 @@ function getImportOrReExportModuleSpecifier(node) {
     }
     return typeof node.source.value === 'string' ? node.source.value : null;
 }
-function findCyclicTargetFileName(graph, currentFileName, moduleSpecifier) {
-    const currentComponentId = graph.componentIdByFileName.get(currentFileName);
-    if (currentComponentId === undefined) {
-        return null;
+function getProjectSourceFile(program, fileName) {
+    const sourceFile = getSourceFileByFileName(program, fileName);
+    return sourceFile && isProjectCodeFile(sourceFile) ? sourceFile : null;
+}
+function getDependenciesForFile(program, graph, fileName, canonicalFileName) {
+    const cached = graph.dependenciesByFileName.get(fileName);
+    if (cached) {
+        return cached;
     }
-    const currentComponentSize = graph.componentSizeById.get(currentComponentId) ?? 0;
-    for (const edge of graph.dependenciesByFileName.get(currentFileName) ?? []) {
-        if (edge.moduleSpecifier !== moduleSpecifier) {
+    const sourceFile = getProjectSourceFile(program, fileName);
+    const edges = [];
+    graph.dependenciesByFileName.set(fileName, edges);
+    if (!sourceFile) {
+        return edges;
+    }
+    graph.displayFileNameByFileName.set(fileName, sourceFile.fileName);
+    for (const statement of sourceFile.statements) {
+        const moduleSpecifier = getRuntimeModuleSpecifier(statement);
+        if (!moduleSpecifier) {
             continue;
         }
-        const isSelfCycle = edge.targetFileName === currentFileName &&
-            graph.selfCycleFileNames.has(currentFileName);
-        const isSameComponentCycle = currentComponentSize > 1 &&
-            graph.componentIdByFileName.get(edge.targetFileName) === currentComponentId;
-        if (isSelfCycle || isSameComponentCycle) {
-            return edge.targetFileName;
+        const resolvedFileName = resolveModuleFileName(program, sourceFile.fileName, moduleSpecifier);
+        if (!resolvedFileName) {
+            continue;
+        }
+        const targetSourceFile = getProjectSourceFile(program, resolvedFileName);
+        if (!targetSourceFile) {
+            continue;
         }
+        const targetFileName = canonicalFileName(targetSourceFile.fileName);
+        graph.displayFileNameByFileName.set(targetFileName, targetSourceFile.fileName);
+        edges.push({
+            isImport: ts.isImportDeclaration(statement),
+            moduleSpecifier,
+            targetFileName,
+        });
     }
-    return null;
+    return edges;
+}
+function fileHasReExportEdges(program, graph, fileName, canonicalFileName) {
+    return getDependenciesForFile(program, graph, fileName, canonicalFileName).some((edge) => !edge.isImport);
+}
+function getCycleStateKey(fileName, hasImportEdge) {
+    return `${hasImportEdge ? '1' : '0'}:${fileName}`;
+}
+function reconstructSearchPath(stateKey, previousStateKeyByStateKey, fileNameByStateKey) {
+    const pathSegments = [];
+    let currentStateKey = stateKey;
+    while (currentStateKey !== null) {
+        const fileName = fileNameByStateKey.get(currentStateKey);
+        if (!fileName) {
+            return [];
+        }
+        pathSegments.push(fileName);
+        const previousStateKey = previousStateKeyByStateKey.get(currentStateKey);
+        if (previousStateKey === undefined) {
+            return [];
+        }
+        currentStateKey = previousStateKey;
+    }
+    return pathSegments.reverse();
 }
-function findPathWithinComponent(graph, startFileName, endFileName, componentId) {
-    const queue = [startFileName];
-    const previousFileName = new Map([[startFileName, null]]);
-    for (let index = 0; index < queue.length && !previousFileName.has(endFileName); index += 1) {
-        const currentFileName = queue[index];
-        if (!currentFileName) {
+function findCyclePathFromEdge(program, graph, currentFileName, edge, canonicalFileName) {
+    const queue = [{ fileName: edge.targetFileName, hasImportEdge: edge.isImport }];
+    const startStateKey = getCycleStateKey(edge.targetFileName, edge.isImport);
+    const previousStateKeyByStateKey = new Map([
+        [startStateKey, null],
+    ]);
+    const fileNameByStateKey = new Map([
+        [startStateKey, edge.targetFileName],
+    ]);
+    let firstResult = null;
+    for (const state of queue) {
+        const stateKey = getCycleStateKey(state.fileName, state.hasImportEdge);
+        if (state.fileName === currentFileName) {
+            const path = reconstructSearchPath(stateKey, previousStateKeyByStateKey, fileNameByStateKey);
+            if (path.length === 0) {
+                continue;
+            }
+            const result = {
+                cyclePath: [currentFileName, ...path],
+                hasImportEdge: state.hasImportEdge,
+                targetFileName: edge.targetFileName,
+            };
+            if (result.hasImportEdge) {
+                return result;
+            }
+            firstResult ??= result;
             continue;
         }
-        for (const edge of graph.dependenciesByFileName.get(currentFileName) ?? []) {
-            if (graph.componentIdByFileName.get(edge.targetFileName) !== componentId ||
-                previousFileName.has(edge.targetFileName)) {
+        for (const nextEdge of getDependenciesForFile(program, graph, state.fileName, canonicalFileName)) {
+            const nextState = {
+                fileName: nextEdge.targetFileName,
+                hasImportEdge: state.hasImportEdge || nextEdge.isImport,
+            };
+            const nextStateKey = getCycleStateKey(nextState.fileName, nextState.hasImportEdge);
+            if (previousStateKeyByStateKey.has(nextStateKey)) {
                 continue;
             }
-            previousFileName.set(edge.targetFileName, currentFileName);
-            queue.push(edge.targetFileName);
+            previousStateKeyByStateKey.set(nextStateKey, stateKey);
+            fileNameByStateKey.set(nextStateKey, nextState.fileName);
+            queue.push(nextState);
         }
     }
-    if (!previousFileName.has(endFileName)) {
-        return [startFileName, endFileName];
-    }
-    const pathSegments = [];
-    let currentFileName = endFileName;
-    while (currentFileName !== null) {
-        pathSegments.push(currentFileName);
-        const nextFileName = previousFileName.get(currentFileName);
-        if (nextFileName === undefined) {
-            return [startFileName, endFileName];
+    return firstResult;
+}
+function findCyclePathForSpecifier(program, graph, currentFileName, moduleSpecifier, canonicalFileName) {
+    let firstResult = null;
+    for (const edge of getDependenciesForFile(program, graph, currentFileName, canonicalFileName)) {
+        if (edge.moduleSpecifier !== moduleSpecifier) {
+            continue;
+        }
+        const result = findCyclePathFromEdge(program, graph, currentFileName, edge, canonicalFileName);
+        if (!result) {
+            continue;
+        }
+        if (result.hasImportEdge) {
+            return result;
         }
-        currentFileName = nextFileName;
+        firstResult ??= result;
     }
-    return pathSegments.reverse();
+    return firstResult;
 }
 function formatFileName(graph, fileName, cwd) {
     const displayFileName = graph.displayFileNameByFileName.get(fileName) ?? fileName;
     const relativeFileName = normalizeSlashes(path.relative(cwd, displayFileName));
     return relativeFileName || normalizeSlashes(path.basename(displayFileName));
 }
-function formatCyclePath(graph, currentFileName, targetFileName, cwd) {
-    const componentId = graph.componentIdByFileName.get(currentFileName);
-    if (componentId === undefined || currentFileName === targetFileName) {
-        return [currentFileName, targetFileName]
-            .map((fileName) => formatFileName(graph, fileName, cwd))
-            .join(' -> ');
-    }
-    return [
-        currentFileName,
-        ...findPathWithinComponent(graph, targetFileName, currentFileName, componentId),
-    ]
-        .map((fileName) => formatFileName(graph, fileName, cwd))
-        .join(' -> ');
+function formatCyclePath(graph, cyclePath, cwd) {
+    return cyclePath.map((fileName) => formatFileName(graph, fileName, cwd)).join(' -> ');
 }
 function getAliasedSymbolIfNeeded(checker, symbol) {
     return (symbol.flags & ts.SymbolFlags.Alias) === 0
@@ -248306,6 +248259,7 @@ const rule$K = createRule({
         const checkNamedAsDefaultMembers = context.options[0]?.checkNamedAsDefaultMembers ?? true;
         const checkNamespaceMembers = context.options[0]?.checkNamespaceMembers ?? true;
         const checkSelfImports = context.options[0]?.checkSelfImports ?? true;
+        const shouldCheckUselessPathSegments = context.options[0]?.checkUselessPathSegments ?? true;
         const ignoreExternalDefaultImports = context.options[0]?.ignoreExternalDefaultImports ?? true;
         const canonicalFileName = createCanonicalFileName();
         const currentFileName = canonicalFileName(context.filename);
@@ -248435,10 +248389,82 @@ const rule$K = createRule({
                 node,
             });
         }
-        function checkDeclarationSelfImport(node) {
-            if (!node.source || typeof node.source.value !== 'string') {
+        function getNormalizedPathReplacement(moduleSpecifierPath, canonicalResolvedFileName) {
+            const normalizedPath = normalizeImportPath(moduleSpecifierPath);
+            if (normalizedPath === moduleSpecifierPath) {
+                return null;
+            }
+            const normalizedResolved = resolveModule(tsProgram, context.filename, normalizedPath);
+            return normalizedResolved &&
+                canonicalFileName(normalizedResolved.resolvedFileName) ===
+                    canonicalResolvedFileName
+                ? normalizedPath
+                : null;
+        }
+        function getIndexPathReplacement(moduleSpecifierPath, canonicalResolvedFileName) {
+            if (!isIndexModulePath(moduleSpecifierPath)) {
+                return null;
+            }
+            const parentDirectory = path.posix.dirname(moduleSpecifierPath);
+            if (parentDirectory === '.' || parentDirectory === '..') {
+                return parentDirectory;
+            }
+            const parentResolved = resolveModule(tsProgram, context.filename, parentDirectory);
+            return parentResolved &&
+                canonicalFileName(parentResolved.resolvedFileName) !==
+                    canonicalResolvedFileName
+                ? `${parentDirectory}/`
+                : parentDirectory;
+        }
+        function getExcessParentPathReplacement(moduleSpecifierPath, resolvedFileName) {
+            if (moduleSpecifierPath.startsWith('./')) {
+                return null;
+            }
+            const expectedPath = computeRelativeImportPath(context.filename, resolvedFileName);
+            const importSegments = moduleSpecifierPath.replace(/^\.\//, '').split('/');
+            const importParentCount = countRelativeParents(importSegments);
+            const expectedParentCount = countRelativeParents(expectedPath.split('/'));
+            if (importParentCount <= expectedParentCount ||
+                expectedPath === moduleSpecifierPath) {
+                return null;
+            }
+            return expectedPath;
+        }
+        function getUselessPathSegmentsReplacement(moduleSpecifierPath) {
+            const resolved = resolveModule(tsProgram, context.filename, moduleSpecifierPath);
+            if (!resolved) {
+                return null;
+            }
+            const canonicalResolvedFileName = canonicalFileName(resolved.resolvedFileName);
+            return (getNormalizedPathReplacement(moduleSpecifierPath, canonicalResolvedFileName) ??
+                getIndexPathReplacement(moduleSpecifierPath, canonicalResolvedFileName) ??
+                getExcessParentPathReplacement(moduleSpecifierPath, resolved.resolvedFileName));
+        }
+        function checkUselessPathSegments(source) {
+            if (!shouldCheckUselessPathSegments || !source.value.startsWith('.')) {
+                return;
+            }
+            const parts = splitModuleSpecifierQuery(source.value);
+            const proposedPath = getUselessPathSegmentsReplacement(parts.path);
+            if (!proposedPath) {
+                return;
+            }
+            const proposedModuleSpecifier = `${proposedPath}${parts.query}`;
+            context.report({
+                data: {
+                    moduleSpecifier: source.value,
+                    proposedPath: proposedModuleSpecifier,
+                },
+                fix: (fixer) => fixer.replaceText(source, quoteModuleSpecifier(source, proposedModuleSpecifier)),
+                messageId: 'uselessPathSegments',
+                node: source,
+            });
+        }
+        function checkDeclarationModuleSpecifier(node) {
+            if (!isStringLiteral(node.source)) {
                 return;
             }
+            checkUselessPathSegments(node.source);
             checkSelfImport(node.source.value, node.source);
         }
         function checkRequireSelfImport(node) {
@@ -248454,12 +248480,12 @@ const rule$K = createRule({
             }
             checkSelfImport(moduleSpecifier.value, moduleSpecifier);
         }
-        function checkDynamicSelfImport(node) {
+        function checkDynamicImport(node) {
             const { source } = node;
-            if (source.type !== dist$3.AST_NODE_TYPES.Literal ||
-                typeof source.value !== 'string') {
+            if (!isStringLiteral(source)) {
                 return;
             }
+            checkUselessPathSegments(source);
             checkSelfImport(source.value, source);
         }
         function checkImportCycle(node) {
@@ -248475,11 +248501,11 @@ const rule$K = createRule({
                 return;
             }
             const graph = getImportGraph(tsProgram);
-            const targetFileName = findCyclicTargetFileName(graph, currentFileName, moduleSpecifier);
-            if (!targetFileName) {
+            const cycle = findCyclePathForSpecifier(tsProgram, graph, currentFileName, moduleSpecifier, canonicalFileName);
+            if (!cycle) {
                 return;
             }
-            const cyclePath = formatCyclePath(graph, currentFileName, targetFileName, context.cwd);
+            const cyclePath = formatCyclePath(graph, cycle.cyclePath, context.cwd);
             if (node.type === dist$3.AST_NODE_TYPES.ImportDeclaration) {
                 // Compute the redirect replacement eagerly so we can decide whether
                 // to suppress. If a redirect to the direct source file is possible,
@@ -248501,12 +248527,10 @@ const rule$K = createRule({
             }
             else {
                 // For re-export nodes (export * from / export {x} from), suppress the
-                // error when the same SCC already contains an ImportDeclaration edge.
+                // error when the reachable cycle contains an ImportDeclaration edge.
                 // That ImportDeclaration will be reported (and fixed) directly, so
                 // reporting the barrel re-export would create duplicate, unfixable noise.
-                const componentId = graph.componentIdByFileName.get(currentFileName);
-                if (componentId !== undefined &&
-                    graph.sccHasImportEdgeById.get(componentId) === true) {
+                if (cycle.hasImportEdge) {
                     return;
                 }
                 context.report({
@@ -248528,7 +248552,7 @@ const rule$K = createRule({
             // Not a barrel (has no re-export edges) — symbols are defined locally,
             // so there is no shorter direct-source path to redirect to.
             if (!canonicalBarrelFileName ||
-                !getImportGraph(tsProgram).barrelFileNames.has(canonicalBarrelFileName)) {
+                !fileHasReExportEdges(tsProgram, getImportGraph(tsProgram), canonicalBarrelFileName, canonicalFileName)) {
                 return null;
             }
             const specifiersBySourceFile = new Map();
@@ -248794,21 +248818,21 @@ const rule$K = createRule({
             CallExpression: checkRequireSelfImport,
             ExportAllDeclaration(node) {
                 checkImportCycle(node);
-                checkDeclarationSelfImport(node);
+                checkDeclarationModuleSpecifier(node);
             },
             ExportNamedDeclaration(node) {
                 checkImportCycle(node);
-                checkDeclarationSelfImport(node);
+                checkDeclarationModuleSpecifier(node);
                 checkNamedAsDefaultExport(node);
             },
             ImportDeclaration(node) {
                 checkImportCycle(node);
-                checkDeclarationSelfImport(node);
+                checkDeclarationModuleSpecifier(node);
                 collectDuplicateImport(node);
                 checkDefaultImport(node);
                 collectNamespaceImport(node);
             },
-            ImportExpression: checkDynamicSelfImport,
+            ImportExpression: checkDynamicImport,
             MemberExpression(node) {
                 checkNamedAsDefaultMemberExpression(node);
                 checkNamespaceMember(node);
@@ -248819,7 +248843,7 @@ const rule$K = createRule({
     },
     meta: {
         docs: {
-            description: 'Fast replacement for import/default, import/namespace, import/no-cycle, import/no-duplicates, import/no-named-as-default, import/no-named-as-default-member, and import/no-self-import checks',
+            description: 'Fast replacement for import/default, import/namespace, import/no-cycle, import/no-duplicates, import/no-named-as-default, import/no-named-as-default-member, import/no-self-import, and import/no-useless-path-segments checks',
         },
         fixable: 'code',
         messages: {
@@ -248830,6 +248854,7 @@ const rule$K = createRule({
             namedAsDefaultMember: 'Default import "{{defaultName}}" from "{{moduleSpecifier}}" also has a named export "{{memberName}}". Use a named import instead.',
             selfImport: 'Module imports itself.',
             unknownNamespaceMember: 'Namespace import "{{namespaceName}}" from "{{moduleSpecifier}}" has no exported member "{{memberName}}".',
+            uselessPathSegments: 'Useless path segments for "{{moduleSpecifier}}", should be "{{proposedPath}}".',
         },
         schema: [
             {
@@ -248863,6 +248888,10 @@ const rule$K = createRule({
                         description: 'Report imports, re-exports, dynamic imports, and require() calls that resolve to the current file. Defaults to true.',
                         type: 'boolean',
                     },
+                    checkUselessPathSegments: {
+                        description: 'Report relative imports, re-exports, and dynamic imports with unnecessary path segments or /index suffixes. Defaults to true.',
+                        type: 'boolean',
+                    },
                     ignoreExternalDefaultImports: {
                         description: 'Skip default import checks for modules resolved from external libraries. Defaults to true.',
                         type: 'boolean',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.503.0",
+  "version": "0.504.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "repository": {
     "type": "git",

package/rules/recommended/import-integrity.d.ts

@@ -1,5 +1,5 @@
 import { type TSESLint } from '@typescript-eslint/utils';
-type MessageId = 'duplicateImport' | 'importCycle' | 'missingDefaultExport' | 'namedAsDefault' | 'namedAsDefaultMember' | 'selfImport' | 'unknownNamespaceMember';
+type MessageId = 'duplicateImport' | 'importCycle' | 'missingDefaultExport' | 'namedAsDefault' | 'namedAsDefaultMember' | 'selfImport' | 'unknownNamespaceMember' | 'uselessPathSegments';
 type Options = [
     {
         checkCycles?: boolean;
@@ -9,6 +9,7 @@ type Options = [
         checkNamedAsDefaultMembers?: boolean;
         checkNamespaceMembers?: boolean;
         checkSelfImports?: boolean;
+        checkUselessPathSegments?: boolean;
         ignoreExternalDefaultImports?: boolean;
     }?
 ];