@flint.fyi/ts 0.14.5 → 0.15.0

package/src/rules/constructorReturns.ts

@@ -1,59 +0,0 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports returning values from constructor functions.",
-		id: "constructorReturns",
-		preset: "untyped",
-	},
-	messages: {
-		noConstructorReturn: {
-			primary:
-				"Returning a value from a constructor function overrides the newly created instance.",
-			secondary: [
-				"This behavior is often unintentional and can lead to unexpected results.",
-				"If you need to return a different object, consider using a factory function instead.",
-			],
-			suggestions: [
-				"Remove the return statement, or return without a value to exit early.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				Constructor: (node) => {
-					if (!node.body) {
-						return;
-					}
-
-					function checkForReturnStatements(node: ts.Node): void {
-						if (ts.isReturnStatement(node)) {
-							if (node.expression) {
-								context.report({
-									message: "noConstructorReturn",
-									range: {
-										begin: node.getStart(context.sourceFile),
-										end: node.getEnd(),
-									},
-								});
-							}
-							return;
-						}
-
-						if (tsutils.isFunctionScopeBoundary(node)) {
-							return;
-						}
-
-						ts.forEachChild(node, checkForReturnStatements);
-					}
-
-					ts.forEachChild(node.body, checkForReturnStatements);
-				},
-			},
-		};
-	},
-});

package/src/rules/debuggerStatements.test.ts

@@ -1,81 +0,0 @@
-import rule from "./debuggerStatements.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-debugger;
-`,
-			snapshot: `
-debugger;
-~~~~~~~~~
-Debugger statements should not be used in production code.
-`,
-			suggestions: [
-				{
-					id: "removeDebugger",
-					updated: `
-
-`,
-				},
-			],
-		},
-		{
-			code: `
-function test() {
-	debugger;
-}
-`,
-			snapshot: `
-function test() {
-	debugger;
-	~~~~~~~~~
-	Debugger statements should not be used in production code.
-}
-`,
-			suggestions: [
-				{
-					id: "removeDebugger",
-					updated: `
-function test() {
-	
-}
-`,
-				},
-			],
-		},
-		{
-			code: `
-if (condition) {
-	debugger;
-}
-`,
-			snapshot: `
-if (condition) {
-	debugger;
-	~~~~~~~~~
-	Debugger statements should not be used in production code.
-}
-`,
-			suggestions: [
-				{
-					id: "removeDebugger",
-					updated: `
-if (condition) {
-	
-}
-`,
-				},
-			],
-		},
-	],
-	valid: [
-		`console.log("debugging");`,
-		`function test() { console.log("test"); }`,
-		`for (let i = 0; i < 10; i++) { break; }`,
-		`for (let i = 0; i < 10; i++) { continue; }`,
-		`function test() { return; }`,
-		`throw new Error("test");`,
-	],
-});

package/src/rules/debuggerStatements.ts

@@ -1,45 +0,0 @@
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports using debugger statements.",
-		id: "debuggerStatements",
-		preset: "logical",
-	},
-	messages: {
-		noDebugger: {
-			primary: "Debugger statements should not be used in production code.",
-			secondary: [
-				"The `debugger` statement causes the JavaScript runtime to pause execution and start a debugger if one is available, such as when browser developer tools are open.",
-				"This can be useful during development, but should not be left in production code.",
-			],
-			suggestions: [
-				"Remove the `debugger` statement before shipping this code to users.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				DebuggerStatement: (node) => {
-					const range = {
-						begin: node.getStart(),
-						end: node.getEnd(),
-					};
-
-					context.report({
-						message: "noDebugger",
-						range,
-						suggestions: [
-							{
-								id: "removeDebugger",
-								range,
-								text: "",
-							},
-						],
-					});
-				},
-			},
-		};
-	},
-});

package/src/rules/defaultCaseLast.test.ts

@@ -1,196 +0,0 @@
-import rule from "./defaultCaseLast.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-switch (value) {
-    default:
-        break;
-    case 1:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    default:
-    ~~~~~~~
-    Default clauses in switch statements should be last.
-        break;
-    case 1:
-        break;
-}
-`,
-		},
-		{
-			code: `
-switch (value) {
-    case 1:
-        break;
-    default:
-        break;
-    case 2:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case 1:
-        break;
-    default:
-    ~~~~~~~
-    Default clauses in switch statements should be last.
-        break;
-    case 2:
-        break;
-}
-`,
-		},
-		{
-			code: `
-switch (value) {
-    case 1:
-    case 2:
-        break;
-    default:
-        break;
-    case 3:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case 1:
-    case 2:
-        break;
-    default:
-    ~~~~~~~
-    Default clauses in switch statements should be last.
-        break;
-    case 3:
-        break;
-}
-`,
-		},
-		{
-			code: `
-switch (value) {
-    default:
-        console.log("default");
-        break;
-    case 1:
-        console.log("one");
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    default:
-    ~~~~~~~
-    Default clauses in switch statements should be last.
-        console.log("default");
-        break;
-    case 1:
-        console.log("one");
-        break;
-}
-`,
-		},
-		{
-			code: `
-const result = (value: number) => {
-    switch (value) {
-        case 1:
-            return "one";
-        default:
-            return "default";
-        case 2:
-            return "two";
-    }
-};
-`,
-			snapshot: `
-const result = (value: number) => {
-    switch (value) {
-        case 1:
-            return "one";
-        default:
-        ~~~~~~~
-        Default clauses in switch statements should be last.
-            return "default";
-        case 2:
-            return "two";
-    }
-};
-`,
-		},
-		{
-			code: `
-switch (value) {
-    default:
-    case 1:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    default:
-    ~~~~~~~
-    Default clauses in switch statements should be last.
-    case 1:
-        break;
-}
-`,
-		},
-	],
-	valid: [
-		`switch (value) { case 1: break; default: break; }`,
-		`switch (value) { case 1: break; case 2: break; default: break; }`,
-		`switch (value) { case 1: break; case 2: break; }`,
-		`switch (value) { default: break; }`,
-		`switch (value) { case 1: case 2: break; default: break; }`,
-		`
-switch (value) {
-    case 1:
-        break;
-    default:
-        break;
-}
-`,
-		`
-switch (value) {
-    case 1:
-        console.log("one");
-        break;
-    case 2:
-        console.log("two");
-        break;
-    default:
-        console.log("default");
-        break;
-}
-`,
-		`
-const result = (value: number) => {
-    switch (value) {
-        case 1:
-            return "one";
-        case 2:
-            return "two";
-        default:
-            return "default";
-    }
-};
-`,
-		`
-switch (value) {
-    case 1:
-    case 2:
-        break;
-    default:
-        break;
-}
-`,
-	],
-});

