@taiga-ui/eslint-plugin-experience-next 0.508.0 → 0.509.0

package/README.md

@@ -127,61 +127,3 @@ from third-party plugins. The exact severities and file globs live in
 | [single-line-variable-spacing](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/single-line-variable-spacing.md)                                       | Group consecutive single-line variables and separate multiline ones with a blank line               | ✅  | 🔧  |     |
 | [standalone-imports-sort](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/standalone-imports-sort.md)                                                 | Auto sort names inside Angular decorators                                                           | ✅  | 🔧  |     |
 | [strict-tui-doc-example](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/strict-tui-doc-example.md)                                                   | If you use the addon-doc, there will be a hint that you are importing something incorrectly         |     | 🔧  |     |
-
-## no-empty-style-metadata
-
-Disallows empty Angular component style metadata. The rule reports empty string and empty template literal values for
-`styles` and `styleUrl`, plus `styleUrls: []`, because they do not add component styles and can be safely removed.
-
-```ts
-// ❌ error
-@Component({
-  selector: 'app-root',
-  templateUrl: './app.component.html',
-  styles: ``,
-  styleUrl: '',
-  styleUrls: [],
-})
-
-// ✅ after autofix
-@Component({
-  selector: 'app-root',
-  templateUrl: './app.component.html',
-})
-```
-
-## prefer-conditional-return
-
-Prefer a single conditional return when an `if` statement returns one expression and the immediately following statement
-returns the fallback expression. The rule skips branches with comments, `else`, empty returns, intervening statements,
-or a return expression that is already a conditional expression.
-
-```ts
-// ❌ error
-if (index < count) {
-  return {value: index++, done: false};
-}
-
-return {value: undefined, done: true};
-
-// ✅ after autofix
-return index < count ? {value: index++, done: false} : {value: undefined, done: true};
-```
-
-```ts
-// not changed: if branch return is already conditional
-if (condition) {
-  return first ? second : third;
-}
-
-return fallback;
-```
-
-```ts
-// not changed: fallback return is already conditional
-if (condition) {
-  return value;
-}
-
-return first ? second : third;
-```

package/index.esm.js

