@flint.fyi/ts 0.14.1 → 0.14.3

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @flint/ts
 
+## 0.14.3
+
+### Patch Changes
+
+- 9b6b884: added browser plugin with alerts rule
+- c8bad31: feat: add JSX plugin with accessKeys rule
+
+## 0.14.2
+
+### Patch Changes
+
+- 6415134: feat: implement debuggerStatements rule for TypeScript plugin
+- Updated dependencies [b58d145]
+  - @flint.fyi/rule-tester@0.14.1
+
 ## 0.14.1
 
 ### Patch Changes

package/lib/index.d.ts

@@ -1,3 +1,4 @@
 export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { ts } from "./plugin.js";
+export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";

package/lib/index.js

@@ -1,3 +1,4 @@
 export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { ts } from "./plugin.js";
+export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";

package/lib/nodes.d.ts

@@ -22,6 +22,7 @@ export interface TSNodesByName {
     ComputedPropertyName: ts.ComputedPropertyName;
     ConditionalExpression: ts.ConditionalExpression;
     ConditionalType: ts.ConditionalType;
+    Constructor: ts.ConstructorDeclaration;
     ContinueStatement: ts.ContinueStatement;
     DebuggerStatement: ts.DebuggerStatement;
     Decorator: ts.Decorator;

package/lib/plugin.d.ts

@@ -1,16 +1,144 @@
 export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, string | undefined, [import("@flint.fyi/core").Rule<{
-    readonly description: "Reports iterating over an array with a for-in loop.";
-    readonly id: "forInArrays";
+    readonly description: "Reports using async functions as Promise executor functions.";
+    readonly id: "asyncPromiseExecutors";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "forIn", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "asyncPromiseExecutor", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports lexical declarations in case clauses without wrapping them in blocks.";
+    readonly id: "caseDeclarations";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unexpectedLexicalDeclaration", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using chained assignment expressions (e.g., a = b = c).";
+    readonly id: "chainedAssignments";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noChainedAssignment", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports reassigning class declarations.";
+    readonly id: "classAssignments";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noClassAssign", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary extra non-null assertions.";
     readonly id: "consecutiveNonNullAssertions";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "consecutiveNonNullAssertion", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports attempting to reassign variables declared with const.";
+    readonly id: "constantAssignments";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noConstAssign", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports returning values from constructor functions.";
+    readonly id: "constructorReturns";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noConstructorReturn", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using debugger statements.";
+    readonly id: "debuggerStatements";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noDebugger", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports switch statements where the default clause is not last.";
+    readonly id: "defaultCaseLast";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "defaultCaseShouldBeLast", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports functions with duplicate parameter names in their signatures.";
+    readonly id: "duplicateArguments";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "duplicateParam", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using empty destructuring patterns that destructure no values.";
+    readonly id: "emptyDestructures";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "emptyPattern", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty static initialization blocks within class declarations.";
+    readonly id: "emptyStaticBlocks";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "emptyStaticBlock", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports reassigning exception parameters in catch clauses.";
+    readonly id: "exceptionAssignments";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noExAssign", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports iterating over an array with a for-in loop.";
+    readonly id: "forInArrays";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "forIn", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports reassigning variables declared with function declarations.";
+    readonly id: "functionAssignments";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noFunctionAssignment", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports generator functions that do not yield values.";
+    readonly id: "generatorFunctionYields";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "missingYield", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.";
+    readonly id: "globalAssignments";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noGlobalAssign", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports calling global objects like Math, JSON, or Reflect as functions.";
+    readonly id: "globalObjectCalls";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noGlobalObjectCall", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using legacy `namespace` declarations.";
     readonly id: "namespaceDeclarations";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "preferModules", {
     readonly allowDeclarations: import("zod").ZodDefault<import("zod").ZodBoolean>;
     readonly allowDefinitionFiles: import("zod").ZodDefault<import("zod").ZodBoolean>;
-}>]>;
+}>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports comparisons with -0 that may not behave as expected.";
+    readonly id: "negativeZeroComparisons";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unexpectedNegativeZeroComparison", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports standalone new expressions that don't use the constructed object.";
+    readonly id: "newExpressions";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noStandaloneNew", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.";
+    readonly id: "newNativeNonConstructors";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noNewNonConstructor", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.";
+    readonly id: "objectProto";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noProto", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using octal escape sequences in string literals.";
+    readonly id: "octalEscapes";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noOctalEscape", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using legacy octal numeric literals.";
+    readonly id: "octalNumbers";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noOctalNumber", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using assignment expressions in return statements.";
+    readonly id: "returnAssignments";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noReturnAssign", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports array literals with holes (sparse arrays).";
+    readonly id: "sparseArrays";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noSparseArray", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports Symbol() calls without description arguments.";
+    readonly id: "symbolDescriptions";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "missingDescription", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports variables that are declared but never assigned a value.";
+    readonly id: "unassignedVariables";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noUnassigned", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using variables that are not defined.";
+    readonly id: "undefinedVariables";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "undefinedVariable", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports files with Unicode Byte Order Marks (BOMs).";
+    readonly id: "unicodeBOMs";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noBOM", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports catch clauses that only rethrow the caught error without modification.";
+    readonly id: "unnecessaryCatches";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unnecessaryCatch", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports negating the left operand of `in` or `instanceof` relations.";
+    readonly id: "unsafeNegations";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "preferNegatingRelation", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports attempting to delete variables with the delete operator.";
+    readonly id: "variableDeletions";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noDeleteVar", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the void operator.";
+    readonly id: "voidOperator";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noVoid", undefined>]>;

package/lib/plugin.js

@@ -1,11 +1,79 @@
 import { createPlugin } from "@flint.fyi/core";
+import asyncPromiseExecutors from "./rules/asyncPromiseExecutors.js";
+import caseDeclarations from "./rules/caseDeclarations.js";
+import chainedAssignments from "./rules/chainedAssignments.js";
+import classAssignments from "./rules/classAssignments.js";
 import consecutiveNonNullAssertions from "./rules/consecutiveNonNullAssertions.js";
+import constantAssignments from "./rules/constantAssignments.js";
+import constructorReturns from "./rules/constructorReturns.js";
+import debuggerStatements from "./rules/debuggerStatements.js";
+import defaultCaseLast from "./rules/defaultCaseLast.js";
+import duplicateArguments from "./rules/duplicateArguments.js";
+import emptyDestructures from "./rules/emptyDestructures.js";
+import emptyStaticBlocks from "./rules/emptyStaticBlocks.js";
+import exceptionAssignments from "./rules/exceptionAssignments.js";
 import forInArrays from "./rules/forInArrays.js";
+import functionAssignments from "./rules/functionAssignments.js";
+import generatorFunctionYields from "./rules/generatorFunctionYields.js";
+import globalAssignments from "./rules/globalAssignments.js";
+import globalObjectCalls from "./rules/globalObjectCalls.js";
 import namespaceDeclarations from "./rules/namespaceDeclarations.js";
+import negativeZeroComparisons from "./rules/negativeZeroComparisons.js";
+import newExpressions from "./rules/newExpressions.js";
+import newNativeNonConstructors from "./rules/newNativeNonConstructors.js";
+import objectProto from "./rules/objectProto.js";
+import octalEscapes from "./rules/octalEscapes.js";
+import octalNumbers from "./rules/octalNumbers.js";
+import returnAssignments from "./rules/returnAssignments.js";
+import sparseArrays from "./rules/sparseArrays.js";
+import symbolDescriptions from "./rules/symbolDescriptions.js";
+import unassignedVariables from "./rules/unassignedVariables.js";
+import undefinedVariables from "./rules/undefinedVariables.js";
+import unicodeBOMs from "./rules/unicodeBOMs.js";
+import unnecessaryCatches from "./rules/unnecessaryCatches.js";
+import unsafeNegations from "./rules/unsafeNegations.js";
+import variableDeletions from "./rules/variableDeletions.js";
+import voidOperator from "./rules/voidOperator.js";
 export const ts = createPlugin({
     files: {
         all: ["**/*.{cjs,js,jsx,mjs,ts,tsx}"],
     },
     name: "ts",
-    rules: [forInArrays, consecutiveNonNullAssertions, namespaceDeclarations],
+    rules: [
+        asyncPromiseExecutors,
+        caseDeclarations,
+        chainedAssignments,
+        classAssignments,
+        consecutiveNonNullAssertions,
+        constantAssignments,
+        constructorReturns,
+        debuggerStatements,
+        defaultCaseLast,
+        duplicateArguments,
+        emptyDestructures,
+        emptyStaticBlocks,
+        exceptionAssignments,
+        forInArrays,
+        functionAssignments,
+        generatorFunctionYields,
+        globalAssignments,
+        globalObjectCalls,
+        namespaceDeclarations,
+        negativeZeroComparisons,
+        newExpressions,
+        newNativeNonConstructors,
+        objectProto,
+        octalEscapes,
+        octalNumbers,
+        returnAssignments,
+        sparseArrays,
+        symbolDescriptions,
+        unassignedVariables,
+        undefinedVariables,
+        unicodeBOMs,
+        unnecessaryCatches,
+        unsafeNegations,
+        variableDeletions,
+        voidOperator,
+    ],
 });

package/lib/rules/asyncPromiseExecutors.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using async functions as Promise executor functions.";
+    readonly id: "asyncPromiseExecutors";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "asyncPromiseExecutor", undefined>;
+export default _default;

package/lib/rules/asyncPromiseExecutors.js

@@ -0,0 +1,51 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports using async functions as Promise executor functions.",
+        id: "asyncPromiseExecutors",
+        preset: "logical",
+    },
+    messages: {
+        asyncPromiseExecutor: {
+            primary: "Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.",
+            secondary: [
+                "The Promise executor function is called synchronously by the Promise constructor.",
+                "If an async function is used as a Promise executor, thrown errors will not be caught by the Promise and will instead result in unhandled rejections.",
+                "Additionally, if a Promise executor function is using `await`, there's probably no need to use the `new Promise` constructor.",
+            ],
+            suggestions: [
+                "Remove the `async` keyword from the executor function.",
+                "If you need to use `await` inside the Promise, consider restructuring your code to avoid the Promise constructor.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                NewExpression: (node) => {
+                    if (!isGlobalDeclaration(node.expression, context.typeChecker) ||
+                        !node.arguments?.length) {
+                        return;
+                    }
+                    const executor = node.arguments[0];
+                    if (!ts.isFunctionLike(executor)) {
+                        return;
+                    }
+                    const asyncModifier = executor.modifiers?.find((mod) => mod.kind === ts.SyntaxKind.AsyncKeyword);
+                    if (!asyncModifier) {
+                        return;
+                    }
+                    context.report({
+                        message: "asyncPromiseExecutor",
+                        range: {
+                            begin: asyncModifier.getStart(context.sourceFile),
+                            end: asyncModifier.getEnd(),
+                        },
+                    });
+                },
+            },
+        };
+    },
+});

