@taiga-ui/eslint-plugin-experience-next 0.502.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 default import, namespace export, named-as-default, and import cycle 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,11 +38,15 @@ declare const plugin: {
         'html-logical-properties': import("eslint").Rule.RuleModule & {
             name: string;
         };
-        'import-integrity': import("@typescript-eslint/utils/ts-eslint").RuleModule<"importCycle" | "missingDefaultExport" | "namedAsDefault" | "unknownNamespaceMember", [({
+        'import-integrity': import("@typescript-eslint/utils/ts-eslint").RuleModule<"duplicateImport" | "importCycle" | "missingDefaultExport" | "namedAsDefault" | "namedAsDefaultMember" | "selfImport" | "unknownNamespaceMember" | "uselessPathSegments", [({
             checkCycles?: boolean;
             checkDefaultImports?: boolean;
+            checkDuplicateImports?: boolean;
             checkNamedAsDefault?: boolean;
+            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

@@ -867,7 +867,7 @@ var recommended = defineConfig([
                 'error',
                 {
                     methods: 'above',
-                    printWidth: 120,
+                    printWidth: 90,
                     properties: 'above',
                 },
             ],
@@ -875,21 +875,22 @@ var recommended = defineConfig([
             'func-style': ['error', 'declaration', { allowArrowFunctions: true }],
             'guard-for-in': 'error',
             'import/consistent-type-specifier-style': ['error', 'prefer-inline'],
-            'import/default': 'off',
+            'import/default': 'off', // Covered by @taiga-ui/experience-next/import-integrity.
             'import/enforce-node-protocol-usage': ['error', 'always'],
             'import/export': 'off',
             'import/first': 'error',
-            'import/namespace': 'off',
+            'import/namespace': 'off', // Covered by @taiga-ui/experience-next/import-integrity.
             'import/newline-after-import': ['error', { count: 1 }],
             'import/no-absolute-path': 'error',
-            'import/no-cycle': 'off',
-            'import/no-duplicates': ['error', { 'prefer-inline': true }],
+            'import/no-cycle': 'off', // Covered by @taiga-ui/experience-next/import-integrity.
+            'import/no-duplicates': 'off', // Covered by @taiga-ui/experience-next/import-integrity.
             'import/no-extraneous-dependencies': 'off',
             'import/no-mutable-exports': 'error',
-            'import/no-named-as-default': 'off',
-            'import/no-self-import': 'error',
+            'import/no-named-as-default': 'off', // Covered by @taiga-ui/experience-next/import-integrity.
+            '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',
@@ -247753,6 +247754,84 @@ function resolveModuleFileName(program, containingFile, moduleSpecifier) {
     }
     return resolved.resolvedFileName;
 }
+function splitModuleSpecifierQuery(moduleSpecifier) {
+    const queryIndex = moduleSpecifier.indexOf('?');
+    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);
+    const resolved = resolveModule(program, containingFile, moduleSpecifierPath);
+    if (!resolved) {
+        return moduleSpecifier;
+    }
+    const queryIndex = moduleSpecifier.indexOf('?');
+    const query = queryIndex === -1 ? '' : moduleSpecifier.slice(queryIndex);
+    return `${canonicalFileName(resolved.resolvedFileName)}${query}`;
+}
+function getDefaultImportName(node) {
+    const defaultImport = node.specifiers.find((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier);
+    return defaultImport?.local.name ?? null;
+}
+function hasNamespaceImport(node) {
+    return node.specifiers.some((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier);
+}
+function hasTypeOnlyDefaultImport(node) {
+    return node.importKind === 'type' && getDefaultImportName(node) !== null;
+}
+function hasImportAttributes(node) {
+    const record = node;
+    const attributes = record['attributes'];
+    const assertions = record['assertions'];
+    return ((Array.isArray(attributes) && attributes.length > 0) ||
+        (Array.isArray(assertions) && assertions.length > 0));
+}
+function hasProblematicImportComments(node, sourceCode) {
+    const text = sourceCode.getText(node);
+    return (text.includes('/*') ||
+        text.includes('//') ||
+        sourceCode
+            .getCommentsBefore(node)
+            .some((comment) => comment.loc.end.line >= node.loc.start.line - 1) ||
+        sourceCode
+            .getCommentsAfter(node)
+            .some((comment) => comment.loc.start.line === node.loc.end.line));
+}
+function getNamedSpecifierText(node, specifier, sourceCode) {
+    const text = sourceCode.getText(specifier);
+    const isTypeOnly = node.importKind === 'type' || specifier.importKind === 'type';
+    return isTypeOnly && !text.trimStart().startsWith('type ') ? `type ${text}` : text;
+}
+function getNamedSpecifierKey(text) {
+    return text.trim().replace(/^type\s+/, '');
+}
 function importDeclarationHasRuntimeEdge(node) {
     const importClause = node.importClause;
     if (!importClause) {
@@ -247809,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;
@@ -248041,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 resolvedFileName = resolveModuleFileName(program, sourceFile.fileName, moduleSpecifier);
+        if (!resolvedFileName) {
             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 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
@@ -248250,12 +248254,240 @@ const rule$K = createRule({
         const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
         const checkCycles = context.options[0]?.checkCycles ?? true;
         const checkDefaultImports = context.options[0]?.checkDefaultImports ?? true;
+        const checkDuplicateImports = context.options[0]?.checkDuplicateImports ?? true;
         const checkNamedAsDefault = context.options[0]?.checkNamedAsDefault ?? true;
+        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);
+        const defaultImports = new Map();
+        const duplicateImportMaps = {
+            importsByModule: new Map(),
+            namespaceImportsByModule: new Map(),
+        };
         const namespaceImports = new Map();
+        function getDuplicateImportMap(node) {
+            return hasNamespaceImport(node)
+                ? duplicateImportMaps.namespaceImportsByModule
+                : duplicateImportMaps.importsByModule;
+        }
+        function collectDuplicateImport(node) {
+            if (!checkDuplicateImports) {
+                return;
+            }
+            const moduleKey = resolveModuleKey(tsProgram, context.filename, node.source.value, canonicalFileName);
+            const importsByModule = getDuplicateImportMap(node);
+            const imports = importsByModule.get(moduleKey) ?? [];
+            imports.push(node);
+            importsByModule.set(moduleKey, imports);
+        }
+        function buildImportRemovalFix(fixer, node) {
+            const [start, end] = node.range;
+            const lineStart = sourceCode.text.lastIndexOf('\n', start - 1) + 1;
+            const removeStart = /^\s*$/.test(sourceCode.text.slice(lineStart, start))
+                ? lineStart
+                : start;
+            const removeEnd = sourceCode.text[end] === '\n' ? end + 1 : end;
+            return [fixer.removeRange([removeStart, removeEnd])];
+        }
+        function buildDuplicateImportFix(fixer, first, rest) {
+            const nodes = [first, ...rest];
+            if (nodes.some((node) => hasNamespaceImport(node) ||
+                hasTypeOnlyDefaultImport(node) ||
+                hasImportAttributes(node) ||
+                hasProblematicImportComments(node, sourceCode))) {
+                return null;
+            }
+            const defaultNames = new Set(nodes.flatMap((node) => {
+                const name = getDefaultImportName(node);
+                return name ? [name] : [];
+            }));
+            if (defaultNames.size > 1) {
+                return null;
+            }
+            const namedSpecifiersByKey = new Map();
+            for (const node of nodes) {
+                for (const specifier of node.specifiers) {
+                    if (specifier.type !== dist$3.AST_NODE_TYPES.ImportSpecifier) {
+                        continue;
+                    }
+                    const text = getNamedSpecifierText(node, specifier, sourceCode).trim();
+                    const key = getNamedSpecifierKey(text);
+                    const existing = namedSpecifiersByKey.get(key);
+                    const isTypeOnly = text.startsWith('type ');
+                    if (!existing || (existing.startsWith('type ') && !isTypeOnly)) {
+                        namedSpecifiersByKey.set(key, text);
+                    }
+                }
+            }
+            const namedSpecifiers = [...namedSpecifiersByKey.values()];
+            const [defaultName = null] = defaultNames;
+            const bindings = [
+                ...(defaultName ? [defaultName] : []),
+                ...(namedSpecifiers.length > 0
+                    ? [`{${namedSpecifiers.join(', ')}}`]
+                    : []),
+            ];
+            const sourceText = sourceCode.getText(first.source);
+            const semi = sourceCode.getText(first).endsWith(';') ? ';' : '';
+            const replacement = bindings.length === 0
+                ? `import ${sourceText}${semi}`
+                : `import ${bindings.join(', ')} from ${sourceText}${semi}`;
+            return [
+                fixer.replaceText(first, replacement),
+                ...rest.flatMap((node) => buildImportRemovalFix(fixer, node)),
+            ];
+        }
+        function reportDuplicateImports(importsByModule) {
+            for (const nodes of importsByModule.values()) {
+                if (nodes.length < 2) {
+                    continue;
+                }
+                const [first, ...rest] = nodes;
+                if (!first) {
+                    continue;
+                }
+                const moduleSpecifier = first.source.value;
+                context.report({
+                    data: { moduleSpecifier },
+                    fix: (fixer) => buildDuplicateImportFix(fixer, first, rest),
+                    messageId: 'duplicateImport',
+                    node: first.source,
+                });
+                for (const node of rest) {
+                    context.report({
+                        data: { moduleSpecifier },
+                        messageId: 'duplicateImport',
+                        node: node.source,
+                    });
+                }
+            }
+        }
+        function reportAllDuplicateImports() {
+            if (!checkDuplicateImports) {
+                return;
+            }
+            reportDuplicateImports(duplicateImportMaps.importsByModule);
+            reportDuplicateImports(duplicateImportMaps.namespaceImportsByModule);
+        }
+        function checkSelfImport(moduleSpecifier, node) {
+            if (!checkSelfImports ||
+                context.filename === '<text>' ||
+                moduleSpecifier.includes('?')) {
+                return;
+            }
+            const resolved = resolveModule(tsProgram, context.filename, getModuleSpecifierPath(moduleSpecifier));
+            if (!resolved ||
+                canonicalFileName(resolved.resolvedFileName) !== currentFileName) {
+                return;
+            }
+            context.report({
+                messageId: 'selfImport',
+                node,
+            });
+        }
+        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) {
+            if (node.callee.type !== dist$3.AST_NODE_TYPES.Identifier ||
+                node.callee.name !== 'require' ||
+                node.arguments.length !== 1) {
+                return;
+            }
+            const [moduleSpecifier] = node.arguments;
+            if (moduleSpecifier?.type !== dist$3.AST_NODE_TYPES.Literal ||
+                typeof moduleSpecifier.value !== 'string') {
+                return;
+            }
+            checkSelfImport(moduleSpecifier.value, moduleSpecifier);
+        }
+        function checkDynamicImport(node) {
+            const { source } = node;
+            if (!isStringLiteral(source)) {
+                return;
+            }
+            checkUselessPathSegments(source);
+            checkSelfImport(source.value, source);
+        }
         function checkImportCycle(node) {
             if (!checkCycles) {
                 return;
@@ -248269,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,
@@ -248295,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({
@@ -248322,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();
@@ -248377,7 +248607,9 @@ const rule$K = createRule({
             return newImports.join('\n');
         }
         function checkDefaultImport(node) {
-            if ((!checkDefaultImports && !checkNamedAsDefault) ||
+            if ((!checkDefaultImports &&
+                !checkNamedAsDefault &&
+                !checkNamedAsDefaultMembers) ||
                 node.importKind === 'type') {
                 return;
             }
@@ -248404,6 +248636,17 @@ const rule$K = createRule({
                 return;
             }
             const exportNames = getNamespaceImportExportNames(checker, esTreeNodeToTSNodeMap, node);
+            if (checkNamedAsDefaultMembers && exportNames) {
+                const [variable] = sourceCode.getDeclaredVariables(defaultImport);
+                if (variable) {
+                    defaultImports.set(defaultImport.local.name, {
+                        exportNames,
+                        moduleSpecifier,
+                        node: defaultImport,
+                        variable,
+                    });
+                }
+            }
             if (!checkNamedAsDefault ||
                 !hasNamedValueExport(exportNames, defaultImport.local.name)) {
                 return;
@@ -248414,6 +248657,49 @@ const rule$K = createRule({
                 node: defaultImport,
             });
         }
+        function reportNamedAsDefaultMember(defaultImportIdentifier, memberName, reportNode) {
+            if (!checkNamedAsDefaultMembers || !memberName || memberName === 'default') {
+                return;
+            }
+            const usage = defaultImports.get(defaultImportIdentifier.name);
+            if (!usage ||
+                !hasNamedValueExport(usage.exportNames, memberName) ||
+                getResolvedVariable(sourceCode, defaultImportIdentifier) !==
+                    usage.variable) {
+                return;
+            }
+            context.report({
+                data: {
+                    defaultName: usage.node.local.name,
+                    memberName,
+                    moduleSpecifier: usage.moduleSpecifier,
+                },
+                messageId: 'namedAsDefaultMember',
+                node: reportNode,
+            });
+        }
+        function checkNamedAsDefaultMemberExpression(node) {
+            if (!checkNamedAsDefaultMembers ||
+                defaultImports.size === 0 ||
+                node.object.type !== dist$3.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            reportNamedAsDefaultMember(node.object, getMemberExpressionPropertyName(node), node.property);
+        }
+        function checkNamedAsDefaultMemberDestructuring(node) {
+            if (!checkNamedAsDefaultMembers ||
+                defaultImports.size === 0 ||
+                node.id.type !== dist$3.AST_NODE_TYPES.ObjectPattern ||
+                node.init?.type !== dist$3.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            for (const property of node.id.properties) {
+                if (property.type !== dist$3.AST_NODE_TYPES.Property) {
+                    continue;
+                }
+                reportNamedAsDefaultMember(node.init, getObjectPropertyName(property), property.key);
+            }
+        }
         function checkNamedAsDefaultExport(node) {
             if (!checkNamedAsDefault ||
                 node.exportKind === 'type' ||
@@ -248529,29 +248815,46 @@ const rule$K = createRule({
             });
         }
         return {
-            ExportAllDeclaration: checkImportCycle,
+            CallExpression: checkRequireSelfImport,
+            ExportAllDeclaration(node) {
+                checkImportCycle(node);
+                checkDeclarationModuleSpecifier(node);
+            },
             ExportNamedDeclaration(node) {
                 checkImportCycle(node);
+                checkDeclarationModuleSpecifier(node);
                 checkNamedAsDefaultExport(node);
             },
             ImportDeclaration(node) {
                 checkImportCycle(node);
+                checkDeclarationModuleSpecifier(node);
+                collectDuplicateImport(node);
                 checkDefaultImport(node);
                 collectNamespaceImport(node);
             },
-            MemberExpression: checkNamespaceMember,
+            ImportExpression: checkDynamicImport,
+            MemberExpression(node) {
+                checkNamedAsDefaultMemberExpression(node);
+                checkNamespaceMember(node);
+            },
+            'Program:exit': reportAllDuplicateImports,
+            VariableDeclarator: checkNamedAsDefaultMemberDestructuring,
         };
     },
     meta: {
         docs: {
-            description: 'Fast replacement for import/default, import/namespace, import/no-cycle, and import/no-named-as-default 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: {
+            duplicateImport: '"{{moduleSpecifier}}" imported multiple times.',
             importCycle: 'Import cycle detected: {{cyclePath}}.',
             missingDefaultExport: 'No default export found in "{{moduleSpecifier}}".',
             namedAsDefault: 'Using exported name "{{name}}" as identifier for default export.',
+            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: [
             {
@@ -248565,14 +248868,30 @@ const rule$K = createRule({
                         description: 'Report default imports from modules without a default export. Defaults to true.',
                         type: 'boolean',
                     },
+                    checkDuplicateImports: {
+                        description: 'Report repeated import declarations for the same resolved module. Defaults to true.',
+                        type: 'boolean',
+                    },
                     checkNamedAsDefault: {
                         description: 'Report default imports and default re-exports named after a named export from the same module. Defaults to true.',
                         type: 'boolean',
                     },
+                    checkNamedAsDefaultMembers: {
+                        description: 'Report property access or destructuring of default imports when the property name is a named export from the same module. Defaults to true.',
+                        type: 'boolean',
+                    },
                     checkNamespaceMembers: {
                         description: 'Report static namespace import member accesses that are not exported by the imported module. Defaults to true.',
                         type: 'boolean',
                     },
+                    checkSelfImports: {
+                        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.502.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,11 +1,15 @@
 import { type TSESLint } from '@typescript-eslint/utils';
-type MessageId = 'importCycle' | 'missingDefaultExport' | 'namedAsDefault' | 'unknownNamespaceMember';
+type MessageId = 'duplicateImport' | 'importCycle' | 'missingDefaultExport' | 'namedAsDefault' | 'namedAsDefaultMember' | 'selfImport' | 'unknownNamespaceMember' | 'uselessPathSegments';
 type Options = [
     {
         checkCycles?: boolean;
         checkDefaultImports?: boolean;
+        checkDuplicateImports?: boolean;
         checkNamedAsDefault?: boolean;
+        checkNamedAsDefaultMembers?: boolean;
         checkNamespaceMembers?: boolean;
+        checkSelfImports?: boolean;
+        checkUselessPathSegments?: boolean;
         ignoreExternalDefaultImports?: boolean;
     }?
 ];