@flint.fyi/ts 0.14.6 → 0.18.0

package/src/rules/nonOctalDecimalEscapes.test.ts

@@ -1,70 +0,0 @@
-import rule from "./nonOctalDecimalEscapes.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-"\\8"
-`,
-			snapshot: `
-"\\8"
- ~~
- Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
-`,
-		},
-		{
-			code: `
-"\\9"
-`,
-			snapshot: `
-"\\9"
- ~~
- Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
-`,
-		},
-		{
-			code: `
-"w\\8less"
-`,
-			snapshot: `
-"w\\8less"
-  ~~
-  Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
-`,
-		},
-		{
-			code: `
-"December 1\\9"
-`,
-			snapshot: `
-"December 1\\9"
-           ~~
-           Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
-`,
-		},
-		{
-			code: `
-"Don't use \\8 and \\9 escapes."
-`,
-			snapshot: `
-"Don't use \\8 and \\9 escapes."
-           ~~
-           Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
-                  ~~
-                  Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
-`,
-		},
-		{
-			code: `
-"\\0\\8"
-`,
-			snapshot: `
-"\\0\\8"
-   ~~
-   Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
-`,
-		},
-	],
-	valid: ['"8"', '"9"', '"w8less"', '"December 19"', '"\\\\8"', '"\\0\\u0038"'],
-});

package/src/rules/nonOctalDecimalEscapes.ts

@@ -1,70 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-const nonOctalDecimalEscapePattern = /\\[89]/g;
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.",
-		id: "nonOctalDecimalEscapes",
-		preset: "logical",
-	},
-	messages: {
-		unexpectedEscape: {
-			primary:
-				"Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.",
-			secondary: [
-				"Non-octal decimal escape sequences \\8 and \\9 are legacy features that are treated as identity escapes (the same as the literal digits).",
-				"They are optional in the ECMAScript specification and not supported in strict mode in all environments.",
-				"Use the literal digits directly instead.",
-			],
-			suggestions: [
-				"Remove the backslash to use the literal digit.",
-				"If an escape sequence is needed, use a Unicode escape like \\u0038 or \\u0039.",
-			],
-		},
-	},
-	setup(context) {
-		function checkNode(
-			node: ts.NoSubstitutionTemplateLiteral | ts.StringLiteral,
-		) {
-			const text = node.getText(context.sourceFile);
-			const matches = [...text.matchAll(nonOctalDecimalEscapePattern)];
-
-			for (const match of matches) {
-				// Ignore escapes where the backslash itself is escaped (e.g. "\\\\8" -> literal "\\8").
-				// Count the number of consecutive backslashes immediately before the match.
-				const matchIndex = match.index;
-				let backslashesBefore = 0;
-				for (let i = matchIndex - 1; i >= 0 && text[i] === "\\"; i--) {
-					backslashesBefore++;
-				}
-
-				// If there is an odd number of backslashes before this one, the backslash is escaped
-				// and should not be treated as an escape sequence.
-				if (backslashesBefore % 2 === 1) {
-					continue;
-				}
-
-				const start = node.getStart(context.sourceFile) + matchIndex;
-
-				context.report({
-					message: "unexpectedEscape",
-					range: {
-						begin: start,
-						end: start + match[0].length,
-					},
-				});
-			}
-		}
-
-		return {
-			visitors: {
-				NoSubstitutionTemplateLiteral: checkNode,
-				StringLiteral: checkNode,
-			},
-		};
-	},
-});

package/src/rules/numericLiteralParsing.test.ts

@@ -1,100 +0,0 @@
-import rule from "./numericLiteralParsing.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-const binary = parseInt("111110111", 2);
-`,
-			snapshot: `
-const binary = parseInt("111110111", 2);
-               ~~~~~~~~~~~~~~~~~~~~~~~~
-               Use 0b111110111 instead of parseInt with radix 2.
-`,
-		},
-		{
-			code: `
-const octal = parseInt("767", 8);
-`,
-			snapshot: `
-const octal = parseInt("767", 8);
-              ~~~~~~~~~~~~~~~~~~
-              Use 0o767 instead of parseInt with radix 8.
-`,
-		},
-		{
-			code: `
-const hex = parseInt("1F7", 16);
-`,
-			snapshot: `
-const hex = parseInt("1F7", 16);
-            ~~~~~~~~~~~~~~~~~~~
-            Use 0x1F7 instead of parseInt with radix 16.
-`,
-		},
-		{
-			code: `
-const value = Number.parseInt("111110111", 2);
-`,
-			snapshot: `
-const value = Number.parseInt("111110111", 2);
-              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-              Use 0b111110111 instead of parseInt with radix 2.
-`,
-		},
-		{
-			code: `
-const result = Number.parseInt("767", 8);
-`,
-			snapshot: `
-const result = Number.parseInt("767", 8);
-               ~~~~~~~~~~~~~~~~~~~~~~~~~
-               Use 0o767 instead of parseInt with radix 8.
-`,
-		},
-		{
-			code: `
-const num = Number.parseInt("1F7", 16);
-`,
-			snapshot: `
-const num = Number.parseInt("1F7", 16);
-            ~~~~~~~~~~~~~~~~~~~~~~~~~~
-            Use 0x1F7 instead of parseInt with radix 16.
-`,
-		},
-		{
-			code: `
-const value = parseInt(\`111110111\`, 2);
-`,
-			snapshot: `
-const value = parseInt(\`111110111\`, 2);
-              ~~~~~~~~~~~~~~~~~~~~~~~~
-              Use 0b111110111 instead of parseInt with radix 2.
-`,
-		},
-	],
-	valid: [
-		`const decimal = parseInt("123");`,
-		`const value = parseInt("123", 10);`,
-		`const ternary = parseInt("102", 3);`,
-		`const binary = 0b111110111;`,
-		`const octal = 0o767;`,
-		`const hex = 0x1F7;`,
-		`const dynamic = parseInt(value, 2);`,
-		`const variable = parseInt("111", radix);`,
-		`const single = parseInt("111");`,
-		`Number.parseInt("123");`,
-		`Number.parseInt("123", 10);`,
-		`
-			function parseInt(...values: unknown[]) {}
-			parseInt("1", 2);
-			export {};
-		`,
-		`
-			const Number = { parseInt(...values: unknown[]) {} };
-			Number.parseInt("1", 2);
-			export {};
-		`,
-	],
-});

