@taiga-ui/eslint-plugin-experience-next 0.499.0 → 0.501.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 default import, namespace export, named-as-default, and import cycle 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.esm.js

@@ -247671,6 +247671,15 @@ 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,
+// so cycles where all usages are DI-only are safe and should not be reported.
+const ANGULAR_DI_FIRST_ARG_FUNCTIONS = new Set([
+    'contentChild',
+    'contentChildren',
+    'inject',
+    'viewChild',
+    'viewChildren',
+]);
 function createCanonicalFileName() {
     const useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
     return (fileName) => {
@@ -248094,6 +248103,43 @@ function getExportSpecifierName(name) {
 function hasNamedValueExport(exportNames, exportedName) {
     return exportedName !== 'default' && (exportNames?.has(exportedName) ?? false);
 }
+function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
+    const valueSpecifiers = node.specifiers.filter((specifier) => {
+        if (specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier ||
+            specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+            return true;
+        }
+        return specifier.importKind !== 'type';
+    });
+    if (valueSpecifiers.length === 0) {
+        return false;
+    }
+    for (const specifier of valueSpecifiers) {
+        const [variable] = sourceCode.getDeclaredVariables(specifier);
+        if (!variable || variable.references.length === 0) {
+            return false;
+        }
+        for (const ref of variable.references) {
+            const { identifier } = ref;
+            const parent = identifier.parent;
+            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);
+            const isRequiredCall = callee?.type === dist$3.AST_NODE_TYPES.MemberExpression &&
+                !callee.computed &&
+                callee.object.type === dist$3.AST_NODE_TYPES.Identifier &&
+                ANGULAR_DI_FIRST_ARG_FUNCTIONS.has(callee.object.name) &&
+                callee.property.type === dist$3.AST_NODE_TYPES.Identifier &&
+                callee.property.name === 'required';
+            if (parent.type !== dist$3.AST_NODE_TYPES.CallExpression ||
+                (!isDirectCall && !isRequiredCall) ||
+                parent.arguments[0] !== identifier) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
 const rule$K = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
@@ -248119,7 +248165,9 @@ const rule$K = createRule({
             }
             const graph = getImportGraph(tsProgram);
             const targetFileName = findCyclicTargetFileName(graph, currentFileName, moduleSpecifier);
-            if (!targetFileName) {
+            if (!targetFileName ||
+                (node.type === dist$3.AST_NODE_TYPES.ImportDeclaration &&
+                    isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode))) {
                 return;
             }
             context.report({
@@ -248222,6 +248270,42 @@ const rule$K = createRule({
                 variable,
             });
         }
+        function buildNamespaceToNamedFix(fixer, usage) {
+            const importDecl = usage.node.parent;
+            if (importDecl.specifiers.length !== 1) {
+                return null;
+            }
+            const memberNames = new Set();
+            const memberNodes = [];
+            for (const ref of usage.variable.references) {
+                const parent = ref.identifier.parent;
+                if (parent.type !== dist$3.AST_NODE_TYPES.MemberExpression ||
+                    parent.object !== ref.identifier ||
+                    parent.computed) {
+                    return null;
+                }
+                const memberName = getMemberExpressionPropertyName(parent);
+                if (!memberName || memberName === 'default') {
+                    return null;
+                }
+                memberNames.add(memberName);
+                memberNodes.push(parent);
+            }
+            if (memberNames.size === 0) {
+                return null;
+            }
+            const sourceText = sourceCode.getText(importDecl.source);
+            const hasSemi = sourceCode.getText(importDecl).endsWith(';');
+            const sortedMembers = [...memberNames].sort();
+            const newImportText = `import {${sortedMembers.join(', ')}} from ${sourceText}${hasSemi ? ';' : ''}`;
+            return [
+                fixer.replaceText(importDecl, newImportText),
+                ...memberNodes.flatMap((memberNode) => {
+                    const name = getMemberExpressionPropertyName(memberNode);
+                    return name ? [fixer.replaceText(memberNode, name)] : [];
+                }),
+            ];
+        }
         function checkNamespaceMember(node) {
             if (!checkNamespaceMembers ||
                 node.object.type !== dist$3.AST_NODE_TYPES.Identifier) {
@@ -248241,6 +248325,7 @@ const rule$K = createRule({
                     moduleSpecifier: usage.moduleSpecifier,
                     namespaceName: usage.node.local.name,
                 },
+                fix: (fixer) => buildNamespaceToNamedFix(fixer, usage),
                 messageId: 'unknownNamespaceMember',
                 node: node.property,
             });
@@ -248263,6 +248348,7 @@ const rule$K = createRule({
         docs: {
             description: 'Fast replacement for import/default, import/namespace, import/no-cycle, and import/no-named-as-default checks',
         },
+        fixable: 'code',
         messages: {
             importCycle: 'Import cycle detected: {{cyclePath}}.',
             missingDefaultExport: 'No default export found in "{{moduleSpecifier}}".',
@@ -250629,6 +250715,9 @@ function getCalleeName(node) {
 }
 function findParentStatement(node) {
     for (let current = node; current.parent; current = current.parent) {
+        if (isFunctionLike(current)) {
+            return null;
+        }
         if (current.parent.type === dist$3.AST_NODE_TYPES.BlockStatement ||
             current.parent.type === dist$3.AST_NODE_TYPES.Program) {
             return current;
@@ -250636,6 +250725,26 @@ function findParentStatement(node) {
     }
     return null;
 }
+function findConciseArrowAncestor(node) {
+    for (let current = node; current.parent; current = current.parent) {
+        const { parent } = current;
+        if (parent.type === dist$3.AST_NODE_TYPES.ArrowFunctionExpression &&
+            parent.body.type !== dist$3.AST_NODE_TYPES.BlockStatement) {
+            return parent;
+        }
+        if (isFunctionLike(parent)) {
+            return null;
+        }
+    }
+    return null;
+}
+function getArrowBodyIndent(arrowFn, sourceText) {
+    const arrowStart = arrowFn.range[0];
+    const lineStart = sourceText.lastIndexOf('\n', arrowStart - 1) + 1;
+    const textBeforeArrow = sourceText.slice(lineStart, arrowStart);
+    const outerIndent = /^(\s*)/.exec(textBeforeArrow)?.[1] ?? '';
+    return { innerIndent: `${outerIndent}    `, outerIndent };
+}
 function getStatementIndent(statement, sourceText) {
     const start = statement.range[0];
     const lineStart = sourceText.lastIndexOf('\n', start - 1) + 1;
@@ -250678,23 +250787,49 @@ const rule$r = createRule({
                 context.report({
                     data: { call: callText },
                     fix(fixer) {
+                        const varName = getCalleeName(firstCall);
                         const parentStatement = findParentStatement(node);
-                        if (!parentStatement) {
+                        if (parentStatement) {
+                            const indent = getStatementIndent(parentStatement, sourceCode.text);
+                            const fixes = [
+                                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));
+                            }
+                            return fixes;
+                        }
+                        const arrowFn = findConciseArrowAncestor(node);
+                        if (!arrowFn) {
                             return null;
                         }
-                        const varName = getCalleeName(firstCall);
-                        const indent = getStatementIndent(parentStatement, sourceCode.text);
-                        const fixes = [
-                            fixer.insertTextBefore(parentStatement, `const ${varName} = ${callText};\n\n${indent}`),
-                        ];
-                        for (const call of calls) {
+                        const arrowBody = arrowFn.body;
+                        const { innerIndent, outerIndent } = getArrowBodyIndent(arrowFn, sourceCode.text);
+                        const bodyText = sourceCode.getText(arrowBody);
+                        const bodyStart = arrowBody.range[0];
+                        const targets = calls
+                            .map((call) => {
                             const { parent } = call;
-                            const target = parent.type === dist$3.AST_NODE_TYPES.TSAsExpression
+                            return parent.type === dist$3.AST_NODE_TYPES.TSAsExpression
                                 ? parent
                                 : call;
-                            fixes.push(fixer.replaceText(target, varName));
+                        })
+                            .sort((a, b) => a.range[0] - b.range[0]);
+                        let replacedBody = '';
+                        let lastIndex = 0;
+                        for (const target of targets) {
+                            const start = target.range[0] - bodyStart;
+                            const end = target.range[1] - bodyStart;
+                            replacedBody += `${bodyText.slice(lastIndex, start)}${varName}`;
+                            lastIndex = end;
                         }
-                        return fixes;
+                        replacedBody += bodyText.slice(lastIndex);
+                        const newBody = `{\n${innerIndent}const ${varName} = ${callText};\n\n${innerIndent}return ${replacedBody};\n${outerIndent}}`;
+                        return [fixer.replaceText(arrowBody, newBody)];
                     },
                     messageId: 'noRepeatedSignalInConditional',
                     node: firstCall,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.499.0",
+  "version": "0.501.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "repository": {
     "type": "git",
@@ -46,7 +46,7 @@
     "eslint-plugin-jest": "^29.15.2",
     "eslint-plugin-package-json": "^0.91.1",
     "eslint-plugin-perfectionist": "^5.9.0",
-    "eslint-plugin-playwright": "^2.10.1",
+    "eslint-plugin-playwright": "^2.10.2",
     "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-regexp": "^3.1.0",