@taiga-ui/eslint-plugin-experience-next 0.501.0 → 0.503.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, and self-import 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,14 @@ 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", [({
             checkCycles?: boolean;
             checkDefaultImports?: boolean;
+            checkDuplicateImports?: boolean;
             checkNamedAsDefault?: boolean;
+            checkNamedAsDefaultMembers?: boolean;
             checkNamespaceMembers?: boolean;
+            checkSelfImports?: 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,19 +875,20 @@ 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-webpack-loader-syntax': 'error',
@@ -247667,8 +247668,8 @@ function getTypeAwareRuleContext(context) {
 
 const importGraphCacheByProgram = new WeakMap();
 const defaultExportCacheByProgram = new WeakMap();
+const fallbackResolutionByProgram = new WeakMap();
 const moduleExportNamesCache = new WeakMap();
-const resolutionStateByProgram = new WeakMap();
 const sourceFileCacheByProgram = new WeakMap();
 const codeFileExtensionRegExp = /\.[cm]?[jt]sx?$/;
 // Angular DI functions resolve tokens at instantiation time, not at module load time,
@@ -247689,8 +247690,38 @@ function createCanonicalFileName() {
             : resolvedFileName.toLowerCase();
     };
 }
-function getResolutionState(program) {
-    const cached = resolutionStateByProgram.get(program);
+function normalizeSlashes(fileName) {
+    return fileName.replaceAll('\\', '/');
+}
+function computeRelativeImportPath(fromFile, toFile) {
+    const relative = path.relative(path.dirname(fromFile), toFile);
+    const normalized = normalizeSlashes(relative).replace(codeFileExtensionRegExp, '');
+    return normalized.startsWith('.') ? normalized : `./${normalized}`;
+}
+function isProjectCodeFile(sourceFile) {
+    const normalizedFileName = normalizeSlashes(sourceFile.fileName);
+    return (!sourceFile.isDeclarationFile &&
+        codeFileExtensionRegExp.test(normalizedFileName) &&
+        !normalizedFileName.includes('/node_modules/'));
+}
+// Returns the module resolution cache that the TypeScript program itself populated during
+// compilation. Not part of the public ts.Program API but available at runtime on TS 4+.
+function getProgramResolutionCache(program) {
+    const record = program;
+    const getCache = record['getModuleResolutionCache'];
+    if (typeof getCache !== 'function') {
+        return null;
+    }
+    const cache = getCache.call(program);
+    if (cache === null ||
+        typeof cache !== 'object' ||
+        !('getOrCreateCacheForDirectory' in cache)) {
+        return null;
+    }
+    return cache;
+}
+function getFallbackResolution(program) {
+    const cached = fallbackResolutionByProgram.get(program);
     if (cached) {
         return cached;
     }
@@ -247699,23 +247730,22 @@ function getResolutionState(program) {
         compilerHost: ts.createCompilerHost(compilerOptions, true),
         resolutionCache: ts.createModuleResolutionCache(program.getCurrentDirectory(), (fileName) => fileName, compilerOptions),
     };
-    resolutionStateByProgram.set(program, state);
+    fallbackResolutionByProgram.set(program, state);
     return state;
 }
-function normalizeSlashes(fileName) {
-    return fileName.replaceAll('\\', '/');
-}
-function isProjectCodeFile(sourceFile) {
-    const normalizedFileName = normalizeSlashes(sourceFile.fileName);
-    return (!sourceFile.isDeclarationFile &&
-        codeFileExtensionRegExp.test(normalizedFileName) &&
-        !normalizedFileName.includes('/node_modules/'));
-}
 function resolveModule(program, containingFile, moduleSpecifier) {
-    const compilerOptions = program.getCompilerOptions();
-    const { compilerHost, resolutionCache } = getResolutionState(program);
-    const resolved = ts.resolveModuleName(moduleSpecifier, containingFile, compilerOptions, compilerHost, resolutionCache).resolvedModule ?? null;
-    return resolved;
+    // Prefer the program's own resolution cache (already populated during compilation)
+    // over running a fresh resolution, which requires file system access per unique
+    // (directory, module) pair and dominates lint time on cold starts.
+    const programCache = getProgramResolutionCache(program);
+    if (programCache) {
+        const fromCache = ts.resolveModuleNameFromCache(moduleSpecifier, containingFile, programCache);
+        if (fromCache !== undefined) {
+            return fromCache.resolvedModule ?? null;
+        }
+    }
+    const { compilerHost, resolutionCache } = getFallbackResolution(program);
+    return (ts.resolveModuleName(moduleSpecifier, containingFile, program.getCompilerOptions(), compilerHost, resolutionCache).resolvedModule ?? null);
 }
 function resolveModuleFileName(program, containingFile, moduleSpecifier) {
     const resolved = resolveModule(program, containingFile, moduleSpecifier);
@@ -247724,6 +247754,56 @@ function resolveModuleFileName(program, containingFile, moduleSpecifier) {
     }
     return resolved.resolvedFileName;
 }
+function getModuleSpecifierPath(moduleSpecifier) {
+    const queryIndex = moduleSpecifier.indexOf('?');
+    return queryIndex === -1 ? moduleSpecifier : moduleSpecifier.slice(0, queryIndex);
+}
+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) {
@@ -247802,7 +247882,11 @@ function buildDependenciesByFileName(program, canonicalFileName) {
             if (!projectFileNames.has(targetFileName)) {
                 continue;
             }
-            edges.push({ moduleSpecifier, targetFileName });
+            edges.push({
+                isImport: ts.isImportDeclaration(statement),
+                moduleSpecifier,
+                targetFileName,
+            });
         }
         dependenciesByFileName.set(fileName, edges);
     }