package/src/rules/numericLiteralParsing.ts

@@ -1,116 +0,0 @@
-import * as ts from "typescript";
-
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
-
-function convertToLiteral(value: string, radix: number): string {
-	const parsed = Number.parseInt(value, radix);
-	if (Number.isNaN(parsed)) {
-		return value;
-	}
-
-	switch (radix) {
-		case 2:
-			return `0b${parsed.toString(2)}`;
-		case 8:
-			return `0o${parsed.toString(8)}`;
-		case 16:
-			return `0x${parsed.toString(16).toUpperCase()}`;
-		default:
-			return value;
-	}
-}
-
-function getRadixValue(node: ts.Expression): number | undefined {
-	if (!ts.isNumericLiteral(node)) {
-		return undefined;
-	}
-
-	const value = Number(node.text);
-	if (![2, 8, 16].includes(value)) {
-		return undefined;
-	}
-
-	return value;
-}
-
-// TODO: Use a util like getStaticValue
-function getStringValue(node: ts.Expression): string | undefined {
-	return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
-		? node.text
-		: undefined;
-}
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.",
-		id: "numericLiteralParsing",
-		preset: "stylistic",
-	},
-	messages: {
-		preferLiteral: {
-			primary: "Use {{ literal }} instead of parseInt with radix {{ radix }}.",
-			secondary: [
-				"Binary, octal, and hexadecimal numeric literals are more readable and direct than using parseInt with a radix.",
-				"Numeric literals are supported natively and don't require function calls.",
-			],
-			suggestions: ["Replace the parseInt call with the numeric literal."],
-		},
-	},
-	setup(context) {
-		function checkParseIntCall(node: ts.CallExpression) {
-			if (node.arguments.length !== 2) {
-				return;
-			}
-
-			const stringValue = getStringValue(node.arguments[0]);
-			if (!stringValue) {
-				return;
-			}
-
-			const radixValue = getRadixValue(node.arguments[1]);
-			if (!radixValue) {
-				return;
-			}
-
-			context.report({
-				data: {
-					literal: convertToLiteral(stringValue, radixValue),
-					radix: String(radixValue),
-				},
-				message: "preferLiteral",
-				range: getTSNodeRange(node, context.sourceFile),
-			});
-		}
-
-		return {
-			visitors: {
-				CallExpression: (node) => {
-					if (ts.isIdentifier(node.expression)) {
-						if (
-							node.expression.text === "parseInt" &&
-							isGlobalDeclaration(node.expression, context.typeChecker)
-						) {
-							checkParseIntCall(node);
-						}
-					} else if (ts.isPropertyAccessExpression(node.expression)) {
-						if (
-							ts.isIdentifier(node.expression.expression) &&
-							node.expression.expression.text === "Number" &&
-							ts.isIdentifier(node.expression.name) &&
-							node.expression.name.text === "parseInt" &&
-							isGlobalDeclaration(
-								node.expression.expression,
-								context.typeChecker,
-							)
-						) {
-							checkParseIntCall(node);
-						}
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/objectProto.test.ts

@@ -1,97 +0,0 @@
-import rule from "./objectProto.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-const proto = obj.__proto__;
-`,
-			snapshot: `
-const proto = obj.__proto__;
-                  ~~~~~~~~~
-                  Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
-`,
-		},
-		{
-			code: `
-obj.__proto__ = prototype;
-`,
-			snapshot: `
-obj.__proto__ = prototype;
-    ~~~~~~~~~
-    Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
-`,
-		},
-		{
-			code: `
-const descriptor = Object.getOwnPropertyDescriptor(obj, "__proto__");
-const proto = obj.__proto__;
-`,
-			snapshot: `
-const descriptor = Object.getOwnPropertyDescriptor(obj, "__proto__");
-const proto = obj.__proto__;
-                  ~~~~~~~~~
-                  Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
-`,
-		},
-		{
-			code: `
-const value = obj["__proto__"];
-`,
-			snapshot: `
-const value = obj["__proto__"];
-                  ~~~~~~~~~~~
-                  Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
-`,
-		},
-		{
-			code: `
-obj["__proto__"] = prototype;
-`,
-			snapshot: `
-obj["__proto__"] = prototype;
-    ~~~~~~~~~~~
-    Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
-`,
-		},
-		{
-			code: `
-if (obj.__proto__ === null) {
-    console.log("No prototype");
-}
-`,
-			snapshot: `
-if (obj.__proto__ === null) {
-        ~~~~~~~~~
-        Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
-    console.log("No prototype");
-}
-`,
-		},
-		{
-			code: `
-function getProto(obj: object) {
-    return obj.__proto__;
-}
-`,
-			snapshot: `
-function getProto(obj: object) {
-    return obj.__proto__;
-               ~~~~~~~~~
-               Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
-}
-`,
-		},
-	],
-	valid: [
-		`const proto = Object.getPrototypeOf(obj);`,
-		`Object.setPrototypeOf(obj, prototype);`,
-		`const obj = Object.create(prototype);`,
-		`const descriptor = Object.getOwnPropertyDescriptor(obj, "__proto__");`,
-		`const key = "__proto__";`,
-		`const string = "obj.__proto__";`,
-		`const obj = { "__proto__": null };`,
-		`const obj = { __proto__: null };`,
-	],
-});

package/src/rules/objectProto.ts

@@ -1,62 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports using the deprecated __proto__ property to access or modify an object's prototype.",
-		id: "objectProto",
-		preset: "untyped",
-	},
-	messages: {
-		noProto: {
-			primary:
-				"Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.",
-			secondary: [
-				"The __proto__ property is deprecated and not part of the ECMAScript standard.",
-				"It is maintained for compatibility with older browsers but can cause performance issues and unexpected behavior.",
-				"Direct manipulation of an object's prototype can lead to hidden classes deoptimizations in JavaScript engines.",
-			],
-			suggestions: [
-				"Use Object.getPrototypeOf(obj) to read the prototype of an object.",
-				"Use Object.setPrototypeOf(obj, proto) to set the prototype of an object.",
-				"Use Object.create(proto) when creating new objects with a specific prototype.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				ElementAccessExpression: (node) => {
-					if (
-						ts.isStringLiteral(node.argumentExpression) &&
-						node.argumentExpression.text === "__proto__"
-					) {
-						context.report({
-							message: "noProto",
-							range: {
-								begin: node.argumentExpression.getStart(context.sourceFile),
-								end: node.argumentExpression.getEnd(),
-							},
-						});
-					}
-				},
-				PropertyAccessExpression: (node) => {
-					if (
-						node.name.kind === ts.SyntaxKind.Identifier &&
-						node.name.text === "__proto__"
-					) {
-						context.report({
-							message: "noProto",
-							range: {
-								begin: node.name.getStart(context.sourceFile),
-								end: node.name.getEnd(),
-							},
-						});
-					}
-				},
-			},
-		};
-	},
-});