@flint.fyi/ts 0.14.5 → 0.15.0

package/src/rules/octalEscapes.test.ts

@@ -1,214 +0,0 @@
-import rule from "./octalEscapes.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-const a = "\\1";
-`,
-			snapshot: `
-const a = "\\1";
-           ~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = "\\2";
-`,
-			snapshot: `
-const a = "\\2";
-           ~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = "\\7";
-`,
-			snapshot: `
-const a = "\\7";
-           ~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = "\\00";
-`,
-			snapshot: `
-const a = "\\00";
-           ~~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = "\\01";
-`,
-			snapshot: `
-const a = "\\01";
-           ~~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = "\\02";
-`,
-			snapshot: `
-const a = "\\02";
-           ~~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = "\\07";
-`,
-			snapshot: `
-const a = "\\07";
-           ~~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = "\\377";
-`,
-			snapshot: `
-const a = "\\377";
-           ~~~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = "\\12";
-`,
-			snapshot: `
-const a = "\\12";
-           ~~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = "before\\1after";
-`,
-			snapshot: `
-const a = "before\\1after";
-                 ~~
-                 Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = "before\\01after";
-`,
-			snapshot: `
-const a = "before\\01after";
-                 ~~~
-                 Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = '\\1';
-`,
-			snapshot: `
-const a = '\\1';
-           ~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = '\\01';
-`,
-			snapshot: `
-const a = '\\01';
-           ~~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = \`\\1\`;
-`,
-			snapshot: `
-const a = \`\\1\`;
-           ~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = \`\\01\`;
-`,
-			snapshot: `
-const a = \`\\01\`;
-           ~~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const a = \`before\\1after\`;
-`,
-			snapshot: `
-const a = \`before\\1after\`;
-                 ~~
-                 Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const x = 5;
-const a = \`value: \${x} \\1\`;
-`,
-			snapshot: `
-const x = 5;
-const a = \`value: \${x} \\1\`;
-                       ~~
-                       Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-		{
-			code: `
-const x = 5;
-const a = \`\\01 value: \${x}\`;
-`,
-			snapshot: `
-const x = 5;
-const a = \`\\01 value: \${x}\`;
-           ~~~
-           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
-`,
-		},
-	],
-	valid: [
-		`const a = "\\0";`,
-		`const a = "\\8";`,
-		`const a = "\\9";`,
-		`const a = "\\x01";`,
-		`const a = "\\u0001";`,
-		`const a = "\\n";`,
-		`const a = "\\t";`,
-		`const a = "\\\\0";`,
-		`const a = "\\\\1";`,
-		`const a = "before\\0after";`,
-		`const a = "before\\8after";`,
-		`const a = "before\\9after";`,
-		`const a = '\\0';`,
-		`const a = '\\8';`,
-		`const a = '\\9';`,
-		`const a = \`\\0\`;`,
-		`const a = \`\\8\`;`,
-		`const a = \`\\9\`;`,
-		`const x = 5; const a = \`value: \${x} \\0\`;`,
-		`const x = 5; const a = \`\\0 value: \${x}\`;`,
-		`const x = 5; const a = \`\\8 \${x} \\9\`;`,
-	],
-});

package/src/rules/octalEscapes.ts