@@ -532,6 +532,7 @@ var recommended = defineConfig([
     progress.configs['recommended-ci'],
     {
         ignores: [
+            '**/tests-results/**',
             '**/tests-report/**',
             '**/snapshots/**',
             '**/test-results/**',
@@ -247942,6 +247943,9 @@ function sourceFileHasDefaultExport(sourceFile) {
         hasRuntimeDefaultModifier(statement) ||
         (ts.isExportDeclaration(statement) && exportsDefaultSpecifier(statement)));
 }
+function isJsonModuleFileName(fileName) {
+    return path.extname(fileName).toLowerCase() === '.json';
+}
 function hasDefaultExport(program, fileName) {
     const canonicalFileName = createCanonicalFileName();
     const normalizedFileName = canonicalFileName(fileName);
@@ -248401,7 +248405,8 @@ const rule$N = createRule({
                 : null;
         }
         function getIndexPathReplacement(moduleSpecifierPath, canonicalResolvedFileName) {
-            if (!isIndexModulePath(moduleSpecifierPath)) {
+            if (codeFileExtensionRegExp.test(moduleSpecifierPath) ||
+                !isIndexModulePath(moduleSpecifierPath)) {
                 return null;
             }
             const parentDirectory = path.posix.dirname(moduleSpecifierPath);
@@ -248618,7 +248623,8 @@ const rule$N = createRule({
             const moduleSpecifier = node.source.value;
             const resolved = resolveModule(tsProgram, context.filename, moduleSpecifier);
             if (!resolved ||
-                (resolved.isExternalLibraryImport && ignoreExternalDefaultImports)) {
+                (resolved.isExternalLibraryImport && ignoreExternalDefaultImports) ||
+                isJsonModuleFileName(resolved.resolvedFileName)) {
                 return;
             }
             const hasResolvedDefaultExport = hasDefaultExport(tsProgram, resolved.resolvedFileName);
@@ -248709,6 +248715,7 @@ const rule$N = createRule({
             const resolved = resolveModule(tsProgram, context.filename, moduleSpecifier);
             if (!resolved ||
                 (resolved.isExternalLibraryImport && ignoreExternalDefaultImports) ||
+                isJsonModuleFileName(resolved.resolvedFileName) ||
                 !hasDefaultExport(tsProgram, resolved.resolvedFileName)) {
                 return;
             }
@@ -248734,7 +248741,11 @@ const rule$N = createRule({
                 return;
             }
             const namespaceImport = node.specifiers.find((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier);
-            if (!namespaceImport) {
+            if (!namespaceImport || typeof node.source.value !== 'string') {
+                return;
+            }
+            const resolved = resolveModule(tsProgram, context.filename, node.source.value);
+            if (resolved && isJsonModuleFileName(resolved.resolvedFileName)) {
                 return;
             }
             const exportNames = getNamespaceImportExportNames(checker, esTreeNodeToTSNodeMap, node);
@@ -251380,6 +251391,34 @@ function getStatementIndent$1(statement, sourceText) {
     const before = sourceText.slice(lineStart, start);
     return /^\s*$/.test(before) ? before : '';
 }
+function isAstNode(value) {
+    if (!value || typeof value !== 'object' || !('type' in value)) {
+        return false;
+    }
+    const { type } = value;
+    return typeof type === 'string';
+}
+function getParent(node) {
+    const maybeNode = node;
+    if (!maybeNode || typeof maybeNode !== 'object' || !('parent' in maybeNode)) {
+        return null;
+    }
+    const { parent } = maybeNode;
+    return isAstNode(parent) ? parent : null;
+}
+function isOptionalMemberReceiver(call) {
+    let current = call;
+    let parent = getParent(current);
+    while (parent?.type === dist$3.AST_NODE_TYPES.TSAsExpression ||
+        parent?.type === dist$3.AST_NODE_TYPES.TSNonNullExpression ||
+        parent?.type === dist$3.AST_NODE_TYPES.TSTypeAssertion) {
+        current = parent;
+        parent = getParent(current);
+    }
+    return (parent?.type === dist$3.AST_NODE_TYPES.MemberExpression &&
+        parent.object === current &&
+        parent.optional);
+}
 const rule$t = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
@@ -251396,6 +251435,7 @@ const rule$t = createRule({
                     return false;
                 }
                 if (child.type === dist$3.AST_NODE_TYPES.CallExpression &&
+                    !isOptionalMemberReceiver(child) &&
                     isSignalReadCall(child, checker, signalNodeMap) &&
                     isNullableCallType(child, checker, signalNodeMap)) {
                     const text = sourceCode.getText(child);
@@ -252872,6 +252912,18 @@ const rule$m = createRule({
 });
 
 const MAX_INLINE_CONDITIONAL_RETURN_LENGTH = 90;
+const BOOLEAN_BINARY_OPERATORS = new Set([
+    '!=',
+    '!==',
+    '<',
+    '<=',
+    '==',
+    '===',
+    '>',
+    '>=',
+    'in',
+    'instanceof',
+]);
 function getReturnStatement(statement) {
     if (statement.type === dist$3.AST_NODE_TYPES.ReturnStatement) {
         return statement;
@@ -252912,6 +252964,52 @@ function isConditionalExpression(node) {
     return (node !== null &&
         unwrapTypeAndParentheses(node).type === dist$3.AST_NODE_TYPES.ConditionalExpression);
 }
+function isBooleanLiteral(node) {
+    return node.type === dist$3.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
+}
+function getBooleanLiteralValue(node) {
+    return isBooleanLiteral(node) ? node.value : null;
+}
+function isKnownBooleanExpression(node) {
+    const unwrapped = unwrapTypeAndParentheses(node);
+    switch (unwrapped.type) {
+        case dist$3.AST_NODE_TYPES.BinaryExpression:
+            return BOOLEAN_BINARY_OPERATORS.has(unwrapped.operator);
+        case dist$3.AST_NODE_TYPES.Literal:
+            return typeof unwrapped.value === 'boolean';
+        case dist$3.AST_NODE_TYPES.LogicalExpression:
+            return (isKnownBooleanExpression(unwrapped.left) &&
+                isKnownBooleanExpression(unwrapped.right));
+        case dist$3.AST_NODE_TYPES.UnaryExpression:
+            return unwrapped.operator === '!';
+        default:
+            return false;
+    }
+}
+function isBooleanType(type) {
+    const types = type.isUnion() ? type.types : [type];
+    return types.every((part) => !!(part.flags & ts.TypeFlags.BooleanLike));
+}
+function getBooleanTestReturnStrategy(test, consequentExpression, alternateExpression, isTypeCheckedBooleanExpression) {
+    const consequentValue = getBooleanLiteralValue(consequentExpression);
+    const alternateValue = getBooleanLiteralValue(alternateExpression);
+    if (consequentValue === false && alternateValue === true) {
+        return unwrapTypeAndParentheses(test).type === dist$3.AST_NODE_TYPES.LogicalExpression
+            ? 'skip'
+            : 'negate';
+    }
+    if (consequentValue !== true || alternateValue !== false) {
+        return 'skip';
+    }
+    return isKnownBooleanExpression(test) || isTypeCheckedBooleanExpression(test)
+        ? 'direct'
+        : 'coerce';
+}
+function shouldSkipBooleanReturn(test, consequentExpression, alternateExpression) {
+    return (getBooleanLiteralValue(consequentExpression) === false &&
+        getBooleanLiteralValue(alternateExpression) === true &&
+        unwrapTypeAndParentheses(test).type === dist$3.AST_NODE_TYPES.LogicalExpression);
+}
 function needsParenthesesInConditionalTest(node) {
     if (getParenthesizedInner(node)) {
         return false;
@@ -252949,6 +253047,27 @@ function needsParenthesesInConditionalBranch(node) {
             return false;
     }
 }
+function needsParenthesesInBooleanCoercion(node) {
+    if (getParenthesizedInner(node)) {
+        return false;
+    }
+    switch (node.type) {
+        case dist$3.AST_NODE_TYPES.ArrowFunctionExpression:
+        case dist$3.AST_NODE_TYPES.AssignmentExpression:
+        case dist$3.AST_NODE_TYPES.BinaryExpression:
+        case dist$3.AST_NODE_TYPES.ConditionalExpression:
+        case dist$3.AST_NODE_TYPES.LogicalExpression:
+        case dist$3.AST_NODE_TYPES.ObjectExpression:
+        case dist$3.AST_NODE_TYPES.SequenceExpression:
+        case dist$3.AST_NODE_TYPES.TSAsExpression:
+        case dist$3.AST_NODE_TYPES.TSSatisfiesExpression:
+        case dist$3.AST_NODE_TYPES.TSTypeAssertion:
+        case dist$3.AST_NODE_TYPES.YieldExpression:
+            return true;
+        default:
+            return false;
+    }
+}
 function renderExpression(node, sourceCode, needsParentheses) {
     const text = sourceCode.getText(node);
     return needsParentheses(node) ? `(${text})` : text;
@@ -252972,9 +253091,58 @@ function renderConditionalReturn(ifStatement, consequentExpression, alternateExp
     const branchIndent = `${indent}    `;
     return `return ${test}\n${branchIndent}? ${consequent}\n${branchIndent}: ${alternate};`;
 }
+function renderBooleanTestReturn(ifStatement, sourceCode, strategy) {
+    const test = sourceCode.getText(ifStatement.test);
+    if (strategy === 'negate') {
+        if (!test.includes('\n')) {
+            const renderedTest = needsParenthesesInBooleanCoercion(ifStatement.test)
+                ? `(${test})`
+                : test;
+            return `return !${renderedTest};`;
+        }
+        const indent = getStatementIndent(ifStatement, sourceCode);
+        return `return !(\n${indent}    ${test}\n${indent});`;
+    }
+    if (strategy === 'coerce') {
+        if (!test.includes('\n')) {
+            const renderedTest = needsParenthesesInBooleanCoercion(ifStatement.test)
+                ? `(${test})`
+                : test;
+            return `return !!${renderedTest};`;
+        }
+        const indent = getStatementIndent(ifStatement, sourceCode);
+        return `return !!(\n${indent}    ${test}\n${indent});`;
+    }
+    if (!test.includes('\n')) {
+        return `return ${test};`;
+    }
+    const indent = getStatementIndent(ifStatement, sourceCode);
+    return `return (\n${indent}    ${test}\n${indent});`;
+}
 const rule$l = createRule({
     create(context) {
         const { sourceCode } = context;
+        let parserServices = null;
+        let checker = null;
+        try {
+            parserServices = dist$3.ESLintUtils.getParserServices(context);
+            checker = parserServices.program.getTypeChecker();
+        }
+        catch {
+            // Type checking is optional; syntactic boolean detection still works.
+        }
+        function isTypeCheckedBooleanExpression(node) {
+            if (!parserServices || !checker) {
+                return false;
+            }
+            try {
+                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                return isBooleanType(checker.getTypeAtLocation(tsNode));
+            }
+            catch {
+                return false;
+            }
+        }
         function checkBody(statements) {
             for (const [index, statement] of statements.entries()) {
                 if (statement.type !== dist$3.AST_NODE_TYPES.IfStatement) {
@@ -252993,6 +253161,7 @@ const rule$l = createRule({
                     !finalArgument ||
                     isConditionalExpression(consequentArgument) ||
                     isConditionalExpression(finalArgument) ||
+                    shouldSkipBooleanReturn(statement.test, consequentArgument, finalArgument) ||
                     !hasOnlyWhitespaceBetween(sourceCode, statement, finalReturn) ||
                     sourceCode.getCommentsInside(statement).length > 0 ||
                     sourceCode.getCommentsInside(finalReturn).length > 0) {
@@ -253000,7 +253169,10 @@ const rule$l = createRule({
                 }
                 context.report({
                     fix(fixer) {
-                        const replacement = renderConditionalReturn(statement, consequentArgument, finalArgument, sourceCode);
+                        const booleanTestReturnStrategy = getBooleanTestReturnStrategy(statement.test, consequentArgument, finalArgument, isTypeCheckedBooleanExpression);
+                        const replacement = booleanTestReturnStrategy === 'skip'
+                            ? renderConditionalReturn(statement, consequentArgument, finalArgument, sourceCode)
+                            : renderBooleanTestReturn(statement, sourceCode, booleanTestReturnStrategy);
                         return fixer.replaceTextRange([statement.range[0], finalReturn.range[1]], replacement);
                     },
                     messageId: 'preferConditionalReturn',

package/package.json

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

package/rules/recommended/prefer-conditional-return.d.ts

@@ -1,5 +1,5 @@
-import { type TSESLint } from '@typescript-eslint/utils';
-export declare const rule: TSESLint.RuleModule<"preferConditionalReturn", [], unknown, TSESLint.RuleListener> & {
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const rule: ESLintUtils.RuleModule<"preferConditionalReturn", [], unknown, ESLintUtils.RuleListener> & {
     name: string;
 };
 export default rule;