@taiga-ui/eslint-plugin-experience-next 0.502.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',
@@ -247753,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) {
@@ -248250,12 +248301,167 @@ 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 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;
@@ -248377,7 +248583,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 +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;
@@ -248414,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' ||
@@ -248529,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: [
@@ -248565,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',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.502.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;
     }?
 ];