@@ -1,85 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-/**
- * Finds the position and length of an octal escape sequence in a string.
- * Returns undefined if no octal escape is found.
- */
-function findOctalEscape(
-	text: string,
-): undefined | { index: number; length: number } {
-	// Remove quotes from the string literal
-	const content = text.slice(1, -1);
-
-	// Match octal escapes: \0 followed by [0-7], or \1-7 optionally followed by [0-7]
-	// But exclude escaped backslashes (\\)
-	const octalEscapePattern = /(?<!\\)\\0[0-7]|(?<!\\)\\[1-7][0-7]*/;
-	const match = octalEscapePattern.exec(content);
-
-	if (!match) {
-		return undefined;
-	}
-
-	// Add 1 to account for the opening quote
-	return {
-		index: match.index + 1,
-		length: match[0].length,
-	};
-}
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports using octal escape sequences in string literals.",
-		id: "octalEscapes",
-		preset: "logical",
-	},
-	messages: {
-		noOctalEscape: {
-			primary:
-				"Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.",
-			secondary: [
-				"Octal escape sequences (e.g., `\\01`, `\\02`, `\\377`) are a deprecated feature in JavaScript that can lead to confusion and are forbidden in strict mode and template literals.",
-				"They are less readable than their modern alternatives and can cause portability issues.",
-			],
-			suggestions: [
-				"Use hexadecimal escape sequences (e.g., `\\x01`) or Unicode escape sequences (e.g., `\\u0001`) instead.",
-			],
-		},
-	},
-	setup(context) {
-		function checkNode(node: ts.Node) {
-			const text = node.getText(context.sourceFile);
-			const octalEscape = findOctalEscape(text);
-
-			if (!octalEscape) {
-				return;
-			}
-
-			const nodeStart = node.getStart(context.sourceFile);
-			context.report({
-				message: "noOctalEscape",
-				range: {
-					begin: nodeStart + octalEscape.index,
-					end: nodeStart + octalEscape.index + octalEscape.length,
-				},
-			});
-		}
-
-		return {
-			visitors: {
-				NoSubstitutionTemplateLiteral: checkNode,
-				StringLiteral: checkNode,
-				TemplateExpression: (node) => {
-					// Check the head of the template
-					checkNode(node.head);
-
-					// Check each template span
-					for (const span of node.templateSpans) {
-						checkNode(span.literal);
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/octalNumbers.test.ts

@@ -1,246 +0,0 @@
-import rule from "./octalNumbers.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-const value = 07;
-`,
-			snapshot: `
-const value = 07;
-              ~~
-              This legacy octal numeric literal evaluates to 7. Did you mean that value, or to use a modern octal syntax such as 0o7?
-`,
-			suggestions: [
-				{
-					id: "useModernOctalSyntax",
-					updated: `
-const value = 0o7;
-`,
-				},
-				{
-					id: "removeLeadingZero",
-					updated: `
-const value = 7;
-`,
-				},
-			],
-		},
-		{
-			code: `
-const value = 077;
-`,
-			snapshot: `
-const value = 077;
-              ~~~
-              This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
-`,
-			suggestions: [
-				{
-					id: "useModernOctalSyntax",
-					updated: `
-const value = 0o77;
-`,
-				},
-				{
-					id: "removeLeadingZero",
-					updated: `
-const value = 77;
-`,
-				},
-			],
-		},
-		{
-			code: `
-const value = 0123;
-`,
-			snapshot: `
-const value = 0123;
-              ~~~~
-              This legacy octal numeric literal evaluates to 83. Did you mean that value, or to use a modern octal syntax such as 0o123?
-`,
-			suggestions: [
-				{
-					id: "useModernOctalSyntax",
-					updated: `
-const value = 0o123;
-`,
-				},
-				{
-					id: "removeLeadingZero",
-					updated: `
-const value = 123;
-`,
-				},
-			],
-		},
-		{
-			code: `
-const value = 01234567;
-`,
-			snapshot: `
-const value = 01234567;
-              ~~~~~~~~
-              This legacy octal numeric literal evaluates to 342391. Did you mean that value, or to use a modern octal syntax such as 0o1234567?
-`,
-			suggestions: [
-				{
-					id: "useModernOctalSyntax",
-					updated: `
-const value = 0o1234567;
-`,
-				},
-				{
-					id: "removeLeadingZero",
-					updated: `
-const value = 1234567;
-`,
-				},
-			],
-		},
-		{
-			code: `
-const values = [01, 02, 03];
-`,
-			snapshot: `
-const values = [01, 02, 03];
-                ~~
-                This legacy octal numeric literal evaluates to 1. Did you mean that value, or to use a modern octal syntax such as 0o1?
-                    ~~
-                    This legacy octal numeric literal evaluates to 2. Did you mean that value, or to use a modern octal syntax such as 0o2?
-                        ~~
-                        This legacy octal numeric literal evaluates to 3. Did you mean that value, or to use a modern octal syntax such as 0o3?
-`,
-			suggestions: [
-				{
-					id: "useModernOctalSyntax",
-					updated: `
-const values = [0o1, 02, 03];
-`,
-				},
-				{
-					id: "removeLeadingZero",
-					updated: `
-const values = [1, 02, 03];
-`,
-				},
-				{
-					id: "useModernOctalSyntax",
-					updated: `
-const values = [01, 0o2, 03];
-`,
-				},
-				{
-					id: "removeLeadingZero",
-					updated: `
-const values = [01, 2, 03];
-`,
-				},
-				{
-					id: "useModernOctalSyntax",
-					updated: `
-const values = [01, 02, 0o3];
-`,
-				},
-				{
-					id: "removeLeadingZero",
-					updated: `
-const values = [01, 02, 3];
-`,
-				},
-			],
-		},
-		{
-			code: `
-function calculate() {
-	return 077;
-}
-`,
-			snapshot: `
-function calculate() {
-	return 077;
-	       ~~~
-	       This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
-}
-`,
-			suggestions: [
-				{
-					id: "useModernOctalSyntax",
-					updated: `
-function calculate() {
-	return 0o77;
-}
-`,
-				},
-				{
-					id: "removeLeadingZero",
-					updated: `
-function calculate() {
-	return 77;
-}
-`,
-				},
-			],
-		},
-		{
-			code: `
-const result = 010 + 020;
-`,
-			snapshot: `
-const result = 010 + 020;
-               ~~~
-               This legacy octal numeric literal evaluates to 8. Did you mean that value, or to use a modern octal syntax such as 0o10?
-                     ~~~
-                     This legacy octal numeric literal evaluates to 16. Did you mean that value, or to use a modern octal syntax such as 0o20?
-`,
-			suggestions: [
-				{
-					id: "useModernOctalSyntax",
-					updated: `
-const result = 0o10 + 020;
-`,
-				},
-				{
-					id: "removeLeadingZero",
-					updated: `
-const result = 10 + 020;
-`,
-				},
-				{
-					id: "useModernOctalSyntax",
-					updated: `
-const result = 010 + 0o20;
-`,
-				},
-				{
-					id: "removeLeadingZero",
-					updated: `
-const result = 010 + 20;
-`,
-				},
-			],
-		},
-	],
-	valid: [
-		`const value = 0;`,
-		`const value = 1;`,
-		`const value = 10;`,
-		`const value = 100;`,
-		`const value = 0x7F;`,
-		`const value = 0o77;`,
-		`const value = 0O77;`,
-		`const value = 0b111;`,
-		`const value = 0B111;`,
-		`const value = 0.8;`,
-		`const value = 8;`,
-		`const value = 9;`,
-		`const value = 123;`,
-		`const values = [0, 1, 10, 100];`,
-		`const hex = 0xFF;`,
-		`const binary = 0b1010;`,
-		`const octal = 0o755;`,
-		`const notOctal = 08;`,
-		`const alsoNotOctal = 09;`,
-	],
-});

package/src/rules/octalNumbers.ts

@@ -1,75 +0,0 @@
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports using legacy octal numeric literals.",
-		id: "octalNumbers",
-		preset: "untyped",
-	},
-	messages: {
-		noOctalNumber: {
-			primary:
-				"This legacy octal numeric literal evaluates to {{ raw }}. Did you mean that value, or to use a modern octal syntax such as {{ equivalent }}?",
-			secondary: [
-				"Legacy octal numeric literals (e.g., `077`, `0123`) are a deprecated feature in JavaScript that can lead to confusion and errors.",
-				"They are forbidden in strict mode and are less readable than their modern alternatives.",
-				"The digit `0` by itself is allowed as it represents zero, not an octal literal.",
-			],
-			suggestions: [
-				"Use the explicit octal syntax (e.g., `0o77`) introduced in ES6, which is clearer and works in both strict and non-strict modes.",
-				"Remove the leading `0` if you intended to use the decimal value.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				NumericLiteral: (node) => {
-					const text = node.getText(context.sourceFile);
-
-					// Check for legacy octal literal: starts with 0 followed by octal digits (0-7)
-					// But not just "0" alone, and not modern formats like 0x, 0o, 0b
-					// cspell:ignore xobi
-					if (
-						text.length > 1 &&
-						text.startsWith("0") &&
-						text[1] >= "0" &&
-						text[1] <= "7" &&
-						!/^0[xobi]/i.test(text)
-					) {
-						const range = {
-							begin: node.getStart(context.sourceFile),
-							end: node.getEnd(),
-						};
-
-						// Parse the octal value
-						const octalValue = parseInt(text, 8);
-						const modernOctalSyntax = `0o${text.slice(1)}`;
-						const decimalWithoutLeadingZero = text.slice(1);
-
-						context.report({
-							data: {
-								equivalent: modernOctalSyntax,
-								raw: octalValue.toString(),
-							},
-							message: "noOctalNumber",
-							range,
-							suggestions: [
-								{
-									id: "useModernOctalSyntax",
-									range,
-									text: modernOctalSyntax,
-								},
-								{
-									id: "removeLeadingZero",
-									range,
-									text: decimalWithoutLeadingZero,
-								},
-							],
-						});
-					}
-				},
-			},
-		};
-	},
-});