eslint-plugin-sonarjs 4.0.2 → 4.1.0

package/types/helpers/dependency-manifests/resolvers/types.d.ts

@@ -0,0 +1,46 @@
+import { Minimatch } from 'minimatch';
+import type { NormalizedAbsolutePath } from '../../files.js';
+import type { Filesystem } from '../../find-up/find-minimatch.js';
+import type { PackageJson } from 'type-fest';
+type ImportMap = Record<string, unknown>;
+export type DependenciesList = Map<string | Minimatch, string | undefined>;
+export type ModuleType = 'module' | 'commonjs';
+export declare const DEFINITELY_TYPED = "@types/";
+type PackageJsonManifest = {
+    type: 'package-json';
+    manifest: PackageJson;
+};
+export type DenoJson = {
+    imports?: ImportMap;
+    workspace?: string[] | {
+        members?: string[];
+    };
+};
+type DenoManifest = {
+    type: 'deno';
+    manifest: DenoJson;
+};
+export type DependencyManifest = (PackageJsonManifest | DenoManifest) & {
+    readonly dependencies: DependenciesList;
+    readonly moduleType: ModuleType | undefined;
+};
+/**
+ * Strategy interface for resolving dependency manifests of a specific type from a single
+ * directory. Implement this interface and register it in {@link MANIFEST_RESOLVERS} to add
+ * support for a new package manager or manifest format (e.g., Bun).
+ */
+export interface ManifestResolver {
+    resolve(dir: NormalizedAbsolutePath, topDir: NormalizedAbsolutePath, fileSystem?: Filesystem): DependencyManifest[];
+}
+type Catalog = Record<string, string>;
+export type CatalogSource = {
+    catalog?: Catalog;
+    catalogs?: Record<string, Catalog>;
+};
+export type Workspace = CatalogSource & {
+    packages?: string[];
+};
+export type ExtendedPackageJson = PackageJson & CatalogSource & {
+    workspaces?: PackageJson.WorkspacePattern[] | Workspace;
+};
+export {};

package/types/helpers/files.d.ts

@@ -1,31 +1,17 @@
-/**
- * Branded types for Unix-style paths (forward slashes, normalized).
- *
- * We use phantom branding here (declare const + type intersection) rather than
- * runtime branding (like in tsconfig/options.ts with actual Symbol properties).
- * This is because:
- * - Paths are primitive strings, not objects that can hold extra properties
- * - We only need compile-time safety, not runtime verification
- * - No runtime overhead - branded paths are just regular strings at runtime
- *
- * @see tsconfig/options.ts for runtime branding of objects via Symbol properties
- */
-declare const NormalizedPathBrand: unique symbol;
-declare const NormalizedAbsolutePathBrand: unique symbol;
 export type NormalizedPath = string & {
-    readonly [NormalizedPathBrand]: never;
+    readonly __normalizedPathBrand: 'NormalizedPath';
 };
 export type NormalizedAbsolutePath = string & {
-    readonly [NormalizedAbsolutePathBrand]: never;
+    readonly __normalizedAbsolutePathBrand: 'NormalizedAbsolutePath';
+};
+export type File = {
+    readonly filePath: NormalizedAbsolutePath;
+    readonly fileContent: string;
 };
 /**
  * Root path constant for Unix filesystem
  */
 export declare const ROOT_PATH: NormalizedAbsolutePath;
-export type File = {
-    readonly path: NormalizedAbsolutePath;
-    readonly content: Buffer | string;
-};
 /**
  * Removes any Byte Order Marker (BOM) from a string's head
  *
@@ -55,6 +41,13 @@ export declare function normalizePath(filePath: string): NormalizedPath;
  */
 export declare function normalizeToAbsolutePath(filePath: string, baseDir?: NormalizedAbsolutePath): NormalizedAbsolutePath;
 export declare function isRoot(file: string): boolean;
+export declare function assertNestedPath(from: NormalizedAbsolutePath, topDir: NormalizedAbsolutePath): void;
+/**
+ * Returns the filesystem root that contains the given absolute path.
+ * Examples: '/a/b' -> '/', 'C:/a/b' -> 'C:/', 'D:/foo' -> 'D:/'.
+ * Used as a cross-platform "no upper bound" sentinel for find-up callers.
+ */
+export declare function getPathRoot(filePath: NormalizedAbsolutePath): NormalizedAbsolutePath;
 export declare function isAbsolutePath(path: string): boolean;
 /**
  * Type-safe dirname that preserves the NormalizedAbsolutePath brand.
@@ -63,6 +56,7 @@ export declare function isAbsolutePath(path: string): boolean;
  * @returns the parent directory as a branded NormalizedAbsolutePath
  */
 export declare function dirnamePath(filePath: NormalizedAbsolutePath): NormalizedAbsolutePath;