package/src/rules/defaultCaseLast.ts

@@ -1,54 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports switch statements where the default clause is not last.",
-		id: "defaultCaseLast",
-		preset: "logical",
-	},
-	messages: {
-		defaultCaseShouldBeLast: {
-			primary: "Default clauses in switch statements should be last.",
-			secondary: [
-				"Placing the default clause in a position other than last can lead to confusion and unexpected behavior.",
-				"While the default clause is executed when no case matches, having it in the middle of other cases makes the control flow harder to follow.",
-			],
-			suggestions: [
-				"Move the default clause to the end of the switch statement to improve code clarity.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				SwitchStatement: (node) => {
-					const clauses = node.caseBlock.clauses;
-					const defaultClauseIndex = clauses.findIndex(
-						(clause) => clause.kind === ts.SyntaxKind.DefaultClause,
-					);
-
-					if (
-						defaultClauseIndex === -1 ||
-						defaultClauseIndex === clauses.length - 1
-					) {
-						return;
-					}
-
-					const defaultClause = clauses[defaultClauseIndex];
-
-					context.report({
-						message: "defaultCaseShouldBeLast",
-						range: {
-							begin: defaultClause.getStart(context.sourceFile),
-							end:
-								defaultClause.getStart(context.sourceFile) + "default".length,
-						},
-					});
-				},
-			},
-		};
-	},
-});

package/src/rules/duplicateArguments.test.ts

