@taiga-ui/eslint-plugin-experience-next 0.474.0 → 0.476.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.474.0",
+  "version": "0.476.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-fully-untracked-effect.d.ts

@@ -1,5 +1,4 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const rule: ESLintUtils.RuleModule<"noTrackedReads", [], unknown, ESLintUtils.RuleListener> & {
+export declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noTrackedReads", [], unknown, import("@typescript-eslint/utils/ts-eslint").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

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

package/rules/no-signal-reads-after-await-in-reactive-context.d.ts

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

package/rules/no-untracked-outside-reactive-context.d.ts

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

package/rules/no-useless-untracked.d.ts

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

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;

package/rules/prefer-untracked-incidental-signal-reads.d.ts

@@ -1,30 +1,4 @@
-/**
- * prefer-untracked-incidental-signal-reads
- *
- * Conservatively flags signal reads inside reactive callbacks that appear to be
- * incidental — they provide only a snapshot value passed to a side-effecting
- * consumer such as a signal write or DOM imperative call — and therefore
- * probably should be wrapped in `untracked(...)`.
- *
- * Design principle: prefer false-negatives over false-positives.
- * This rule only reports patterns it can confidently identify as suspicious.
- *
- * Limitations
- * -----------
- * Whether a signal read *should* be tracked is a question of developer intent,
- * not syntax. The rule relies on heuristics (type-based signal detection,
- * structural pattern matching) and will inevitably produce:
- *
- *  - False negatives: incidental reads that do not match the heuristics.
- *  - False positives (rare): reads that look incidental but are intentional
- *    dependencies (e.g. the developer intentionally re-runs the effect when
- *    `mousePosition` changes to keep `position` in sync).
- *
- * Always review suggestions before accepting the fix. If the reported read
- * IS meant to be a tracked dependency, disable the rule for that line.
- */
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const rule: ESLintUtils.RuleModule<"incidentalRead", [], unknown, ESLintUtils.RuleListener> & {
+export declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"incidentalRead", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };
 export default rule;

package/rules/prefer-untracked-signal-getter.d.ts

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

package/rules/utils/{angular-signals.d.ts → angular/angular-signals.d.ts}

@@ -1,11 +1,10 @@
 import { type TSESTree } from '@typescript-eslint/utils';
 import ts from 'typescript';
+import { type NodeMap } from '../typescript/node-map';
+export { walkAfterAsyncBoundaryAst, walkAst, walkSynchronousAst } from '../ast/ast-walk';
+export type { NodeMap } from '../typescript/node-map';
 export { findAngularCoreImport, findAngularCoreImports, findAngularCoreImportSpecifier, findRuntimeAngularCoreImport, getLocalNameForImport, } from './angular-imports';
-export { walkAfterAsyncBoundaryAst, walkAst, walkSynchronousAst } from './ast-walk';
-export interface NodeMap {
-    get(node: TSESTree.Node): ts.Node | undefined;
-}
-type ReactiveCallback = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;
+export type ReactiveCallback = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;
 export interface ReactiveScope {
     readonly callback: ReactiveCallback;
     readonly kind: string;
@@ -16,6 +15,8 @@ export interface SignalUsage {
     readonly reads: TSESTree.CallExpression[];
     readonly writes: TSESTree.CallExpression[];
 }
+export declare function isReactiveCallback(node: TSESTree.Node | null | undefined): node is ReactiveCallback;
+export declare function getReactiveCallbackArgument(node: TSESTree.CallExpression): ReactiveCallback | null;
 export declare function isAngularEffectCall(node: TSESTree.CallExpression, program: TSESTree.Program): boolean;
 export declare function isAngularInjectCall(node: TSESTree.CallExpression, program: TSESTree.Program): boolean;
 export declare function isAngularUntrackedCall(node: TSESTree.CallExpression, program: TSESTree.Program): boolean;
@@ -46,3 +47,6 @@ export declare function isGetterMemberAccess(node: TSESTree.MemberExpression, ch
  * already hidden from tracking).
  */
 export declare function collectSignalUsages(scopeNode: TSESTree.Node, checker: ts.TypeChecker, esTreeNodeToTSNodeMap: NodeMap, program: TSESTree.Program): SignalUsage;
+export declare function collectSignalReadsInsideUntracked(root: TSESTree.Node, checker: ts.TypeChecker, esTreeNodeToTSNodeMap: NodeMap, program: TSESTree.Program): TSESTree.CallExpression[];
+export declare function isReactiveOwnerCall(node: TSESTree.Node, program: TSESTree.Program): node is TSESTree.CallExpression;
+export declare function getReturnedReactiveOwnerCall(node: TSESTree.CallExpression, program: TSESTree.Program): TSESTree.CallExpression | null;

package/rules/utils/angular/pipes.d.ts

@@ -0,0 +1,2 @@
+import { type ClassMember } from '../ast/ancestors';
+export declare function isPipeTransformMember(member: ClassMember): boolean;

package/rules/utils/angular/providers.d.ts

@@ -0,0 +1,3 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare function isAngularInjectionTokenFactoryFunction(fn: TSESTree.FunctionLike, program: TSESTree.Program): boolean;
+export declare function isAngularUseFactoryFunction(fn: TSESTree.FunctionLike): boolean;

package/rules/utils/ast/ancestors.d.ts

@@ -0,0 +1,12 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export type ClassLike = TSESTree.ClassDeclaration | TSESTree.ClassExpression;
+export type ClassMember = TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
+export declare function findAncestor<T extends TSESTree.Node>(node: TSESTree.Node | null | undefined, predicate: (ancestor: TSESTree.Node) => ancestor is T): T | null;
+export declare function findSelfOrAncestor<T extends TSESTree.Node>(node: TSESTree.Node | null | undefined, predicate: (candidate: TSESTree.Node) => candidate is T): T | null;
+export declare function hasAncestor(node: TSESTree.Node | null | undefined, predicate: (ancestor: TSESTree.Node) => boolean): boolean;
+export declare function isNodeInside(node: TSESTree.Node, ancestor: TSESTree.Node): boolean;
+export declare function isNodeInsideAny(node: TSESTree.Node, ancestors: readonly TSESTree.Node[]): boolean;
+export declare function getEnclosingFunction(node: TSESTree.Node | null | undefined): TSESTree.FunctionLike | null;
+export declare function getEnclosingClass(node: TSESTree.Node | null | undefined): ClassLike | null;
+export declare function getEnclosingClassMember(node: TSESTree.Node | null | undefined): ClassMember | null;
+export declare function getScopeRoot(node: TSESTree.Node): TSESTree.Node;

package/rules/utils/{ast-walk.d.ts → ast/ast-walk.d.ts}

@@ -1,4 +1,5 @@
 import { type TSESTree } from '@typescript-eslint/utils';
+export declare function isFunctionLike(node: TSESTree.Node): node is TSESTree.FunctionLike;
 /**
  * Walks the synchronous portion of a reactive scope.
  *

package/rules/utils/ast/call-expressions.d.ts

@@ -0,0 +1,2 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare function collectCallExpressions(root: TSESTree.Node): TSESTree.CallExpression[];

package/rules/utils/ast/mutation-targets.d.ts

@@ -0,0 +1,4 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export type MutationTarget = TSESTree.Identifier | TSESTree.MemberExpression;
+export declare function unwrapMutationTarget(node: TSESTree.Node): TSESTree.Node;
+export declare function collectMutationTargets(node: TSESTree.Node): MutationTarget[];

package/rules/utils/ast/parenthesized.d.ts

@@ -0,0 +1,3 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare function getParenthesizedInner(node: TSESTree.Node): TSESTree.Node | null;
+export declare function unwrapParenthesized(node: TSESTree.Node): TSESTree.Node;

package/rules/utils/ast/property-names.d.ts

@@ -0,0 +1,5 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare function getStaticPropertyName(key: TSESTree.PropertyName): string | null;
+export declare function getObjectPropertyName(node: TSESTree.Property): string | null;
+export declare function getMemberExpressionPropertyName(node: TSESTree.MemberExpression): string | null;
+export declare function getClassMemberName(member: TSESTree.MethodDefinition | TSESTree.PropertyDefinition): string | null;

package/rules/utils/ast/returned-expression.d.ts

@@ -0,0 +1,2 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare function getReturnedExpression(node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression): TSESTree.Expression | null;

package/rules/utils/ast/string-literals.d.ts

@@ -0,0 +1,10 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export type StringLiteral = TSESTree.Literal & {
+    value: string;
+};
+export type StaticStringNode = StringLiteral | TSESTree.TemplateLiteral;
+export declare function isStringLiteral(node: TSESTree.Node | null | undefined): node is StringLiteral;
+export declare function isStaticTemplateLiteral(node: TSESTree.Node | null | undefined): node is TSESTree.TemplateLiteral;
+export declare function isStaticString(node: TSESTree.Node | null | undefined): node is StaticStringNode;
+export declare function getStaticStringValue(node: TSESTree.Node | null | undefined): string | null;
+export declare function isEmptyStaticString(node: TSESTree.Node | null | undefined): boolean;

package/rules/utils/text/dedent.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Removes `extraSpaces` leading spaces from every line of `text` that starts
+ * with at least that many spaces.
+ */
+export declare function dedent(text: string, extraSpaces: number): string;

package/rules/utils/typescript/decorators.d.ts

@@ -0,0 +1,2 @@
+import { type ClassLike } from '../ast/ancestors';
+export declare function hasNamedDecorator(node: ClassLike, name: string): boolean;

package/rules/utils/typescript/function-usage.d.ts

@@ -0,0 +1,5 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+import type ts from 'typescript';
+import { type NodeMap } from './node-map';
+export declare function isDirectCallOrNewArgument(node: TSESTree.FunctionLike): boolean;
+export declare function isStoredFunctionUsedAsCallOrNewArgument(fn: TSESTree.FunctionLike, checker: ts.TypeChecker, esTreeNodeToTSNodeMap: NodeMap): boolean;

package/rules/utils/typescript/node-map.d.ts

@@ -0,0 +1,6 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+import type ts from 'typescript';
+export interface NodeMap {
+    get(node: TSESTree.Node): ts.Node | undefined;
+}
+export type TsNodeToESTreeNodeMap = Map<ts.Node, TSESTree.Node>;

package/rules/utils/typescript/symbols.d.ts

@@ -0,0 +1,4 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+import type ts from 'typescript';
+import { type NodeMap } from './node-map';
+export declare function getSymbolAtNode(node: TSESTree.Node, checker: ts.TypeChecker, esTreeNodeToTSNodeMap: NodeMap): ts.Symbol | null;

package/rules/utils/typescript/type-aware-context.d.ts

@@ -0,0 +1,14 @@
+import { ESLintUtils, type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import type ts from 'typescript';
+type ParserServices = ReturnType<typeof ESLintUtils.getParserServices>;
+export interface TypeAwareRuleContext {
+    readonly checker: ts.TypeChecker;
+    readonly esTreeNodeToTSNodeMap: ParserServices['esTreeNodeToTSNodeMap'];
+    readonly parserServices: ParserServices;
+    readonly program: TSESTree.Program;
+    readonly sourceCode: Readonly<TSESLint.SourceCode>;
+    readonly tsNodeToESTreeNodeMap: ParserServices['tsNodeToESTreeNodeMap'];
+    readonly tsProgram: ts.Program;
+}
+export declare function getTypeAwareRuleContext<MessageId extends string, Options extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<MessageId, Options>>): TypeAwareRuleContext;
+export {};