@@ -247877,6 +247961,32 @@ function collectSelfCycles(dependenciesByFileName) {
     }
     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) {
@@ -247886,10 +247996,12 @@ function getImportGraph(program) {
     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),
     };
     importGraphCacheByProgram.set(program, cache);
@@ -248103,6 +248215,34 @@ function getExportSpecifierName(name) {
 function hasNamedValueExport(exportNames, exportedName) {
     return exportedName !== 'default' && (exportNames?.has(exportedName) ?? false);
 }
+// Angular resolves the reference lazily (at instantiation, not at module load time)
+// in all of these contexts, so a cycle through them is safe at the ES module level.
+function isInAngularSafeContext(identifier) {
+    // TSESTree types parent as Node (non-optional), but the root node's parent is
+    // null at runtime. Widening to include null/undefined lets while(current) serve
+    // as the exit condition when traversal reaches the top of the tree.
+    let current = identifier.parent;
+    while (current) {
+        // Lazy evaluation: body runs only when the function/arrow is called.
+        if (current.type === dist$3.AST_NODE_TYPES.ArrowFunctionExpression ||
+            current.type === dist$3.AST_NODE_TYPES.FunctionExpression ||
+            current.type === dist$3.AST_NODE_TYPES.FunctionDeclaration) {
+            return true;
+        }
+        // Angular decorator metadata (@Component, @Directive, etc.) is processed
+        // after all modules in the cycle have finished loading.
+        if (current.type === dist$3.AST_NODE_TYPES.Decorator) {
+            return true;
+        }
+        // Non-static class field initializers run at instantiation time, not at
+        // module load time, so they do not create a load-time cycle edge.
+        if (current.type === dist$3.AST_NODE_TYPES.PropertyDefinition && !current.static) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
 function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     const valueSpecifiers = node.specifiers.filter((specifier) => {
         if (specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier ||
@@ -248114,6 +248254,10 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     if (valueSpecifiers.length === 0) {
         return false;
     }
+    // True if at least one reference is a genuine DI call or lives in a lazy/decorator
+    // context. Pure type-only references don't count: an import used only as a type
+    // should use `import type` and is not considered safe from a cycle perspective.
+    let hasSafeRuntimeUsage = false;
     for (const specifier of valueSpecifiers) {
         const [variable] = sourceCode.getDeclaredVariables(specifier);
         if (!variable || variable.references.length === 0) {
@@ -248122,6 +248266,17 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
         for (const ref of variable.references) {
             const { identifier } = ref;
             const parent = identifier.parent;
+            // Type-only references (e.g., param: Type<T>) don't create runtime
+            // dependencies. Skip without marking hasSafeRuntimeUsage — an import
+            // that is exclusively used as a type should use `import type` instead.
+            if (parent.type === dist$3.AST_NODE_TYPES.TSTypeReference) {
+                continue;
+            }
+            // References inside lazy/decorator contexts don't create load-time edges.
+            if (isInAngularSafeContext(identifier)) {
+                hasSafeRuntimeUsage = true;
+                continue;
+            }
             const callee = parent.type === dist$3.AST_NODE_TYPES.CallExpression ? parent.callee : null;
             const isDirectCall = callee?.type === dist$3.AST_NODE_TYPES.Identifier &&
                 ANGULAR_DI_FIRST_ARG_FUNCTIONS.has(callee.name);
@@ -248136,21 +248291,177 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
                 parent.arguments[0] !== identifier) {
                 return false;
             }
+            hasSafeRuntimeUsage = true;
         }
     }
-    return true;
+    return hasSafeRuntimeUsage;
 }
 const rule$K = createRule({
     create(context) {
         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 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 checkDeclarationSelfImport(node) {
+            if (!node.source || typeof node.source.value !== 'string') {
+                return;
+            }
+            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 checkDynamicSelfImport(node) {
+            const { source } = node;
+            if (source.type !== dist$3.AST_NODE_TYPES.Literal ||
+                typeof source.value !== 'string') {
+                return;
+            }
+            checkSelfImport(source.value, source);
+        }
         function checkImportCycle(node) {
             if (!checkCycles) {
                 return;
@@ -248165,21 +248476,116 @@ const rule$K = createRule({
             }
             const graph = getImportGraph(tsProgram);
             const targetFileName = findCyclicTargetFileName(graph, currentFileName, moduleSpecifier);
-            if (!targetFileName ||
-                (node.type === dist$3.AST_NODE_TYPES.ImportDeclaration &&
-                    isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode))) {
+            if (!targetFileName) {
                 return;
             }
-            context.report({
-                data: {
-                    cyclePath: formatCyclePath(graph, currentFileName, targetFileName, context.cwd),
-                },
-                messageId: 'importCycle',
-                node: sourceNode,
-            });
+            const cyclePath = formatCyclePath(graph, currentFileName, targetFileName, 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,
+                // always report (the fix breaks the cycle). Otherwise, suppress when
+                // all usages are Angular-DI-safe (inject, class fields, etc.).
+                const replacement = computeCycleBreakingReplacement(node);
+                if (!replacement &&
+                    isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode)) {
+                    return;
+                }
+                context.report({
+                    data: { cyclePath },
+                    fix: replacement
+                        ? (fixer) => [fixer.replaceText(node, replacement)]
+                        : undefined,
+                    messageId: 'importCycle',
+                    node: sourceNode,
+                });
+            }
+            else {
+                // For re-export nodes (export * from / export {x} from), suppress the
+                // error when the same SCC already 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) {
+                    return;
+                }
+                context.report({
+                    data: { cyclePath },
+                    messageId: 'importCycle',
+                    node: sourceNode,
+                });
+            }
+        }
+        function computeCycleBreakingReplacement(node) {
+            // Only named imports can be safely redirected to their source file
+            if (node.specifiers.some((s) => s.type !== dist$3.AST_NODE_TYPES.ImportSpecifier)) {
+                return null;
+            }
+            const barrelFileName = resolveModuleFileName(tsProgram, context.filename, node.source.value);
+            const canonicalBarrelFileName = barrelFileName
+                ? canonicalFileName(barrelFileName)
+                : null;
+            // 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)) {
+                return null;
+            }
+            const specifiersBySourceFile = new Map();
+            for (const specifier of node.specifiers) {
+                if (specifier.type !== dist$3.AST_NODE_TYPES.ImportSpecifier) {
+                    return null;
+                }
+                const tsSpecifier = esTreeNodeToTSNodeMap.get(specifier);
+                if (!ts.isImportSpecifier(tsSpecifier)) {
+                    return null;
+                }
+                const localSymbol = checker.getSymbolAtLocation(tsSpecifier.name);
+                if (!localSymbol) {
+                    return null;
+                }
+                const originalSymbol = getAliasedSymbolIfNeeded(checker, localSymbol);
+                const { declarations } = originalSymbol;
+                const firstDeclaration = declarations?.[0];
+                if (!firstDeclaration) {
+                    return null;
+                }
+                const sourceFile = firstDeclaration.getSourceFile();
+                if (!isProjectCodeFile(sourceFile)) {
+                    return null;
+                }
+                const sourceFilePath = sourceFile.fileName;
+                // Symbol is defined directly in the barrel — no shorter path exists
+                if (canonicalBarrelFileName === canonicalFileName(sourceFilePath)) {
+                    return null;
+                }
+                const importedName = tsSpecifier.propertyName?.text ?? tsSpecifier.name.text;
+                const localName = tsSpecifier.name.text;
+                const typePrefix = specifier.importKind === 'type' ? 'type ' : '';
+                const specText = importedName === localName
+                    ? `${typePrefix}${importedName}`
+                    : `${typePrefix}${importedName} as ${localName}`;
+                const group = specifiersBySourceFile.get(sourceFilePath) ?? [];
+                group.push(specText);
+                specifiersBySourceFile.set(sourceFilePath, group);
+            }
+            if (specifiersBySourceFile.size === 0) {
+                return null;
+            }
+            const semi = sourceCode.getText(node).endsWith(';') ? ';' : '';
+            const quote = node.source.raw[0] ?? "'";
+            const importPrefix = node.importKind === 'type' ? 'import type' : 'import';
+            const newImports = [];
+            for (const [sourceFilePath, names] of specifiersBySourceFile) {
+                const relPath = computeRelativeImportPath(context.filename, sourceFilePath);
+                newImports.push(`${importPrefix} {${names.join(', ')}} from ${quote}${relPath}${quote}${semi}`);
+            }
+            return newImports.join('\n');
         }
         function checkDefaultImport(node) {
-            if ((!checkDefaultImports && !checkNamedAsDefault) ||
+            if ((!checkDefaultImports &&
+                !checkNamedAsDefault &&
+                !checkNamedAsDefaultMembers) ||
                 node.importKind === 'type') {
                 return;
             }
@@ -248206,6 +248612,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;
@@ -248216,6 +248633,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' ||
@@ -248331,28 +248791,44 @@ const rule$K = createRule({
             });
         }
         return {
-            ExportAllDeclaration: checkImportCycle,
+            CallExpression: checkRequireSelfImport,
+            ExportAllDeclaration(node) {
+                checkImportCycle(node);
+                checkDeclarationSelfImport(node);
+            },
             ExportNamedDeclaration(node) {
                 checkImportCycle(node);
+                checkDeclarationSelfImport(node);
                 checkNamedAsDefaultExport(node);
             },
             ImportDeclaration(node) {
                 checkImportCycle(node);
+                checkDeclarationSelfImport(node);
+                collectDuplicateImport(node);
                 checkDefaultImport(node);
                 collectNamespaceImport(node);
             },
-            MemberExpression: checkNamespaceMember,
+            ImportExpression: checkDynamicSelfImport,
+            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, and import/no-self-import 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}}".',
         },
         schema: [
@@ -248367,14 +248843,26 @@ 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',
+                    },
                     ignoreExternalDefaultImports: {
                         description: 'Skip default import checks for modules resolved from external libraries. Defaults to true.',
                         type: 'boolean',
@@ -250700,6 +251188,19 @@ function isNullableCallType(call, checker, nodeMap) {
         return false;
     }
 }
+function getTargetNode(call) {
+    const { parent } = call;
+    if (parent.type === dist$3.AST_NODE_TYPES.TSAsExpression) {
+        return parent;
+    }
+    if (parent.type === dist$3.AST_NODE_TYPES.UnaryExpression &&
+        parent.operator === '!' &&
+        parent.parent.type === dist$3.AST_NODE_TYPES.UnaryExpression &&
+        parent.parent.operator === '!') {
+        return parent.parent;
+    }
+    return call;
+}
 function getCalleeName(node) {
     const { callee } = node;
     if (callee.type === dist$3.AST_NODE_TYPES.MemberExpression &&
@@ -250795,11 +251296,7 @@ const rule$r = createRule({
                                 fixer.insertTextBefore(parentStatement, `const ${varName} = ${callText};\n\n${indent}`),
                             ];
                             for (const call of calls) {
-                                const { parent } = call;
-                                const target = parent.type === dist$3.AST_NODE_TYPES.TSAsExpression
-                                    ? parent
-                                    : call;
-                                fixes.push(fixer.replaceText(target, varName));
+                                fixes.push(fixer.replaceText(getTargetNode(call), varName));
                             }
                             return fixes;
                         }
@@ -250812,12 +251309,7 @@ const rule$r = createRule({
                         const bodyText = sourceCode.getText(arrowBody);
                         const bodyStart = arrowBody.range[0];
                         const targets = calls
-                            .map((call) => {
-                            const { parent } = call;
-                            return parent.type === dist$3.AST_NODE_TYPES.TSAsExpression
-                                ? parent
-                                : call;
-                        })
+                            .map(getTargetNode)
                             .sort((a, b) => a.range[0] - b.range[0]);
                         let replacedBody = '';
                         let lastIndex = 0;
@@ -250829,7 +251321,13 @@ const rule$r = createRule({
                         }
                         replacedBody += bodyText.slice(lastIndex);
                         const newBody = `{\n${innerIndent}const ${varName} = ${callText};\n\n${innerIndent}return ${replacedBody};\n${outerIndent}}`;
-                        return [fixer.replaceText(arrowBody, newBody)];
+                        const bodyRangeStart = arrowBody.range[0];
+                        const textBeforeBody = sourceCode.text.slice(0, bodyRangeStart);
+                        const whitespaceBeforeBody = /\s*$/.exec(textBeforeBody)?.[0] ?? '';
+                        const replaceFrom = bodyRangeStart - whitespaceBeforeBody.length;
+                        return [
+                            fixer.replaceTextRange([replaceFrom, arrowBody.range[1]], ` ${newBody}`),
+                        ];
                     },
                     messageId: 'noRepeatedSignalInConditional',
                     node: firstCall,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.501.0",
+  "version": "0.503.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,14 @@
 import { type TSESLint } from '@typescript-eslint/utils';
-type MessageId = 'importCycle' | 'missingDefaultExport' | 'namedAsDefault' | 'unknownNamespaceMember';
+type MessageId = 'duplicateImport' | 'importCycle' | 'missingDefaultExport' | 'namedAsDefault' | 'namedAsDefaultMember' | 'selfImport' | 'unknownNamespaceMember';
 type Options = [
     {
         checkCycles?: boolean;
         checkDefaultImports?: boolean;
+        checkDuplicateImports?: boolean;
         checkNamedAsDefault?: boolean;
+        checkNamedAsDefaultMembers?: boolean;
         checkNamespaceMembers?: boolean;
+        checkSelfImports?: boolean;
         ignoreExternalDefaultImports?: boolean;
     }?
 ];