package/lib/rules/asyncPromiseExecutors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/rules/asyncPromiseExecutors.test.js

@@ -0,0 +1,71 @@
+import rule from "./asyncPromiseExecutors.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+new Promise(async (resolve, reject) => {
+    resolve(42);
+});
+`,
+            snapshot: `
+new Promise(async (resolve, reject) => {
+            ~~~~~
+            Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve(42);
+});
+`,
+        },
+        {
+            code: `
+new Promise(async function(resolve, reject) {
+    resolve(42);
+});
+`,
+            snapshot: `
+new Promise(async function(resolve, reject) {
+            ~~~~~
+            Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve(42);
+});
+`,
+        },
+        {
+            code: `
+const p = new Promise(async (resolve) => {
+    resolve();
+});
+`,
+            snapshot: `
+const p = new Promise(async (resolve) => {
+                      ~~~~~
+                      Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve();
+});
+`,
+        },
+    ],
+    valid: [
+        `
+new Promise((resolve, reject) => {
+    resolve(42);
+});
+`,
+        `
+new Promise(function(resolve, reject) {
+    resolve(42);
+});
+`,
+        `
+const p = new Promise((resolve) => {
+    doSomething().then(resolve);
+});
+`,
+        `
+// Not a Promise constructor
+new SomethingElse(async (resolve) => {
+    resolve();
+});
+`,
+    ],
+});

package/lib/rules/caseDeclarations.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports lexical declarations in case clauses without wrapping them in blocks.";
+    readonly id: "caseDeclarations";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unexpectedLexicalDeclaration", undefined>;
+export default _default;

package/lib/rules/caseDeclarations.js

@@ -0,0 +1,53 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports lexical declarations in case clauses without wrapping them in blocks.",
+        id: "caseDeclarations",
+        preset: "untyped",
+    },
+    messages: {
+        unexpectedLexicalDeclaration: {
+            primary: "Variables declared in case clauses without braces leak into the surrounding scope.",
+            secondary: [
+                "Lexical declarations (let, const, function, class) are scoped to the entire switch statement, not just the case clause where they are declared.",
+                "This can lead to unexpected behavior when the same variable name is used in multiple case clauses, as they will conflict in the same scope.",
+            ],
+            suggestions: [
+                "Wrap the case clause contents in curly braces {} to create a block scope.",
+            ],
+        },
+    },
+    setup(context) {
+        function getLexicalDeclaration(statements) {
+            for (const statement of statements) {
+                if (ts.isVariableStatement(statement) &&
+                    tsutils.isNodeFlagSet(statement.declarationList, ts.NodeFlags.Let | ts.NodeFlags.Const)) {
+                    return statement.declarationList.getChildAt(0, context.sourceFile);
+                }
+                if (ts.isClassDeclaration(statement) ||
+                    ts.isFunctionDeclaration(statement)) {
+                    return statement.getChildAt(0, context.sourceFile);
+                }
+            }
+            return undefined;
+        }
+        function checkClause(node) {
+            const declarationNode = getLexicalDeclaration(node.statements);
+            if (declarationNode) {
+                context.report({
+                    message: "unexpectedLexicalDeclaration",
+                    range: getTSNodeRange(declarationNode, context.sourceFile),
+                });
+            }
+        }
+        return {
+            visitors: {
+                CaseClause: checkClause,
+                DefaultClause: checkClause,
+            },
+        };
+    },
+});

package/lib/rules/caseDeclarations.test.d.ts

@@ -0,0 +1 @@
+export {};