@flint.fyi/ts 0.14.0 → 0.14.2

package/src/rules/octalEscapes.test.ts

@@ -0,0 +1,214 @@
+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

@@ -0,0 +1,85 @@
+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);
+					}
+				},
+			},
+		};
+	},
+});