@@ -1,140 +0,0 @@
-import rule from "./duplicateArguments.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-function test(value, value) {
-    return value;
-}
-`,
-			snapshot: `
-function test(value, value) {
-                     ~~~~~
-                     This parameter overrides the previous parameter of the same name.
-    return value;
-}
-`,
-		},
-		{
-			code: `
-function test(first, second, first) {
-    return first + second;
-}
-`,
-			snapshot: `
-function test(first, second, first) {
-                             ~~~~~
-                             This parameter overrides the previous parameter of the same name.
-    return first + second;
-}
-`,
-		},
-		{
-			code: `
-const arrow = (value, value) => value;
-`,
-			snapshot: `
-const arrow = (value, value) => value;
-                      ~~~~~
-                      This parameter overrides the previous parameter of the same name.
-`,
-		},
-		{
-			code: `
-const func = function (value, value) {
-    return value;
-};
-`,
-			snapshot: `
-const func = function (value, value) {
-                              ~~~~~
-                              This parameter overrides the previous parameter of the same name.
-    return value;
-};
-`,
-		},
-		{
-			code: `
-class Example {
-    method(value, value) {
-        return value;
-    }
-}
-`,
-			snapshot: `
-class Example {
-    method(value, value) {
-                  ~~~~~
-                  This parameter overrides the previous parameter of the same name.
-        return value;
-    }
-}
-`,
-		},
-		{
-			code: `
-class Example {
-    constructor(value, value) {
-        this.value = value;
-    }
-}
-`,
-			snapshot: `
-class Example {
-    constructor(value, value) {
-                       ~~~~~
-                       This parameter overrides the previous parameter of the same name.
-        this.value = value;
-    }
-}
-`,
-		},
-		{
-			code: `
-function test(first, second, third, second) {
-    return first + second + third;
-}
-`,
-			snapshot: `
-function test(first, second, third, second) {
-                                    ~~~~~~
-                                    This parameter overrides the previous parameter of the same name.
-    return first + second + third;
-}
-`,
-		},
-		{
-			code: `
-function test(value, value, value) {
-    return value;
-}
-`,
-			snapshot: `
-function test(value, value, value) {
-                     ~~~~~
-                     This parameter overrides the previous parameter of the same name.
-                            ~~~~~
-                            This parameter overrides the previous parameter of the same name.
-    return value;
-}
-`,
-		},
-	],
-	valid: [
-		`function test(value) { return value; }`,
-		`function test(first, second) { return first + second; }`,
-		`const arrow = (value) => value;`,
-		`const arrow = (first, second) => first + second;`,
-		`const func = function (value) { return value; };`,
-		`const func = function (first, second) { return first + second; };`,
-		`class Example { method(value) { return value; } }`,
-		`class Example { method(first, second) { return first + second; } }`,
-		`class Example { constructor(value) { this.value = value; } }`,
-		`class Example { constructor(first, second) { this.first = first; this.second = second; } }`,
-		`function test({ value }) { return value; }`,
-		`function test({ first, second }) { return first + second; }`,
-		`function test([first, second]) { return first + second; }`,
-	],
-});

package/src/rules/duplicateArguments.ts

@@ -1,58 +0,0 @@
-import * as ts from "typescript";
-
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports functions with duplicate parameter names in their signatures.",
-		id: "duplicateArguments",
-		preset: "untyped",
-	},
-	messages: {
-		duplicateParam: {
-			primary:
-				"This parameter overrides the previous parameter of the same name.",
-			secondary: [
-				"Duplicate parameter names in functions can lead to unexpected behavior and make code harder to understand.",
-				"In strict mode, duplicate parameter names are a syntax error.",
-				"Even in non-strict mode, only the last parameter with a given name is accessible.",
-			],
-			suggestions: ["Rename one of the duplicate parameters to a unique name."],
-		},
-	},
-	setup(context) {
-		function checkNode({ parameters }: ts.FunctionLikeDeclaration) {
-			const seenNames = new Set<string>();
-
-			for (const parameter of parameters) {
-				if (!ts.isIdentifier(parameter.name)) {
-					continue;
-				}
-
-				const parameterName = parameter.name.text;
-				const existingParameter = seenNames.has(parameterName);
-
-				if (existingParameter) {
-					context.report({
-						message: "duplicateParam",
-						range: getTSNodeRange(parameter.name, context.sourceFile),
-					});
-				} else {
-					seenNames.add(parameterName);
-				}
-			}
-		}
-
-		return {
-			visitors: {
-				ArrowFunction: checkNode,
-				Constructor: checkNode,
-				FunctionDeclaration: checkNode,
-				FunctionExpression: checkNode,
-				MethodDeclaration: checkNode,
-			},
-		};
-	},
-});