@taiga-ui/eslint-plugin-experience-next 0.504.0 → 0.506.0

package/README.md

@@ -109,6 +109,7 @@ from third-party plugins. The exact severities and file globs live in
 | [object-single-line](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/object-single-line.md)                                                           | Enforce single-line formatting for single-property objects when it fits `printWidth`                | ✅  | 🔧  |     |
 | [prefer-combined-if-control-flow](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-combined-if-control-flow.md)                                 | Combine consecutive `if` statements that use the same `return`, `break`, `continue`, or `throw`     | ✅  | 🔧  |     |
 | [prefer-deep-imports](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-deep-imports.md)                                                         | Allow deep imports of Taiga UI packages                                                             |     | 🔧  |     |
+| [prefer-loose-null-check](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-loose-null-check.md)                                                 | Prefer loose null checks over paired strict comparisons against `null` and `undefined`              | ✅  | 🔧  |     |
 | [prefer-multi-arg-push](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-multi-arg-push.md)                                                     | Combine consecutive `.push()` calls on the same array into a single multi-argument call             | ✅  | 🔧  |     |
 | [prefer-namespace-keyword](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-namespace-keyword.md)                                               | Replace `module Foo {}` with `namespace Foo {}` for TypeScript namespace declarations               | ✅  | 🔧  |     |
 | [prefer-untracked-incidental-signal-reads](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-untracked-incidental-signal-reads.md)               | Wrap likely-incidental signal reads with `untracked()` in reactive callbacks                        | ✅  | 🔧  |     |

package/index.d.ts

