@taiga-ui/eslint-plugin-experience-next 0.475.0 → 0.477.0

package/README.md

@@ -45,10 +45,12 @@ export default [
 | flat-exports                                    | Spread nested arrays when exporting Angular entity collections                                      |     | 🔧  |     |
 | host-attributes-sort                            | Sort Angular host metadata attributes using configurable attribute groups                           | ✅  | 🔧  |     |
 | injection-token-description                     | Require `InjectionToken` descriptions to include the token name                                     | ✅  | 🔧  |     |
+| no-commonjs-import-patterns                     | Disallow legacy CommonJS interop import patterns                                                    | ✅  |     |     |
 | no-deep-imports                                 | Disables deep imports of Taiga UI packages                                                          | ✅  | 🔧  |     |
 | no-deep-imports-to-indexed-packages             | Disallow deep imports from packages that expose an index.ts next to ng-package.json or package.json | ✅  | 🔧  |     |
 | no-fully-untracked-effect                       | Disallow reactive callbacks where all signal reads are hidden inside `untracked()`                  | ✅  |     |     |
 | no-href-with-router-link                        | Do not use href and routerLink attributes together on the same element                              | ✅  | 🔧  |     |
+| no-import-assertions                            | Replace legacy `assert { ... }` import assertions with `with { ... }`                               | ✅  | 🔧  |     |
 | no-implicit-public                              | Require explicit `public` modifier for class members and parameter properties                       | ✅  | 🔧  |     |
 | no-infinite-loop                                | Disallow `while (true)` and `for` loops without an explicit condition                               | ✅  |     |     |
 | no-legacy-peer-deps                             | Disallow `legacy-peer-deps=true` in `.npmrc`                                                        | ✅  |     |     |
@@ -64,6 +66,7 @@ export default [
 | prefer-combined-if-control-flow                 | Combine consecutive `if` statements that use the same `return`, `break`, `continue`, or `throw`     | ✅  | 🔧  |     |
 | prefer-deep-imports                             | Allow deep imports of Taiga UI packages                                                             |     | 🔧  |     |
 | prefer-multi-arg-push                           | Combine consecutive `.push()` calls on the same array into a single multi-argument call             | ✅  | 🔧  |     |
+| prefer-namespace-keyword                        | Replace `module Foo {}` with `namespace Foo {}` for TypeScript namespace declarations               | ✅  | 🔧  |     |
 | prefer-untracked-incidental-signal-reads        | Wrap likely-incidental signal reads with `untracked()` in reactive callbacks                        | ✅  | 🔧  |     |
 | prefer-untracked-signal-getter                  | Prefer `untracked(signalGetter)` over `untracked(() => signalGetter())` for a single signal getter  | ✅  | 🔧  |     |
 | short-tui-imports                               | Shorten TuiXxxComponent / TuiYyyDirective in Angular metadata                                       | ✅  | 🔧  |     |
@@ -307,6 +310,29 @@ export const TUI_MY_TOKEN = new InjectionToken<string>(ngDevMode ? '[TUI_MY_TOKE
 
 ---
 
+## no-commonjs-import-patterns
+
+<sup>`✅ Recommended`</sup>
+
+Disallows legacy CommonJS interop import patterns that are brittle under modern ESM-oriented toolchains. It reports
+`import foo = require('foo')` and namespace imports that are used as callable values, constructors, or tag functions.
+
+```ts
+// ❌ error
+import toolkit = require('@taiga-ui/cdk');
+
+import * as createClient from 'legacy-client';
+createClient();
+
+// ✅ ok
+import toolkit from '@taiga-ui/cdk';
+
+import createClient from 'legacy-client';
+createClient();
+```
+
+---
+
 ## no-deep-imports
 
 <sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
@@ -419,6 +445,22 @@ attribute.
 
 ---
 
+## no-import-assertions
+
+<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
+
+Disallows legacy `assert { ... }` import assertions and rewrites them to `with { ... }` import attributes.
+
+```ts
+// ❌ error
+import data from './file.json' assert {type: 'json'};
+
+// ✅ after autofix
+import data from './file.json' with {type: 'json'};
+```
+
+---
+
 ## no-implicit-public
 
 <sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
@@ -1043,6 +1085,27 @@ output.push('# Getting Started', '');
 
 ---
 
+## prefer-namespace-keyword
+
+<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
+
+Prefers `namespace Foo {}` over the older `module Foo {}` syntax for TypeScript namespace declarations. External module
+augmentations such as `declare module 'pkg' {}` are ignored.
+
+```ts
+// ❌ error
+module Foo.Bar {
+  export type Value = string;
+}
+
+// ✅ after autofix
+namespace Foo.Bar {
+  export type Value = string;
+}
+```
+
+---
+
 ## prefer-untracked-incidental-signal-reads
 
 <sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>

package/index.d.ts

@@ -30,6 +30,9 @@ declare const plugin: {
         'injection-token-description': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalid-injection-token-description", readonly unknown[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'no-commonjs-import-patterns': import("@typescript-eslint/utils/ts-eslint").RuleModule<"avoidCallableNamespaceImport" | "avoidImportEquals", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'no-deep-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"no-deep-imports", {
             currentProject: string;
             deepImport: string;
@@ -49,7 +52,10 @@ declare const plugin: {
         'no-implicit-public': import("@typescript-eslint/utils/ts-eslint").RuleModule<"implicitPublic", readonly unknown[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-infinite-loop': import("@typescript-eslint/utils/ts-eslint").RuleModule<"forLoop" | "whileLoop", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'no-import-assertions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useWithImportAttributes", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        'no-infinite-loop': import("@typescript-eslint/utils/ts-eslint").RuleModule<"doWhileLoop" | "forLoop" | "whileLoop", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         'no-legacy-peer-deps': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLegacyPeerDeps", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
@@ -96,6 +102,9 @@ declare const plugin: {
         'prefer-multi-arg-push': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferMultiArgPush", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'prefer-namespace-keyword': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useNamespaceKeyword", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'prefer-untracked-incidental-signal-reads': import("@typescript-eslint/utils/ts-eslint").RuleModule<"incidentalRead", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/index.esm.js

@@ -898,6 +898,7 @@ var recommended = defineConfig([
             ],
             '@taiga-ui/experience-next/host-attributes-sort': 'error',
             '@taiga-ui/experience-next/injection-token-description': 'error',
+            '@taiga-ui/experience-next/no-commonjs-import-patterns': 'error',
             '@taiga-ui/experience-next/no-deep-imports': [
                 'error',
                 {
@@ -908,6 +909,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-deep-imports-to-indexed-packages': 'error',
             '@taiga-ui/experience-next/no-fully-untracked-effect': 'error',
             '@taiga-ui/experience-next/no-implicit-public': 'error',
+            '@taiga-ui/experience-next/no-import-assertions': 'error',
             '@taiga-ui/experience-next/no-infinite-loop': 'error',
             '@taiga-ui/experience-next/no-redundant-type-annotation': 'error',
             '@taiga-ui/experience-next/no-side-effects-in-computed': 'error',
@@ -917,6 +919,7 @@ var recommended = defineConfig([
             '@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-multi-arg-push': 'error',
+            '@taiga-ui/experience-next/prefer-namespace-keyword': 'error',
             '@taiga-ui/experience-next/prefer-untracked-incidental-signal-reads': 'error',
             '@taiga-ui/experience-next/prefer-untracked-signal-getter': 'error',
             '@taiga-ui/experience-next/short-tui-imports': 'error',
@@ -1351,8 +1354,8 @@ function getTypeAwareRuleContext(context) {
     };
 }
 
-const createRule$j = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$j({
+const createRule$m = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$m({
     create(context, [configs]) {
         const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const flatConfig = configs.flat();
@@ -1520,9 +1523,9 @@ function isExternalPureTuple(typeChecker, type) {
     return typeArgs.every((item) => isClassType(item));
 }
 
-const createRule$i = ESLintUtils.RuleCreator((name) => name);
+const createRule$l = ESLintUtils.RuleCreator((name) => name);
 const MESSAGE_ID$7 = 'spreadArrays';
-var flatExports = createRule$i({
+var flatExports = createRule$l({
     create(context) {
         const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const arrays = new Map();
@@ -1802,8 +1805,8 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const createRule$h = ESLintUtils.RuleCreator((name) => name);
-const rule$k = createRule$h({
+const createRule$k = ESLintUtils.RuleCreator((name) => name);
+const rule$n = createRule$k({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -2064,7 +2067,7 @@ const config$2 = {
 const MESSAGE_ID$5 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
 const NG_DEV_MODE = 'ngDevMode';
-const createRule$g = ESLintUtils.RuleCreator((name) => name);
+const createRule$j = ESLintUtils.RuleCreator((name) => name);
 function getVariableName(node) {
     if (node.parent.type !== AST_NODE_TYPES$1.VariableDeclarator) {
         return undefined;
@@ -2132,7 +2135,7 @@ function getNgDevModeDeclarationFix(program, fixer) {
     }
     return fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
 }
-const rule$j = createRule$g({
+const rule$m = createRule$j({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -2181,6 +2184,88 @@ const rule$j = createRule$g({
     name: 'injection-token-description',
 });
 
+const createRule$i = ESLintUtils.RuleCreator((name) => name);
+function getResolvedVariable(sourceCode, node) {
+    const scope = sourceCode.getScope(node);
+    const reference = scope.references.find((item) => item.identifier === node);
+    return reference?.resolved ?? null;
+}
+const rule$l = createRule$i({
+    create(context) {
+        const { sourceCode } = context;
+        const namespaceImports = new Map();
+        const markNamespaceImportAsUsedLikeValue = (identifier) => {
+            const usage = namespaceImports.get(identifier.name);
+            if (!usage ||
+                usage.usedLikeValue ||
+                getResolvedVariable(sourceCode, identifier) !== usage.variable) {
+                return;
+            }
+            usage.usedLikeValue = true;
+        };
+        return {
+            'CallExpression > Identifier.callee'(node) {
+                markNamespaceImportAsUsedLikeValue(node);
+            },
+            ImportDeclaration(node) {
+                const namespaceImport = node.specifiers.find((specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier);
+                if (!namespaceImport) {
+                    return;
+                }
+                const [variable] = sourceCode.getDeclaredVariables(namespaceImport);
+                if (!variable) {
+                    return;
+                }
+                namespaceImports.set(namespaceImport.local.name, {
+                    node: namespaceImport,
+                    usedLikeValue: false,
+                    variable,
+                });
+            },
+            'NewExpression > Identifier.callee'(node) {
+                markNamespaceImportAsUsedLikeValue(node);
+            },
+            'Program:exit'() {
+                for (const usage of namespaceImports.values()) {
+                    if (!usage.usedLikeValue) {
+                        continue;
+                    }
+                    context.report({
+                        data: { name: usage.node.local.name },
+                        messageId: 'avoidCallableNamespaceImport',
+                        node: usage.node,
+                    });
+                }
+            },
+            'TaggedTemplateExpression > Identifier.tag'(node) {
+                markNamespaceImportAsUsedLikeValue(node);
+            },
+            TSImportEqualsDeclaration(node) {
+                if (node.moduleReference.type !== AST_NODE_TYPES.TSExternalModuleReference) {
+                    return;
+                }
+                context.report({
+                    data: { name: node.id.name },
+                    messageId: 'avoidImportEquals',
+                    node,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow legacy CommonJS interop import patterns such as `import = require(...)` and namespace imports used like callable values.',
+        },
+        messages: {
+            avoidCallableNamespaceImport: 'Namespace import "{{name}}" is used like a value instead of a namespace. This is a brittle interop pattern and often should become a default import.',
+            avoidImportEquals: '`import {{name}} = require(...)` is a legacy CommonJS import pattern.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-commonjs-import-patterns',
+});
+
 const MESSAGE_ID$4 = 'no-deep-imports';
 const ERROR_MESSAGE$2 = 'Deep imports of Taiga UI packages are prohibited';
 const CODE_EXTENSIONS = new Set([
@@ -2200,8 +2285,8 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const createRule$f = ESLintUtils.RuleCreator((name) => name);
-const rule$i = createRule$f({
+const createRule$h = ESLintUtils.RuleCreator((name) => name);
+const rule$k = createRule$h({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -2288,13 +2373,13 @@ const rule$i = createRule$f({
     name: 'no-deep-imports',
 });
 
-const createRule$e = ESLintUtils.RuleCreator((name) => name);
+const createRule$g = ESLintUtils.RuleCreator((name) => name);
 const resolveCacheByOptions = new WeakMap();
 const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-var noDeepImportsToIndexedPackages = createRule$e({
+var noDeepImportsToIndexedPackages = createRule$g({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -3014,7 +3099,7 @@ const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#react
 const UNTRACKED_RULES_README_URL = 'https://github.com/taiga-family/taiga-ui/blob/main/projects/eslint-plugin-experience-next/README.md';
 const createUntrackedRule = ESLintUtils.RuleCreator((name) => `${UNTRACKED_RULES_README_URL}#${name}`);
 
-const rule$h = createUntrackedRule({
+const rule$j = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -3153,8 +3238,8 @@ function getScopeRoot(node) {
     return (findAncestor(node, (ancestor) => ancestor.type === AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
 }
 
-const createRule$d = ESLintUtils.RuleCreator((name) => name);
-const rule$g = createRule$d({
+const createRule$f = ESLintUtils.RuleCreator((name) => name);
+const rule$i = createRule$f({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getEnclosingClass(node);
@@ -3216,6 +3301,38 @@ const rule$g = createRule$d({
     name: 'explicit-public-member',
 });
 
+const createRule$e = ESLintUtils.RuleCreator((name) => name);
+const rule$h = createRule$e({
+    create(context) {
+        const { sourceCode } = context;
+        return {
+            ImportDeclaration(node) {
+                const importAttributesToken = sourceCode.getTokenAfter(node.source);
+                if (importAttributesToken?.value !== 'assert') {
+                    return;
+                }
+                context.report({
+                    fix: (fixer) => fixer.replaceText(importAttributesToken, 'with'),
+                    messageId: 'useWithImportAttributes',
+                    node: importAttributesToken,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow legacy `assert { ... }` import assertions. Use `with { ... }` import attributes instead.',
+        },
+        fixable: 'code',
+        messages: {
+            useWithImportAttributes: 'Use `with { ... }` import attributes instead of `assert { ... }`.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-import-assertions',
+});
+
 function getParenthesizedInner(node) {
     const maybeNode = node;
     if (maybeNode.type === 'ParenthesizedExpression') {
@@ -3233,16 +3350,30 @@ function unwrapParenthesized(node) {
     return current;
 }
 
-const createRule$c = ESLintUtils.RuleCreator((name) => name);
-function isBooleanTrue(node) {
+const createRule$d = ESLintUtils.RuleCreator((name) => name);
+function isInfiniteLoopLiteral(node) {
     const unwrapped = unwrapParenthesized(node);
-    return unwrapped.type === AST_NODE_TYPES.Literal && unwrapped.value === true;
+    if (unwrapped.type !== AST_NODE_TYPES.Literal) {
+        return false;
+    }
+    return unwrapped.value === true || unwrapped.value === 1;
 }
-const rule$f = createRule$c({
+function isInfiniteLoopTest(test) {
+    return test === null || isInfiniteLoopLiteral(test);
+}
+const rule$g = createRule$d({
     create(context) {
         return {
+            DoWhileStatement(node) {
+                if (isInfiniteLoopTest(node.test)) {
+                    context.report({
+                        messageId: 'doWhileLoop',
+                        node: node.test,
+                    });
+                }
+            },
             ForStatement(node) {
-                if (!node.test) {
+                if (isInfiniteLoopTest(node.test)) {
                     context.report({
                         messageId: 'forLoop',
                         node,
@@ -3250,7 +3381,7 @@ const rule$f = createRule$c({
                 }
             },
             WhileStatement(node) {
-                if (isBooleanTrue(node.test)) {
+                if (isInfiniteLoopTest(node.test)) {
                     context.report({
                         messageId: 'whileLoop',
                         node: node.test,
@@ -3261,9 +3392,10 @@ const rule$f = createRule$c({
     },
     meta: {
         docs: {
-            description: 'Disallow `while (true)` and `for` loops without an explicit condition. Prefer loops with meaningful exit conditions.',
+            description: 'Disallow `for (;;)` / conditionals `for`, `while (true)`, and `do ... while (true)`. Prefer loops with meaningful exit conditions.',
         },
         messages: {
+            doWhileLoop: 'Use an explicit exit condition instead of `do ... while (true)`.',
             forLoop: 'Use an explicit exit condition instead of a `for` loop without a condition.',
             whileLoop: 'Use an explicit exit condition instead of `while (true)`.',
         },
@@ -3273,9 +3405,9 @@ const rule$f = createRule$c({
     name: 'no-infinite-loop',
 });
 
-const createRule$b = ESLintUtils.RuleCreator((name) => name);
+const createRule$c = ESLintUtils.RuleCreator((name) => name);
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$e = createRule$b({
+const rule$f = createRule$c({
     create(context) {
         return {
             Program(node) {
@@ -3313,8 +3445,8 @@ const rule$e = createRule$b({
     name: 'no-legacy-peer-deps',
 });
 
-const createRule$a = ESLintUtils.RuleCreator((name) => name);
-const rule$d = createRule$a({
+const createRule$b = ESLintUtils.RuleCreator((name) => name);
+const rule$e = createRule$b({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         return {
@@ -3471,7 +3603,7 @@ const config = {
     },
 };
 
-const createRule$9 = ESLintUtils.RuleCreator((name) => name);
+const createRule$a = ESLintUtils.RuleCreator((name) => name);
 function collectArrayExpressions(node) {
     const result = [];
     if (node.type === AST_NODE_TYPES.ArrayExpression) {
@@ -3497,7 +3629,7 @@ function collectArrayExpressions(node) {
     }
     return result;
 }
-const rule$c = createRule$9({
+const rule$d = createRule$a({
     create(context) {
         const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const ignoreTupleContextualTyping = context.options[0]?.ignoreTupleContextualTyping ?? true;
@@ -3666,7 +3798,7 @@ function getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap) {
     return checker.getSymbolAtLocation(tsNode) ?? null;
 }
 
-const createRule$8 = ESLintUtils.RuleCreator((name) => name);
+const createRule$9 = ESLintUtils.RuleCreator((name) => name);
 function isFunctionLikeScope(node) {
     return !!node && isFunctionLike(node);
 }
@@ -3923,7 +4055,7 @@ function inspectComputedBody(root, context, localScopes, visitedFunctions, repor
         return;
     });
 }
-const rule$b = createRule$8({
+const rule$c = createRule$9({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -3966,7 +4098,7 @@ const rule$b = createRule$8({
     name: 'no-side-effects-in-computed',
 });
 
-const rule$a = createUntrackedRule({
+const rule$b = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -4012,7 +4144,7 @@ const rule$a = createUntrackedRule({
     name: 'no-signal-reads-after-await-in-reactive-context',
 });
 
-const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+const createRule$8 = ESLintUtils.RuleCreator((name) => name);
 function collectParts(node) {
     if (node.type === AST_NODE_TYPES.BinaryExpression && node.operator === '+') {
         return [...collectParts(node.left), ...collectParts(node.right)];
@@ -4062,7 +4194,7 @@ function templateContent(template, renderExpr) {
         : ''}`)
         .join('');
 }
-const rule$9 = createRule$7({
+const rule$a = createRule$8({
     create(context) {
         const { sourceCode } = context;
         let parserServices = null;
@@ -4394,7 +4526,7 @@ function buildReactiveCallReplacement(outerUntrackedCall, reactiveCall, sourceCo
     }
     return dedent(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
 }
-const rule$8 = createUntrackedRule({
+const rule$9 = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -4522,7 +4654,7 @@ function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program
     });
     return found;
 }
-const rule$7 = createUntrackedRule({
+const rule$8 = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -4604,8 +4736,8 @@ const rule$7 = createUntrackedRule({
     name: 'no-useless-untracked',
 });
 
-const createRule$6 = ESLintUtils.RuleCreator((name) => name);
-const rule$6 = createRule$6({
+const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+const rule$7 = createRule$7({
     create(context, [{ printWidth }]) {
         const sourceCode = context.sourceCode;
         const getLineEndIndex = (lineStartIndex) => {
@@ -4857,7 +4989,7 @@ const rule$6 = createRule$6({
     name: 'object-single-line',
 });
 
-const createRule$5 = ESLintUtils.RuleCreator((name) => name);
+const createRule$6 = ESLintUtils.RuleCreator((name) => name);
 const EMPTY_ARGUMENT = '__EMPTY_ARGUMENT__';
 function isSupportedControlFlowStatement(node) {
     return (node.type === AST_NODE_TYPES.BreakStatement ||
@@ -4926,7 +5058,7 @@ function renderTest(node, sourceCode) {
     const text = sourceCode.getText(node);
     return needsParenthesesInOrChain(node) ? `(${text})` : text;
 }
-const rule$5 = createRule$5({
+const rule$6 = createRule$6({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -5006,8 +5138,8 @@ const rule$5 = createRule$5({
 
 const MESSAGE_ID$1 = 'prefer-deep-imports';
 const ERROR_MESSAGE = 'Import via root entry point is prohibited when nested entry points exist';
-const createRule$4 = ESLintUtils.RuleCreator(() => ERROR_MESSAGE);
-var preferDeepImports = createRule$4({
+const createRule$5 = ESLintUtils.RuleCreator(() => ERROR_MESSAGE);
+var preferDeepImports = createRule$5({
     create(context, [options]) {
         const allowedPackages = normalizeImportFilter(options.importFilter);
         const isStrictMode = options.strict ?? false;
@@ -5348,7 +5480,7 @@ function buildRewrittenImports(node, baseImportPath, symbolToEntryPoint) {
     return importStatements.join('\n');
 }
 
-const createRule$3 = ESLintUtils.RuleCreator((name) => name);
+const createRule$4 = ESLintUtils.RuleCreator((name) => name);
 function getPushCall(node) {
     if (node.expression.type !== AST_NODE_TYPES.CallExpression) {
         return null;
@@ -5363,7 +5495,7 @@ function getPushCall(node) {
     }
     return call;
 }
-const rule$4 = createRule$3({
+const rule$5 = createRule$4({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -5441,6 +5573,53 @@ const rule$4 = createRule$3({
     name: 'prefer-multi-arg-push',
 });
 
+const createRule$3 = ESLintUtils.RuleCreator((name) => name);
+function getModuleKeywordToken(sourceCode, node) {
+    const firstToken = sourceCode.getFirstToken(node);
+    if (!firstToken) {
+        return null;
+    }
+    if (firstToken.value === 'declare') {
+        return sourceCode.getTokenAfter(firstToken) ?? null;
+    }
+    return firstToken;
+}
+const rule$4 = createRule$3({
+    create(context) {
+        const { sourceCode } = context;
+        return {
+            TSModuleDeclaration(node) {
+                if (node.kind !== 'module' ||
+                    node.global ||
+                    node.id.type === AST_NODE_TYPES.Literal) {
+                    return;
+                }
+                const moduleKeywordToken = getModuleKeywordToken(sourceCode, node);
+                if (moduleKeywordToken?.value !== 'module') {
+                    return;
+                }
+                context.report({
+                    fix: (fixer) => fixer.replaceText(moduleKeywordToken, 'namespace'),
+                    messageId: 'useNamespaceKeyword',
+                    node: moduleKeywordToken,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Prefer `namespace Foo {}` over the older `module Foo {}` syntax for TypeScript namespace declarations.',
+        },
+        fixable: 'code',
+        messages: {
+            useNamespaceKeyword: 'Use `namespace` instead of `module` for TypeScript namespace declarations.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'prefer-namespace-keyword',
+});
+
 /**
  * prefer-untracked-incidental-signal-reads
  *
@@ -6223,28 +6402,31 @@ const plugin = {
         'class-property-naming': classPropertyNaming,
         'decorator-key-sort': config$3,
         'flat-exports': flatExports,
-        'host-attributes-sort': rule$k,
+        'host-attributes-sort': rule$n,
         'html-logical-properties': config$2,
-        'injection-token-description': rule$j,
-        'no-deep-imports': rule$i,
+        'injection-token-description': rule$m,
+        'no-commonjs-import-patterns': rule$l,
+        'no-deep-imports': rule$k,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
-        'no-fully-untracked-effect': rule$h,
+        'no-fully-untracked-effect': rule$j,
         'no-href-with-router-link': config$1,
-        'no-implicit-public': rule$g,
-        'no-infinite-loop': rule$f,
-        'no-legacy-peer-deps': rule$e,
-        'no-playwright-empty-fill': rule$d,
+        'no-implicit-public': rule$i,
+        'no-import-assertions': rule$h,
+        'no-infinite-loop': rule$g,
+        'no-legacy-peer-deps': rule$f,
+        'no-playwright-empty-fill': rule$e,
         'no-project-as-in-ng-template': config,
-        'no-redundant-type-annotation': rule$c,
-        'no-side-effects-in-computed': rule$b,
-        'no-signal-reads-after-await-in-reactive-context': rule$a,
-        'no-string-literal-concat': rule$9,
-        'no-untracked-outside-reactive-context': rule$8,
-        'no-useless-untracked': rule$7,
-        'object-single-line': rule$6,
-        'prefer-combined-if-control-flow': rule$5,
+        'no-redundant-type-annotation': rule$d,
+        'no-side-effects-in-computed': rule$c,
+        'no-signal-reads-after-await-in-reactive-context': rule$b,
+        'no-string-literal-concat': rule$a,
+        'no-untracked-outside-reactive-context': rule$9,
+        'no-useless-untracked': rule$8,
+        'object-single-line': rule$7,
+        'prefer-combined-if-control-flow': rule$6,
         'prefer-deep-imports': preferDeepImports,
-        'prefer-multi-arg-push': rule$4,
+        'prefer-multi-arg-push': rule$5,
+        'prefer-namespace-keyword': rule$4,
         'prefer-untracked-incidental-signal-reads': rule$3,
         'prefer-untracked-signal-getter': rule$2,
         'short-tui-imports': rule$1,

package/package.json

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

package/rules/no-commonjs-import-patterns.d.ts

@@ -0,0 +1,6 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+type MessageId = 'avoidCallableNamespaceImport' | 'avoidImportEquals';
+export declare const rule: ESLintUtils.RuleModule<MessageId, [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default rule;

package/rules/no-import-assertions.d.ts

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

package/rules/no-infinite-loop.d.ts

@@ -1,5 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-type MessageId = 'forLoop' | 'whileLoop';
+type MessageId = 'doWhileLoop' | 'forLoop' | 'whileLoop';
 export declare const rule: ESLintUtils.RuleModule<MessageId, [], unknown, ESLintUtils.RuleListener> & {
     name: string;
 };

package/rules/prefer-namespace-keyword.d.ts

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