+export declare function relativeToAncestorPath(filePath: NormalizedAbsolutePath, topDir: NormalizedAbsolutePath): string | undefined;
 /**
  * Type-safe path join that preserves the NormalizedAbsolutePath brand.
  * Joins path segments using posix separators.
@@ -77,4 +71,3 @@ export declare function joinPaths(base: NormalizedAbsolutePath, ...segments: str
  * @returns the filename (last segment of the path)
  */
 export declare function basenamePath(filePath: NormalizedPath | NormalizedAbsolutePath): string;
-export {};

package/types/helpers/generate-meta.d.ts

@@ -2,6 +2,7 @@ import type { Rule } from 'eslint';
 import type { RulesMeta } from '@eslint/core';
 import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
 import type { ESLintConfiguration } from './configs.js';
+import type { ModuleType } from './dependency-manifests/resolvers/types.js';
 export type SonarMeta = {
     meta: Rule.RuleMetaData & {
         docs?: {
@@ -12,6 +13,7 @@ export type SonarMeta = {
     eslintId: string;
     scope: 'All' | 'Main' | 'Tests';
     languages: ('ts' | 'js')[];
+    skipOnGeneratedSource?: boolean;
     blacklistedExtensions?: string[];
     schema?: JSONSchema4;
     hasSecondaries?: boolean;
@@ -23,5 +25,8 @@ export type SonarMeta = {
         externalRule: string;
     }[];
     quickFixMessage?: string;
+    requiredDependency: readonly string[];
+    requiredEcmaVersion?: number;
+    requiredModuleType?: ModuleType;
 };
 export declare function generateMeta(sonarMeta: SonarMeta, ruleMeta?: RulesMeta): RulesMeta;

package/types/helpers/internal-metrics.d.ts

@@ -0,0 +1,5 @@
+export interface InternalMetricsSink {
+    cognitiveComplexity?: number;
+}
+export declare function toInternalMetricsSettings(metricsSink: InternalMetricsSink): Record<string, unknown>;
+export declare function getInternalMetricsSink(settings: unknown): InternalMetricsSink | undefined;

package/types/helpers/mocha-style-test-frameworks.d.ts

@@ -0,0 +1,19 @@
+import type { Rule } from 'eslint';
+import type estree from 'estree';
+export declare const SUPPORTED_TEST_FRAMEWORKS: string[];
+export declare const TEST_FUNCTION_NAMES: string[];
+export declare const SUITE_FUNCTION_NAMES: string[];
+export declare const PLAYWRIGHT_TEST_MODIFIERS: Set<string>;
+export declare const PLAYWRIGHT_DESCRIBE_MODIFIERS: Set<string>;
+export declare const PLAYWRIGHT_DESCRIBE_FOCUS_MODIFIER = "only";
+export declare function isMochaTestConstruct(context: Rule.RuleContext, node: estree.CallExpression, constructs: string[]): boolean;
+export declare function isConcreteMochaTestModifier(context: Rule.RuleContext, modifier: string): boolean;
+export declare function getMochaCalleeParts(node: estree.Node): {
+    base: estree.Identifier;
+    modifiers: string[];
+} | undefined;
+export declare function getMochaConstructName(context: Rule.RuleContext, identifier: estree.Identifier): string | undefined;
+export declare function hasCallback(node: estree.CallExpression): boolean;
+export declare function getStaticTitle(node: estree.Node): string | undefined;
+export declare function getPlaywrightTestQualifiers(context: Rule.RuleContext, node: estree.Node): string[] | undefined;
+export declare function getPlaywrightDescribeQualifiers(node: estree.Node): string[] | undefined;

package/types/helpers/mocha.d.ts

@@ -19,3 +19,10 @@ export declare function isTestCase(node: estree.Node): boolean;
  * @returns
  */
 export declare function isDescribeCase(node: estree.Node): boolean;
+/**
+ * returns true if the node is a lifecycle hook
+ *
+ * @param node
+ * @returns
+ */
+export declare function isLifecycleHook(node: estree.Node): boolean;

package/types/helpers/module.d.ts

@@ -1,15 +1,21 @@
-import type { Rule, Scope } from 'eslint';
+import type { Rule, Scope, SourceCode } from 'eslint';
 import type estree from 'estree';
 import { type Node } from './ast.js';
+export declare function getImportDeclarations(context: Rule.RuleContext): estree.ImportDeclaration[];
 /**
- * Checks if the current file is an ES module based on sourceType.
- *
- * The parser sets sourceType based on file extension (.mjs/.cjs),
- * package.json "type" field, and ESLint configuration.
+ * Clears the caches related to the given source file
  */
-export declare function isESModule(context: Rule.RuleContext): boolean;
-export declare function getImportDeclarations(context: Rule.RuleContext): estree.ImportDeclaration[];
-export declare function getRequireCalls(context: Rule.RuleContext): estree.CallExpression[];
+export declare function clearFileCaches(): void;
+export declare function getCurrentFileImports(sourceCode: SourceCode): ReadonlySet<string>;
+/**
+ * Checks if the file imports any of the specified modules, either via require() calls or import declarations.
+ */
+export declare function importsModule(context: Rule.RuleContext, moduleNames: string[]): boolean;
+/**
+ * Checks if at least one of the specified imports is imported (via import or require) in the file
+ * or if at least one of the specified dependencies is listed in the corresponding dependency manifest.
+ */
+export declare function importsOrDependsOnModule(context: Rule.RuleContext, imports: string[], dependencies: string[]): boolean;
 export declare function isRequire(node: Node): node is estree.CallExpression;
 /**
  * Returns the fully qualified name of ESLint node

package/types/helpers/numbers.d.ts

@@ -0,0 +1,4 @@
+export declare function isExactlyRepresentableAsBinaryFraction(raw: string): boolean;
+export declare function isExactlyRepresentableIntegerDivision(leftValue: number, rightValue: number): boolean;
+export declare function greatestCommonDivisor(left: bigint, right: bigint): bigint;
+export declare function isPowerOfTwo(value: bigint): boolean;

package/types/helpers/playwright.d.ts

@@ -0,0 +1,2 @@
+import type estree from 'estree';
+export declare function isDescribe(node: estree.Node | undefined): boolean;

package/types/helpers/regex/extract.d.ts

@@ -1,8 +1,12 @@
 import type estree from 'estree';
 import * as regexpp from '@eslint-community/regexpp';
 import type { Rule } from 'eslint';
-export declare function getParsedRegex(node: estree.Node, context: Rule.RuleContext): regexpp.AST.RegExpLiteral | null;
-export declare function getPatternFromNode(node: estree.Node, context: Rule.RuleContext): {
+type ExtractedRegexPattern = {
     pattern: string;
     flags: string;
-} | null;
+    seams: number[];
+    isPureLiteral: boolean;
+};
+export declare function getParsedRegex(node: estree.Node, context: Rule.RuleContext): regexpp.AST.RegExpLiteral | null;
+export declare function getPatternFromNode(node: estree.Node, context: Rule.RuleContext): ExtractedRegexPattern | null;
+export {};

package/types/helpers/sinon.d.ts

@@ -2,6 +2,5 @@ import type { Rule } from 'eslint';
 import type estree from 'estree';
 import type { ParserServicesWithTypeInformation } from '@typescript-eslint/utils';
 import ts from 'typescript';
-export declare function isImported(context: Rule.RuleContext): boolean;
 export declare function isAssertion(context: Rule.RuleContext, node: estree.Node): boolean;
 export declare function isTSAssertion(services: ParserServicesWithTypeInformation, node: ts.Node): boolean;

package/types/helpers/supertest.d.ts

@@ -2,6 +2,5 @@ import type { Rule } from 'eslint';
 import type estree from 'estree';
 import type { ParserServicesWithTypeInformation } from '@typescript-eslint/utils';
 import ts from 'typescript';
-export declare function isImported(context: Rule.RuleContext): boolean;
 export declare function isAssertion(context: Rule.RuleContext, node: estree.Node): boolean;
 export declare function isTSAssertion(services: ParserServicesWithTypeInformation, node: ts.Node): boolean;

package/types/helpers/test-file-pattern.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_TEST_FILE_EXTENSIONS: string[];
+/**
+ * Checks whether a file path matches a test file pattern.
+ *
+ * @param filePath the file path to test.
+ * @param extensions the allowed test file extensions.
+ * @returns true when the path looks like a test file.
+ */
+export declare function isTestFile(filePath: string, extensions?: string[]): boolean;
+/**
+ * Checks whether a file path looks test-related.
+ *
+ * @param filePath the file path to test.
+ * @param extensions the allowed test file extensions.
+ * @returns true when the path looks test-related.
+ */
+export declare function isTestRelatedFile(filePath: string, extensions?: string[]): boolean;

package/types/helpers/type-origin.d.ts

@@ -0,0 +1,31 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { RequiredParserServices } from './parser-services.js';
+export type TypeOrigin = {
+    internal: TSESTree.TypeNode[];
+    external: TSESTree.TypeNode[];
+};
+/**
+ * Partitions the syntactic members of a type annotation into "internal"
+ * (user-writable in this project) and "external" (declared in node_modules
+ * or in the TypeScript default lib).
+ *
+ * Operates on the syntactic AST node, not on a resolved `ts.Type`. Returning
+ * the original AST nodes lets callers produce locations, suggestions, or
+ * fixes targeting exactly what the user wrote.
+ *
+ * Classification rules per top-level member:
+ * - Keyword / literal types -> internal (the user wrote them directly).
+ * - TSTypeReference -> resolves the type name to a symbol and inspects its
+ *   declarations. A reference is external only when ALL declarations live in
+ *   files that satisfy `isSourceFileFromExternalLibrary` or
+ *   `isSourceFileDefaultLibrary`. Any local declaration (declaration-merging
+ *   escape hatch) makes the reference internal.
+ * - Any other composite constructor (TSIntersectionType, TSArrayType,
+ *   TSTypeLiteral, TSConditionalType, ...) -> internal at the top level. We
+ *   do not recurse; callers can if they need to.
+ *
+ * Known limitation: alias chains are not followed. If the user re-aliases an
+ * external type locally (e.g. `type Inner = ReactNode`), the local alias is
+ * internal because the user has a place to edit.
+ */
+export declare function classifyTypesByOrigin(typeNode: TSESTree.TypeNode, services: RequiredParserServices): TypeOrigin;

package/types/helpers/type.d.ts

@@ -4,6 +4,9 @@ import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import type { RequiredParserServices } from './parser-services.js';
 import type { Rule } from 'eslint';
 export type RuleContext = TSESLint.RuleContext<string, string[]>;
+/**
+ * Returns true when `node` resolves to the built-in `Array` type.
+ */
 export declare function isArray(node: estree.Node, services: RequiredParserServices): boolean;
 /**
  * TypeScript provides a set of utility types to facilitate type transformations.
@@ -18,14 +21,41 @@ export declare const UTILITY_TYPES: Set<string>;
  * @returns
  */
 export declare function isTypedArray(node: estree.Node, services: RequiredParserServices): boolean;
+/**
+ * Returns true when `node` resolves to a string-like type.
+ */
 export declare function isString(node: estree.Node, services: RequiredParserServices): boolean;
+/**
+ * Returns true when `node` resolves to a number-like type.
+ */
 export declare function isNumber(node: estree.Node, services: RequiredParserServices): boolean;
+/**
+ * Returns true when `type` is bigint-like.
+ */
 export declare function isBigIntType(type: ts.Type): boolean;
+/**
+ * Returns true when `type` is number-like.
+ */
 export declare function isNumberType(type: ts.Type): boolean;
+/**
+ * Returns true when `type` is string-like.
+ */
 export declare function isStringType(type: ts.Type): boolean;
+/**
+ * Returns true when `node` resolves to a function type.
+ */
 export declare function isFunction(node: estree.Node, services: RequiredParserServices): boolean;
+/**
+ * Returns true when `node` resolves to a union type.
+ */
 export declare function isUnion(node: estree.Node, services: RequiredParserServices): boolean;
+/**
+ * Returns true when `node` resolves to `undefined`, `null`, or a union containing either.
+ */
 export declare function isUndefinedOrNull(node: estree.Node, services: RequiredParserServices): boolean;
+/**
+ * Returns true when `node` resolves to a thenable type.
+ */
 export declare function isThenable(node: estree.Node, services: RequiredParserServices): boolean;
 /**
  * Checks if a node's type is either:
@@ -37,7 +67,35 @@ export declare function isThenable(node: estree.Node, services: RequiredParserSe
  * optional async callbacks (() => void | Promise<void>).
  */
 export declare function isThenableOrVoidUnion(node: estree.Node, services: RequiredParserServices): boolean;
+/**
+ * Returns true when `type` is exactly `any`.
+ */
 export declare function isAny(type: ts.Type): boolean;
+/**
+ * Returns true when both types are specific enough to compare (neither `any`
+ * nor `unknown`) and are mutually assignable.
+ *
+ * Mutual assignability is stricter than symbol equality for generic aliases:
+ * `Props<User>` and `Props<Product>` share the same alias symbol, but they are
+ * not mutually assignable and therefore do not represent the same effective type.
+ */
+export declare function areMutuallyAssignableTypes(checker: ts.TypeChecker, left: ts.Type | undefined, right: ts.Type | undefined): boolean;
+/**
+ * Returns true when both types come from the same named declaration and, for
+ * generic declarations, are instantiated with the same type arguments.
+ *
+ * The comparison has two steps:
+ * 1. the declarations must resolve to the same symbol
+ * 2. each type argument must match through `areSameTypeArguments(...)`
+ *
+ * That helper can call back into this function for named type arguments, so
+ * generic comparisons recurse through nested declarations.
+ *
+ * This is intentionally stricter than structural equality: `Props<User>` and
+ * `Props<Product>` are different, and `Props<User>` also stays different from
+ * `Props<{ id: string }>` even if the shapes happen to match.
+ */
+export declare function areSameTypeDeclarations(checker: ts.TypeChecker, left: ts.Type | undefined, right: ts.Type | undefined): boolean;
 /**
  * Checks if a node has a generic type like:
  *
@@ -50,9 +108,21 @@ export declare function isAny(type: ts.Type): boolean;
  * @returns
  */
 export declare function isGenericType(node: TSESTree.Node, services: RequiredParserServices): boolean;
+/**
+ * Returns the TypeScript type resolved at `node`.
+ */
 export declare function getTypeFromTreeNode(node: estree.Node, services: RequiredParserServices): ts.Type;
+/**
+ * Returns the widened string representation of the type resolved at `node`.
+ */
 export declare function getTypeAsString(node: estree.Node, services: RequiredParserServices): string;
+/**
+ * Returns the symbol resolved at `node`, if any.
+ */
 export declare function getSymbolAtLocation(node: estree.Node, services: RequiredParserServices): ts.Symbol | undefined;
+/**
+ * Returns the resolved call signature for the call-like expression at `node`.
+ */
 export declare function getSignatureFromCallee(node: estree.Node, services: RequiredParserServices): ts.Signature | undefined;
 /**
  * This function checks if a type may correspond to an array type. Beyond simple array types, it will also
@@ -79,16 +149,37 @@ export declare function isNumberArray(type: ts.Type, services: RequiredParserSer
  * @param services The services used to get access to the TypeScript type checker
  */
 export declare function isBigIntArray(type: ts.Type, services: RequiredParserServices): boolean;
+/**
+ * Test if the provided type is an array of booleans.
+ * @param type A TypeScript type.
+ * @param services The services used to get access to the TypeScript type checker
+ */
+export declare function isBooleanArray(type: ts.Type, services: RequiredParserServices): boolean;
 /**
  * Checks whether a TypeScript type node denotes a type alias.
  * @param node a type node to check
  * @param context the rule context
  */
 export declare function isTypeAlias(node: TSESTree.TypeNode, context: Rule.RuleContext): boolean | undefined;
+/**
+ * Returns true when `type` is the boolean literal `true`.
+ */
 export declare function isBooleanTrueType(type: ts.Type): boolean;
-export declare function isBooleanType({ flags }: ts.Type): number;
+/**
+ * Returns true when `type` is boolean-like.
+ */
+export declare function isBooleanType({ flags }: ts.Type): boolean;
+/**
+ * Returns true when `type` is `null`, `undefined`, or a union containing either.
+ */
 export declare function isNullOrUndefinedType({ flags }: ts.Type): number;
+/**
+ * Returns true when `type` is object-like.
+ */
 export declare function isObjectType({ flags }: ts.Type): number;
+/**
+ * Returns true when `node` exposes a callable member named `methodName`.
+ */
 export declare function typeHasMethod(node: estree.Node, methodName: string, services: RequiredParserServices): boolean;
 /**
  * Checks if a type is iterable (can be used in for-of loops).

package/types/helpers/vitest.d.ts

@@ -2,6 +2,5 @@ import type { Rule } from 'eslint';
 import type estree from 'estree';
 import type { ParserServicesWithTypeInformation } from '@typescript-eslint/utils';
 import ts from 'typescript';
-export declare function isImported(context: Rule.RuleContext): boolean;
 export declare function isAssertion(context: Rule.RuleContext, node: estree.Node): boolean;
 export declare function isTSAssertion(services: ParserServicesWithTypeInformation, node: ts.Node): boolean;

package/types/plugin-rules.d.ts

@@ -29,6 +29,7 @@ export declare const rules: {
     'no-duplicate-string': import("eslint").Rule.RuleModule;
     'no-case-label-in-switch': import("eslint").Rule.RuleModule;
     'no-parameter-reassignment': import("eslint").Rule.RuleModule;
+    'no-floating-point-equality': import("eslint").Rule.RuleModule;
     'prefer-while': import("eslint").Rule.RuleModule;
     'no-sonar-comments': import("eslint").Rule.RuleModule;
     'no-small-switch': import("eslint").Rule.RuleModule;
@@ -73,7 +74,6 @@ export declare const rules: {
     'arguments-order': import("eslint").Rule.RuleModule;
     'pseudo-random': import("eslint").Rule.RuleModule;
     'for-loop-increment-sign': import("eslint").Rule.RuleModule;
-    cookies: import("eslint").Rule.RuleModule;
     'null-dereference': import("eslint").Rule.RuleModule;
     'no-selector-parameter': import("eslint").Rule.RuleModule;
     'updated-loop-counter': import("eslint").Rule.RuleModule;
@@ -164,15 +164,9 @@ export declare const rules: {
     'prefer-promise-shorthand': import("eslint").Rule.RuleModule;
     'os-command': import("eslint").Rule.RuleModule;
     'no-redundant-optional': import("eslint").Rule.RuleModule;
-    'regular-expr': import("eslint").Rule.RuleModule;
-    encryption: import("eslint").Rule.RuleModule;
     hashing: import("eslint").Rule.RuleModule;
     'bool-param-default': import("eslint").Rule.RuleModule;
-    xpath: import("eslint").Rule.RuleModule;
-    sockets: import("eslint").Rule.RuleModule;
     'no-try-promise': import("eslint").Rule.RuleModule;
-    'process-argv': import("eslint").Rule.RuleModule;
-    'standard-input': import("eslint").Rule.RuleModule;
     'unverified-certificate': import("eslint").Rule.RuleModule;
     'no-unsafe-unzip': import("eslint").Rule.RuleModule;
     cors: import("eslint").Rule.RuleModule;
@@ -199,12 +193,11 @@ export declare const rules: {
     'no-mime-sniff': import("eslint").Rule.RuleModule;
     'no-referrer-policy': import("eslint").Rule.RuleModule;
     'strict-transport-security': import("eslint").Rule.RuleModule;
-    'certificate-transparency': import("eslint").Rule.RuleModule;
-    'dns-prefetching': import("eslint").Rule.RuleModule;
     'confidential-information-logging': import("eslint").Rule.RuleModule;
     'no-ip-forward': import("eslint").Rule.RuleModule;
     'empty-string-repetition': import("eslint").Rule.RuleModule;
     'regex-complexity': import("eslint").Rule.RuleModule;
+    'no-incompatible-assertion-types': import("eslint").Rule.RuleModule;
     'anchor-precedence': import("eslint").Rule.RuleModule;
     'slow-regex': import("eslint").Rule.RuleModule;
     'no-invalid-regexp': import("eslint").Rule.RuleModule;
@@ -214,6 +207,8 @@ export declare const rules: {
     'no-misleading-character-class': import("eslint").Rule.RuleModule;
     'duplicates-in-character-class': import("eslint").Rule.RuleModule;
     'session-regeneration': import("eslint").Rule.RuleModule;
+    'prefer-specific-assertions': import("eslint").Rule.RuleModule;
+    'no-trivial-assertions': import("eslint").Rule.RuleModule;
     'test-check-exception': import("eslint").Rule.RuleModule;
     'stable-tests': import("eslint").Rule.RuleModule;
     'no-empty-after-reluctant': import("eslint").Rule.RuleModule;
@@ -221,7 +216,6 @@ export declare const rules: {
     'no-code-after-done': import("eslint").Rule.RuleModule;
     'disabled-timeout': import("eslint").Rule.RuleModule;
     'chai-determinate-assertion': import("eslint").Rule.RuleModule;
-    'aws-s3-bucket-server-encryption': import("eslint").Rule.RuleModule;
     'aws-s3-bucket-insecure-http': import("eslint").Rule.RuleModule;
     'aws-s3-bucket-versioning': import("eslint").Rule.RuleModule;
     'aws-s3-bucket-granted-access': import("eslint").Rule.RuleModule;
@@ -229,7 +223,6 @@ export declare const rules: {
     'aws-iam-public-access': import("eslint").Rule.RuleModule;
     'aws-ec2-unencrypted-ebs-volume': import("eslint").Rule.RuleModule;
     'aws-s3-bucket-public-access': import("eslint").Rule.RuleModule;
-    'no-vue-bypass-sanitization': import("eslint").Rule.RuleModule;
     'aws-iam-all-privileges': import("eslint").Rule.RuleModule;
     'aws-rds-unencrypted-databases': import("eslint").Rule.RuleModule;
     'aws-iam-all-resources-accessible': import("eslint").Rule.RuleModule;
@@ -267,4 +260,11 @@ export declare const rules: {
     'review-blockchain-mnemonic': import("eslint").Rule.RuleModule;
     'dynamically-constructed-templates': import("eslint").Rule.RuleModule;
     'no-session-cookies-on-static-assets': import("eslint").Rule.RuleModule;
+    'dompurify-unsafe-config': import("eslint").Rule.RuleModule;
+    'no-duplicate-test-title': import("eslint").Rule.RuleModule;
+    'async-test-assertions': import("eslint").Rule.RuleModule;
+    'no-empty-test-title': import("eslint").Rule.RuleModule;
+    'hooks-before-test-cases': import("eslint").Rule.RuleModule;
+    'no-forced-browser-interaction': import("eslint").Rule.RuleModule;
+    'super-linear-regex': import("eslint").Rule.RuleModule;
 };

package/cjs/S2255/rule.js

@@ -1,111 +0,0 @@
-"use strict";
-/*
- * SonarQube JavaScript Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the Sonar Source-Available License for more details.
- *
- * You should have received a copy of the Sonar Source-Available License
- * along with this program; if not, see https://sonarsource.com/license/ssal/
- */
-// https://sonarsource.github.io/rspec/#/rspec/S2255/javascript
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rule = void 0;
-const generate_meta_js_1 = require("../helpers/generate-meta.js");
-const ast_js_1 = require("../helpers/ast.js");
-const meta = __importStar(require("./generated-meta.js"));
-exports.rule = {
-    meta: (0, generate_meta_js_1.generateMeta)(meta, {
-        messages: {
-            safeCookie: 'Make sure that cookie is written safely here.',
-        },
-    }),
-    create(context) {
-        let usingExpressFramework = false;
-        return {
-            Program() {
-                // init flag for each file
-                usingExpressFramework = false;
-            },
-            Literal(node) {
-                if (node.value === 'express') {
-                    usingExpressFramework = true;
-                }
-            },
-            AssignmentExpression(node) {
-                const { left } = node;
-                if (left.type === 'MemberExpression') {
-                    const { object, property } = left;
-                    if ((0, ast_js_1.isIdentifier)(object, 'document') && (0, ast_js_1.isIdentifier)(property, 'cookie')) {
-                        context.report({
-                            messageId: 'safeCookie',
-                            node: left,
-                        });
-                    }
-                }
-            },
-            CallExpression(node) {
-                const { callee, arguments: args } = node;
-                if (callee.type === 'MemberExpression' &&
-                    usingExpressFramework &&
-                    (0, ast_js_1.isIdentifier)(callee.property, 'cookie', 'cookies')) {
-                    context.report({
-                        messageId: 'safeCookie',
-                        node,
-                    });
-                }
-                if (callee.type === 'MemberExpression' &&
-                    (0, ast_js_1.isIdentifier)(callee.property, 'setHeader') &&
-                    isLiteral(args[0], 'Set-Cookie')) {
-                    context.report({
-                        messageId: 'safeCookie',
-                        node: callee,
-                    });
-                }
-            },
-        };
-    },
-};
-function isLiteral(node, value) {
-    return node?.type === 'Literal' && node.value === value;
-}