@@ -148,6 +148,9 @@ declare const plugin: {
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'prefer-loose-null-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferLooseNullCheck", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'prefer-multi-arg-push': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferMultiArgPush", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/index.esm.js

@@ -1213,6 +1213,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-useless-untracked': 'error',
             '@taiga-ui/experience-next/object-single-line': ['error', { printWidth: 90 }],
             '@taiga-ui/experience-next/prefer-combined-if-control-flow': 'error',
+            '@taiga-ui/experience-next/prefer-loose-null-check': 'error',
             '@taiga-ui/experience-next/prefer-multi-arg-push': 'error',
             '@taiga-ui/experience-next/prefer-namespace-keyword': 'error',
             '@taiga-ui/experience-next/prefer-untracked-incidental-signal-reads': 'error',
@@ -1509,6 +1510,7 @@ var taigaSpecific = defineConfig([
     {
         files: pattern('**/*.html'),
         ignores: [
+            '**/proprietary/**',
             // Angular ESLint virtual files for inline templates in spec/cy files
             '**/*.spec.ts/**/*.html',
             '**/*.cy.ts/**/*.html',
@@ -46222,7 +46224,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join('\n');
 }
-const rule$P = createRule({
+const rule$Q = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -46369,7 +46371,7 @@ const config$5 = {
 function getCorrectOrderRelative(correct, current) {
     return correct.filter((item) => current.includes(item));
 }
-const rule$O = createRule({
+const rule$P = createRule({
     name: 'decorator-key-sort',
     rule: config$5,
 });
@@ -46433,7 +46435,7 @@ function getNodeLabel(node) {
     }
     return 'text';
 }
-const rule$N = createRule({
+const rule$O = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
@@ -46664,7 +46666,7 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const rule$M = createRule({
+const rule$N = createRule({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -46778,7 +46780,7 @@ function getHostAttributeProperties(hostObject) {
             return null;
         }
         const name = getStaticPropertyName(property.key);
-        if (name === null) {
+        if (name == null) {
             return null;
         }
         properties.push({ name, node: property });
@@ -46997,7 +46999,7 @@ const config$4 = {
         type: 'suggestion',
     },
 };
-const rule$L = createRule({
+const rule$M = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
@@ -248249,7 +248251,7 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     }
     return hasSafeRuntimeUsage;
 }
-const rule$K = createRule({
+const rule$L = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
         const checkCycles = context.options[0]?.checkCycles ?? true;
@@ -248441,21 +248443,21 @@ const rule$K = createRule({
                 getExcessParentPathReplacement(moduleSpecifierPath, resolved.resolvedFileName));
         }
         function checkUselessPathSegments(source) {
-            if (!shouldCheckUselessPathSegments || !source.value.startsWith('.')) {
+            if (!shouldCheckUselessPathSegments ||
+                !source.value.startsWith('.') ||
+                splitModuleSpecifierQuery(source.value).query) {
                 return;
             }
-            const parts = splitModuleSpecifierQuery(source.value);
-            const proposedPath = getUselessPathSegmentsReplacement(parts.path);
+            const proposedPath = getUselessPathSegmentsReplacement(source.value);
             if (!proposedPath) {
                 return;
             }
-            const proposedModuleSpecifier = `${proposedPath}${parts.query}`;
             context.report({
                 data: {
                     moduleSpecifier: source.value,
-                    proposedPath: proposedModuleSpecifier,
+                    proposedPath,
                 },
-                fix: (fixer) => fixer.replaceText(source, quoteModuleSpecifier(source, proposedModuleSpecifier)),
+                fix: (fixer) => fixer.replaceText(source, quoteModuleSpecifier(source, proposedPath)),
                 messageId: 'uselessPathSegments',
                 node: source,
             });
@@ -248955,7 +248957,7 @@ function prependTokenName(text, name) {
     return `${text.slice(0, 1)}[${name}]: ${text.slice(1)}`;
 }
 function isNgDevModeVisible(sourceCode, node) {
-    for (let scope = sourceCode.getScope(node); scope !== null; scope = scope.upper) {
+    for (let scope = sourceCode.getScope(node); scope != null; scope = scope.upper) {
         if (scope.variables.some((variable) => variable.name === NG_DEV_MODE)) {
             return true;
         }
@@ -248975,7 +248977,7 @@ function getNgDevModeDeclarationFix(program, fixer) {
     }
     return fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
 }
-const rule$J = createRule({
+const rule$K = createRule({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -249024,7 +249026,7 @@ const rule$J = createRule({
     name: 'injection-token-description',
 });
 
-const rule$I = createRule({
+const rule$J = createRule({
     create(context) {
         const { sourceCode } = context;
         const namespaceImports = new Map();
@@ -249119,7 +249121,7 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const rule$H = createRule({
+const rule$I = createRule({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -249211,7 +249213,7 @@ const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-const rule$G = createRule({
+const rule$H = createRule({
     create(context) {
         const parserServices = dist$3.ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -249226,7 +249228,7 @@ const rule$G = createRule({
             }
             const key = `${containingDir}\0${moduleSpecifier}`;
             const cachedFile = cache.get(key);
-            if (cachedFile !== undefined) {
+            if (cachedFile != null) {
                 return cachedFile;
             }
             const resolved = ts.resolveModuleName(moduleSpecifier, context.filename, compilerOptions, compilerHost);
@@ -249237,7 +249239,7 @@ const rule$G = createRule({
         function findNearestFileUpwardsCached(startDirectory, fileName) {
             const key = `${startDirectory}\0${fileName}`;
             const cachedPath = nearestFileUpCache.get(key);
-            if (cachedPath !== undefined) {
+            if (cachedPath != null) {
                 return cachedPath;
             }
             let currentDirectory = startDirectory;
@@ -249258,7 +249260,7 @@ const rule$G = createRule({
         }
         function pickPackageMarkerFileCached(resolvedRootFilePath) {
             const cachedMarker = markerCache.get(resolvedRootFilePath);
-            if (cachedMarker !== undefined) {
+            if (cachedMarker != null) {
                 return cachedMarker;
             }
             const resolvedRootDirectory = path.dirname(resolvedRootFilePath);
@@ -249270,7 +249272,7 @@ const rule$G = createRule({
         }
         function pickIndexFileInDirectoryCached(packageDirectory) {
             const cachedIndexFile = indexFileCache.get(packageDirectory);
-            if (cachedIndexFile !== undefined) {
+            if (cachedIndexFile != null) {
                 return cachedIndexFile;
             }
             const indexTypescriptPath = path.join(packageDirectory, 'index.ts');
@@ -249408,13 +249410,13 @@ const noDuplicateAttributesRule = angular.templatePlugin.rules?.['no-duplicate-a
 if (!noDuplicateAttributesRule) {
     throw new Error('angular-eslint template rule "no-duplicate-attributes" is not available');
 }
-const rule$F = createRule({
+const rule$G = createRule({
     name: 'no-duplicate-attrs',
     rule: noDuplicateAttributesRule,
 });
 
 const MESSAGE_ID$c = 'duplicateId';
-const rule$E = createRule({
+const rule$F = createRule({
     name: 'no-duplicate-id',
     rule: {
         create(context) {
@@ -249476,7 +249478,7 @@ function getTrackingKey(node) {
     }
     return null;
 }
-const rule$D = createRule({
+const rule$E = createRule({
     name: 'no-duplicate-in-head',
     rule: {
         create(context) {
@@ -249542,7 +249544,7 @@ function getOrderedChildren(node) {
             ...node.params,
             node.body,
         ];
-        return children.filter((child) => child !== undefined && child !== null);
+        return children.filter((child) => child != null);
     }
     if (node.type === dist$3.AST_NODE_TYPES.BlockStatement ||
         node.type === dist$3.AST_NODE_TYPES.Program) {
@@ -249569,7 +249571,7 @@ function getOrderedChildren(node) {
             node.update,
             node.body,
         ];
-        return children.filter((child) => child !== null);
+        return children.filter((child) => child != null);
     }
     if (node.type === dist$3.AST_NODE_TYPES.ForInStatement ||
         node.type === dist$3.AST_NODE_TYPES.ForOfStatement) {
@@ -250061,7 +250063,7 @@ const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#r
 const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
 const createUntrackedRule = createRule;
 
-const rule$C = createUntrackedRule({
+const rule$D = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250134,7 +250136,7 @@ const config$3 = {
         type: 'problem',
     },
 };
-const rule$B = createRule({
+const rule$C = createRule({
     name: 'no-href-with-router-link',
     rule: config$3,
 });
@@ -250195,7 +250197,7 @@ function getScopeRoot(node) {
     return (findAncestor(node, (ancestor) => ancestor.type === dist$3.AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
 }
 
-const rule$A = createRule({
+const rule$B = createRule({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getEnclosingClass(node);
@@ -250257,7 +250259,7 @@ const rule$A = createRule({
     name: 'no-implicit-public',
 });
 
-const rule$z = createRule({
+const rule$A = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -250313,9 +250315,9 @@ function isInfiniteLoopLiteral(node) {
     return unwrapped.value === true || unwrapped.value === 1;
 }
 function isInfiniteLoopTest(test) {
-    return test === null || isInfiniteLoopLiteral(test);
+    return test == null || isInfiniteLoopLiteral(test);
 }
-const rule$y = createRule({
+const rule$z = createRule({
     create(context) {
         return {
             DoWhileStatement(node) {
@@ -250360,7 +250362,7 @@ const rule$y = createRule({
 });
 
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$x = createRule({
+const rule$y = createRule({
     create(context) {
         return {
             Program(node) {
@@ -250820,7 +250822,7 @@ const OBSOLETE_HTML_ATTRS = {
 };
 
 const MESSAGE_ID$9 = 'obsolete';
-const rule$w = createRule({
+const rule$x = createRule({
     name: 'no-obsolete-attrs',
     rule: {
         create(context) {
@@ -250898,7 +250900,7 @@ const OBSOLETE_HTML_TAGS = new Set([
 ]);
 
 const MESSAGE_ID$8 = 'unexpected';
-const rule$v = createRule({
+const rule$w = createRule({
     name: 'no-obsolete-tags',
     rule: {
         create(context) {
@@ -250925,7 +250927,7 @@ const rule$v = createRule({
     },
 });
 
-const rule$u = createRule({
+const rule$v = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         return {
@@ -251069,7 +251071,7 @@ const config$2 = {
         type: 'problem',
     },
 };
-const rule$t = createRule({
+const rule$u = createRule({
     name: 'no-project-as-in-ng-template',
     rule: config$2,
 });
@@ -251106,7 +251108,7 @@ function collectArrayExpressions(node) {
     }
     return result;
 }
-const rule$s = createRule({
+const rule$t = createRule({
     create(context) {
         const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const ignoreTupleContextualTyping = context.options[0]?.ignoreTupleContextualTyping ?? true;
@@ -251281,7 +251283,7 @@ function getStatementIndent(statement, sourceText) {
     const before = sourceText.slice(lineStart, start);
     return /^\s*$/.test(before) ? before : '';
 }
-const rule$r = createRule({
+const rule$s = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251712,7 +251714,7 @@ function inspectComputedBody(root, context, localScopes, visitedFunctions, repor
         return;
     });
 }
-const rule$q = createRule({
+const rule$r = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251755,7 +251757,7 @@ const rule$q = createRule({
     name: 'no-side-effects-in-computed',
 });
 
-const rule$p = createUntrackedRule({
+const rule$q = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251849,7 +251851,7 @@ function templateContent(template, renderExpr) {
         : ''}`)
         .join('');
 }
-const rule$o = createRule({
+const rule$p = createRule({
     create(context) {
         const { sourceCode } = context;
         let parserServices = null;
@@ -252184,7 +252186,7 @@ function buildReactiveCallReplacement(outerUntrackedCall, reactiveCall, sourceCo
     }
     return dedent(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
 }
-const rule$n = createUntrackedRule({
+const rule$o = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -252220,7 +252222,7 @@ const rule$n = createUntrackedRule({
                                 fixer.replaceText(node, buildReactiveCallReplacement(node, reactiveCall, sourceCode)),
                             ];
                             const untrackedLocalName = findUntrackedAlias(program);
-                            const stillUsed = untrackedLocalName !== null &&
+                            const stillUsed = untrackedLocalName != null &&
                                 isUntrackedUsedElsewhere(untrackedLocalName, node);
                             if (!stillUsed) {
                                 fixes.push(...buildImportRemovalFixes(program, fixer, sourceCode));
@@ -252313,7 +252315,7 @@ function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program
     });
     return found;
 }
-const rule$m = createUntrackedRule({
+const rule$n = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -252344,11 +252346,11 @@ const rule$m = createUntrackedRule({
                     ? (fixer) => {
                         const parentStmt = parent;
                         const replacement = buildReplacement(untrackedCall, parentStmt, sourceCode);
-                        if (replacement === null) {
+                        if (replacement == null) {
                             return null;
                         }
                         const untrackedLocalName = findUntrackedAlias(program);
-                        const stillUsed = untrackedLocalName !== null &&
+                        const stillUsed = untrackedLocalName != null &&
                             isUntrackedUsedElsewhere(untrackedLocalName, untrackedCall);
                         const fixes = [fixer.replaceText(parentStmt, replacement)];
                         if (!stillUsed) {
@@ -252395,7 +252397,7 @@ const rule$m = createUntrackedRule({
     name: 'no-useless-untracked',
 });
 
-const rule$l = createRule({
+const rule$m = createRule({
     create(context, [{ printWidth }]) {
         const sourceCode = context.sourceCode;
         const getLineEndIndex = (lineStartIndex) => {
@@ -252716,7 +252718,7 @@ function renderTest(node, sourceCode) {
     const text = sourceCode.getText(node);
     return needsParenthesesInOrChain(node) ? `(${text})` : text;
 }
-const rule$k = createRule({
+const rule$l = createRule({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -252805,6 +252807,110 @@ const rule$k = createRule({
     name: 'prefer-combined-if-control-flow',
 });
 
+function parseStrictNullCheck(node, getText) {
+    if (node.type !== dist$3.AST_NODE_TYPES.BinaryExpression) {
+        return null;
+    }
+    const { left, operator, right } = node;
+    if (operator !== '!==' && operator !== '===') {
+        return null;
+    }
+    if (right.type === dist$3.AST_NODE_TYPES.Literal && right.value === null) {
+        return { comparedWith: 'null', operand: getText(left), strictOp: operator };
+    }
+    if (right.type === dist$3.AST_NODE_TYPES.Identifier && right.name === 'undefined') {
+        return { comparedWith: 'undefined', operand: getText(left), strictOp: operator };
+    }
+    if (left.type === dist$3.AST_NODE_TYPES.Literal && left.value === null) {
+        return { comparedWith: 'null', operand: getText(right), strictOp: operator };
+    }
+    if (left.type === dist$3.AST_NODE_TYPES.Identifier && left.name === 'undefined') {
+        return { comparedWith: 'undefined', operand: getText(right), strictOp: operator };
+    }
+    return null;
+}
+function isParsedNullCheck(value) {
+    return value !== null;
+}
+function getLooseNullCheck(left, right) {
+    if (!isParsedNullCheck(left) ||
+        !isParsedNullCheck(right) ||
+        left.strictOp !== right.strictOp ||
+        left.operand !== right.operand ||
+        left.comparedWith === right.comparedWith) {
+        return null;
+    }
+    return `${left.operand} ${left.strictOp === '!==' ? '!=' : '=='} null`;
+}
+function collectAndLeaves(node) {
+    if (node.type === dist$3.AST_NODE_TYPES.LogicalExpression && node.operator === '&&') {
+        return [...collectAndLeaves(node.left), ...collectAndLeaves(node.right)];
+    }
+    return [node];
+}
+function isAndChainRoot(node) {
+    return (node.parent.type !== dist$3.AST_NODE_TYPES.LogicalExpression ||
+        node.parent.operator !== '&&');
+}
+function findLooseNullCheckMatch(parsedChecks) {
+    for (const [firstCheckIndex, firstCheck] of parsedChecks.entries()) {
+        if (!isParsedNullCheck(firstCheck)) {
+            continue;
+        }
+        for (let secondCheckIndex = firstCheckIndex + 1; secondCheckIndex < parsedChecks.length; secondCheckIndex++) {
+            const replacement = getLooseNullCheck(firstCheck, parsedChecks[secondCheckIndex] ?? null);
+            if (replacement !== null) {
+                return { firstCheckIndex, replacement, secondCheckIndex };
+            }
+        }
+    }
+    return null;
+}
+const rule$k = createRule({
+    create(context) {
+        const getText = (n) => context.sourceCode.getText(n);
+        return {
+            /**
+             * Handles only paired null/undefined checks in the same `&&` chain.
+             */
+            LogicalExpression(node) {
+                if (node.operator !== '&&' || !isAndChainRoot(node)) {
+                    return;
+                }
+                const leaves = collectAndLeaves(node);
+                const parsedChecks = leaves.map((leaf) => parseStrictNullCheck(leaf, getText));
+                const match = findLooseNullCheckMatch(parsedChecks);
+                if (match === null) {
+                    return;
+                }
+                const replacement = leaves
+                    .filter((_, index) => index !== match.secondCheckIndex)
+                    .map((leaf, index) => index === match.firstCheckIndex
+                    ? match.replacement
+                    : getText(leaf))
+                    .join(' && ');
+                context.report({
+                    fix: (fixer) => fixer.replaceText(node, replacement),
+                    messageId: 'preferLooseNullCheck',
+                    node,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Prefer loose null checks over paired strict comparisons against `null` and `undefined`.',
+        },
+        fixable: 'code',
+        messages: {
+            preferLooseNullCheck: 'Prefer loose null check over paired strict comparisons against `null` and `undefined`.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'prefer-loose-null-check',
+});
+
 function getPushCall(node) {
     if (node.expression.type !== dist$3.AST_NODE_TYPES.CallExpression) {
         return null;
@@ -253190,7 +253296,7 @@ const rule$h = createUntrackedRule({
         const estreeNodeMap = tsNodeToESTreeNodeMap;
         function buildFix(read) {
             const untrackedAlias = findUntrackedAlias(program);
-            const alreadyHasUntracked = untrackedAlias !== null;
+            const alreadyHasUntracked = untrackedAlias != null;
             const wrapped = buildUntrackedWrap(read, sourceCode, untrackedAlias ?? 'untracked');
             if (alreadyHasUntracked) {
                 return (fixer) => [fixer.replaceText(read, wrapped)];
@@ -253520,13 +253626,13 @@ const VALID_CONTAINERS = new Set(['menu', 'ol', 'ul']);
  */
 function isElement(node) {
     return (typeof node === 'object' &&
-        node !== null &&
+        node != null &&
         typeof node['name'] === 'string' &&
         Array.isArray(node['children']));
 }
 function getClosestParentElement(node) {
     let current = node['parent'];
-    while (current !== null && current !== undefined) {
+    while (current != null) {
         if (isElement(current)) {
             return current;
         }
@@ -254198,7 +254304,7 @@ const rule$6 = createRule({
                     if (!arr) {
                         continue;
                     }
-                    const elements = arr.elements.filter((el) => el !== null);
+                    const elements = arr.elements.filter((el) => el != null);
                     if (elements.length <= 1) {
                         continue;
                     }
@@ -254444,7 +254550,7 @@ const rule$3 = createRule({
         const purityCache = new WeakMap();
         const isPureArray = (arr) => {
             const cachedPurity = purityCache.get(arr);
-            if (cachedPurity !== undefined) {
+            if (cachedPurity != null) {
                 return cachedPurity;
             }
             if (arr.isDirty) {
@@ -254613,7 +254719,7 @@ const config = {
                 }
                 for (const attr of node.inputs) {
                     const attrValue = getLiteralStringValue(attr);
-                    if (attrValue !== null) {
+                    if (attrValue != null) {
                         checkAttribute(context, attr, attrValue, checkers);
                     }
                 }
@@ -255119,42 +255225,43 @@ const plugin = {
     },
     rules: {
         'array-as-const': rule$5,
-        'attrs-newline': rule$P,
+        'attrs-newline': rule$Q,
         'class-property-naming': rule$4,
-        'decorator-key-sort': rule$O,
-        'element-newline': rule$N,
+        'decorator-key-sort': rule$P,
+        'element-newline': rule$O,
         'flat-exports': rule$3,
-        'host-attributes-sort': rule$M,
-        'html-logical-properties': rule$L,
-        'import-integrity': rule$K,
-        'injection-token-description': rule$J,
-        'no-commonjs-import-patterns': rule$I,
-        'no-deep-imports': rule$H,
-        'no-deep-imports-to-indexed-packages': rule$G,
-        'no-duplicate-attrs': rule$F,
-        'no-duplicate-id': rule$E,
-        'no-duplicate-in-head': rule$D,
-        'no-fully-untracked-effect': rule$C,
-        'no-href-with-router-link': rule$B,
-        'no-implicit-public': rule$A,
-        'no-import-assertions': rule$z,
-        'no-infinite-loop': rule$y,
-        'no-legacy-peer-deps': rule$x,
-        'no-obsolete-attrs': rule$w,
-        'no-obsolete-tags': rule$v,
-        'no-playwright-empty-fill': rule$u,
-        'no-project-as-in-ng-template': rule$t,
-        'no-redundant-type-annotation': rule$s,
-        'no-repeated-signal-in-conditional': rule$r,
+        'host-attributes-sort': rule$N,
+        'html-logical-properties': rule$M,
+        'import-integrity': rule$L,
+        'injection-token-description': rule$K,
+        'no-commonjs-import-patterns': rule$J,
+        'no-deep-imports': rule$I,
+        'no-deep-imports-to-indexed-packages': rule$H,
+        'no-duplicate-attrs': rule$G,
+        'no-duplicate-id': rule$F,
+        'no-duplicate-in-head': rule$E,
+        'no-fully-untracked-effect': rule$D,
+        'no-href-with-router-link': rule$C,
+        'no-implicit-public': rule$B,
+        'no-import-assertions': rule$A,
+        'no-infinite-loop': rule$z,
+        'no-legacy-peer-deps': rule$y,
+        'no-obsolete-attrs': rule$x,
+        'no-obsolete-tags': rule$w,
+        'no-playwright-empty-fill': rule$v,
+        'no-project-as-in-ng-template': rule$u,
+        'no-redundant-type-annotation': rule$t,
+        'no-repeated-signal-in-conditional': rule$s,
         'no-restricted-attr-values': rule$2,
-        'no-side-effects-in-computed': rule$q,
-        'no-signal-reads-after-await-in-reactive-context': rule$p,
-        'no-string-literal-concat': rule$o,
-        'no-untracked-outside-reactive-context': rule$n,
-        'no-useless-untracked': rule$m,
-        'object-single-line': rule$l,
-        'prefer-combined-if-control-flow': rule$k,
+        'no-side-effects-in-computed': rule$r,
+        'no-signal-reads-after-await-in-reactive-context': rule$q,
+        'no-string-literal-concat': rule$p,
+        'no-untracked-outside-reactive-context': rule$o,
+        'no-useless-untracked': rule$n,
+        'object-single-line': rule$m,
+        'prefer-combined-if-control-flow': rule$l,
         'prefer-deep-imports': rule$1,
+        'prefer-loose-null-check': rule$k,
         'prefer-multi-arg-push': rule$j,
         'prefer-namespace-keyword': rule$i,
         'prefer-untracked-incidental-signal-reads': rule$h,

package/package.json

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

package/rules/recommended/prefer-loose-null-check.d.ts

@@ -0,0 +1,4 @@
+export declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferLooseNullCheck", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default rule;