@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/regexIgnoreCaseFlags.js

@@ -0,0 +1,145 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexIgnoreCaseFlags.ts
+function getCharacterClassesIfSimplified(pattern) {
+	const characterClasses = [];
+	let simplified = false;
+	visitRegExpAST(pattern, { onCharacterClassEnter(charClass) {
+		if (charClass.negate || simplified) return;
+		const elements = charClass.elements;
+		if (hasMatchingCasePair(elements) && !isHexSubset(elements) && !isFullAlphabetMatch(elements)) {
+			characterClasses.push(charClass);
+			simplified = true;
+		}
+	} });
+	return simplified ? characterClasses : void 0;
+}
+function hasMatchingCasePair(elements) {
+	const letters = /* @__PURE__ */ new Set();
+	for (const element of elements) if (element.type === "Character" && isLetter(element.value)) letters.add(element.value);
+	else if (element.type === "CharacterClassRange") {
+		for (let code = element.min.value; code <= element.max.value; code++) if (isLetter(code)) letters.add(code);
+	}
+	return letters.values().some((letter) => letters.has(toLowerCase(letter)) && letters.has(toUpperCase(letter)));
+}
+function isFullAlphabetMatch(elements) {
+	let hasFullUpper = false;
+	let hasFullLower = false;
+	let hasOtherLetters = false;
+	for (const element of elements) if (element.type === "CharacterClassRange") {
+		const min = element.min.value;
+		const max = element.max.value;
+		if (min === 65 && max === 90) hasFullUpper = true;
+		else if (min === 97 && max === 122) hasFullLower = true;
+		else if (isLetter(min) || isLetter(max)) hasOtherLetters = true;
+	} else if (element.type === "Character" && isLetter(element.value)) hasOtherLetters = true;
+	return hasFullUpper && hasFullLower && !hasOtherLetters;
+}
+function isHexLetter(codePoint) {
+	return codePoint >= 65 && codePoint <= 70 || codePoint >= 97 && codePoint <= 102;
+}
+function isHexSubset(elements) {
+	let hasHexRange = false;
+	for (const element of elements) if (element.type === "CharacterClassRange") {
+		const min = element.min.value;
+		const max = element.max.value;
+		if (min >= 65 && max <= 70 || min >= 97 && max <= 102) hasHexRange = true;
+		else if (isLetter(min) || isLetter(max)) return false;
+	} else if (element.type === "Character") {
+		if (isLetter(element.value) && !isHexLetter(element.value)) return false;
+	}
+	return hasHexRange;
+}
+function isLetter(codePoint) {
+	return codePoint >= 65 && codePoint <= 90 || codePoint >= 97 && codePoint <= 122;
+}
+function simplifyCharacterClass(pattern, charClass) {
+	const elements = charClass.elements;
+	const keptCharacters = /* @__PURE__ */ new Set();
+	const rangesToKeep = [];
+	for (const element of elements) if (element.type === "Character") if (isLetter(element.value)) keptCharacters.add(toLowerCase(element.value));
+	else keptCharacters.add(element.value);
+	else if (element.type === "CharacterClassRange") {
+		const min = element.min.value;
+		const max = element.max.value;
+		const minIsUpper = min >= 65 && min <= 90;
+		const maxIsUpper = max >= 65 && max <= 90;
+		const minIsLower = min >= 97 && min <= 122;
+		const maxIsLower = max >= 97 && max <= 122;
+		if (minIsUpper && maxIsUpper) rangesToKeep.push({
+			max: toLowerCase(max),
+			min: toLowerCase(min)
+		});
+		else if (minIsLower && maxIsLower) rangesToKeep.push({
+			max,
+			min
+		});
+		else rangesToKeep.push({
+			max,
+			min
+		});
+	}
+	let result = "[";
+	for (const range of rangesToKeep) {
+		result += String.fromCodePoint(range.min);
+		result += "-";
+		result += String.fromCodePoint(range.max);
+	}
+	for (const char of [...keptCharacters].sort((a, b) => a - b)) result += String.fromCodePoint(char);
+	result += "]";
+	const before = pattern.slice(0, charClass.start);
+	const after = pattern.slice(charClass.end);
+	return before + result + after;
+}
+function toLowerCase(codePoint) {
+	return codePoint >= 65 && codePoint <= 90 ? codePoint + 32 : codePoint;
+}
+function toUpperCase(codePoint) {
+	return codePoint >= 97 && codePoint <= 122 ? codePoint - 32 : codePoint;
+}
+var regexIgnoreCaseFlags_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports regex patterns that can be simplified by using the i (ignore case) flag.",
+		id: "regexIgnoreCaseFlags",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { useIgnoreCase: {
+		primary: "This character class can be simplified by using the `i` flag.",
+		secondary: ["The `i` flag makes the regex case-insensitive, eliminating the need to match both upper and lower case letters explicitly."],
+		suggestions: ["Add the `i` flag and simplify the character class if it is meant to be case-insensitive.", "Remove the `i` flag if it is not meant to be case-insensitive."]
+	} },
+	setup(context) {
+		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
+			const text = node.getText(sourceFile);
+			const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(text);
+			if (!match) return;
+			const [, pattern, flags] = match;
+			if (!pattern || flags?.includes("i")) return;
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const characterClasses = getCharacterClassesIfSimplified(regexpAst);
+			if (!characterClasses) return;
+			const nodeRange = getTSNodeRange(node, sourceFile);
+			let simplifiedPattern = pattern;
+			for (const charClass of [...characterClasses].reverse()) simplifiedPattern = simplifyCharacterClass(simplifiedPattern, charClass);
+			const fixedText = `/${simplifiedPattern}/${flags}i`;
+			for (const charClass of characterClasses) context.report({
+				fix: {
+					range: nodeRange,
+					text: fixedText
+				},
+				message: "useIgnoreCase",
+				range: {
+					begin: nodeRange.begin + 1 + charClass.start,
+					end: nodeRange.begin + 1 + charClass.end
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { regexIgnoreCaseFlags_default as default };
+
+//# sourceMappingURL=regexIgnoreCaseFlags.js.map

package/lib/rules/regexInvisibleCharacters.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports invisible characters in regex patterns that should use escape sequences instead.";
+    readonly id: "regexInvisibleCharacters";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unexpectedInvisible", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexInvisibleCharacters.d.ts.map

package/lib/rules/regexInvisibleCharacters.js

@@ -0,0 +1,90 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+import { Chars } from "regexp-ast-analysis";
+//#region src/rules/regexInvisibleCharacters.ts
+const codepoints = {
+	braillePatternBlank: 10240,
+	leftToRight: 8206,
+	mongolianVowelSeparator: 6158,
+	nextLine: 133,
+	rightToLeft: 8207,
+	space: 32,
+	zeroWidthNonJoiner: 8204,
+	zeroWidthSpace: 8203,
+	zeroWithJoiner: 8205
+};
+function isInvisible(codePoint) {
+	if (isSpace(codePoint)) return true;
+	return codePoint === codepoints.space || codePoint === codepoints.nextLine || codePoint === codepoints.mongolianVowelSeparator || codePoint === codepoints.zeroWidthSpace || codePoint === codepoints.zeroWidthNonJoiner || codePoint === codepoints.zeroWithJoiner || codePoint === codepoints.leftToRight || codePoint === codepoints.rightToLeft || codePoint === codepoints.braillePatternBlank;
+}
+function isSpace(codePoint) {
+	return Chars.space({}).has(codePoint);
+}
+function toEscapeSequence(codePoint, hasUnicode) {
+	if (codePoint <= 255) return `\\x${codePoint.toString(16).toUpperCase().padStart(2, "0")}`;
+	if (hasUnicode) return `\\u{${codePoint.toString(16).toUpperCase()}}`;
+	return `\\u${codePoint.toString(16).toUpperCase().padStart(4, "0")}`;
+}
+var regexInvisibleCharacters_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports invisible characters in regex patterns that should use escape sequences instead.",
+		id: "regexInvisibleCharacters",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unexpectedInvisible: {
+		primary: "Prefer the more clear '{{ escape }}' instead of this invisible character.",
+		secondary: ["Invisible characters are difficult to distinguish and can lead to hard-to-debug issues."],
+		suggestions: ["Replace the invisible character with '{{ escape }}'."]
+	} },
+	setup(context) {
+		function checkCharacter(charNode, patternStart, hasUnicode) {
+			if (charNode.raw.length !== 1 || charNode.value === codepoints.space || !isInvisible(charNode.value)) return;
+			const escape = toEscapeSequence(charNode.value, hasUnicode);
+			context.report({
+				data: { escape },
+				fix: {
+					range: {
+						begin: patternStart + charNode.start,
+						end: patternStart + charNode.end
+					},
+					text: escape
+				},
+				message: "unexpectedInvisible",
+				range: {
+					begin: patternStart + charNode.start,
+					end: patternStart + charNode.end
+				}
+			});
+		}
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const hasUnicode = flags.includes("u") || flags.includes("v");
+			visitRegExpAST(regexpAst, { onCharacterEnter(charNode) {
+				checkCharacter(charNode, patternStart, hasUnicode);
+			} });
+		}
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			checkPattern(pattern, start, flags);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.pattern.replace(/\\\\/g, "\\"), construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexInvisibleCharacters_default as default };
+
+//# sourceMappingURL=regexInvisibleCharacters.js.map

package/lib/rules/regexLetterCasing.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports inconsistent letter casing in regex sequences.";
+    readonly id: "regexLetterCasing";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unexpectedCase", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexLetterCasing.d.ts.map

package/lib/rules/regexLetterCasing.js

@@ -0,0 +1,186 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexLetterCasing.ts
+function checkPattern(pattern, flags) {
+	const regexpAst = parseRegexpAst(pattern, flags);
+	if (!regexpAst) return [];
+	const issues = [];
+	const ignoreCase = flags.includes("i");
+	function checkCaseInsensitive(charNode) {
+		if (charNode.parent.type === "CharacterClassRange" || !isLetter(charNode.value)) return;
+		if (isLowercaseLetter(String.fromCodePoint(charNode.value))) return;
+		const lowercase = String.fromCodePoint(charNode.value).toLowerCase();
+		issues.push({
+			data: {
+				area: "characters",
+				caseActual: "uppercase",
+				casePreferred: "lowercase",
+				lettersActual: charNode.raw,
+				lettersPreferred: lowercase
+			},
+			end: charNode.end,
+			message: "unexpectedCase",
+			start: charNode.start
+		});
+	}
+	function checkCharacterClassRangeCaseInsensitive(rangeNode) {
+		if (!isLetter(rangeNode.min.value) || !isLetter(rangeNode.max.value)) return;
+		const lowercaseMin = String.fromCodePoint(rangeNode.min.value);
+		if (isLowercaseLetter(lowercaseMin)) return;
+		const lowercaseMax = String.fromCodePoint(rangeNode.max.value);
+		if (isLowercaseLetter(lowercaseMax)) return;
+		issues.push({
+			data: {
+				area: "character class ranges",
+				caseActual: "uppercase",
+				casePreferred: "lowercase",
+				lettersActual: rangeNode.raw,
+				lettersPreferred: `${lowercaseMin}-${lowercaseMax}`.toLowerCase()
+			},
+			end: rangeNode.end,
+			message: "unexpectedCase",
+			start: rangeNode.start
+		});
+	}
+	function checkUnicodeEscape(charNode) {
+		const match = /^(\\u\{?)([\dA-Fa-f]+)(\}?)$/u.exec(charNode.raw);
+		if (!match) return;
+		const [, prefix, code, suffix] = match;
+		if (code === code?.toLowerCase()) return;
+		issues.push({
+			data: {
+				area: "unicode escapes",
+				caseActual: "uppercase",
+				casePreferred: "lowercase",
+				lettersActual: charNode.raw,
+				lettersPreferred: `${prefix}${code?.toLowerCase()}${suffix}`
+			},
+			end: charNode.end,
+			message: "unexpectedCase",
+			start: charNode.start
+		});
+	}
+	function checkHexadecimalEscape(charNode) {
+		const match = /^\\x([\dA-Fa-f]{2})$/u.exec(charNode.raw);
+		if (!match) return;
+		const code = match[1];
+		if (code === code.toLowerCase()) return;
+		issues.push({
+			data: {
+				area: "hexadecimal escapes",
+				caseActual: "uppercase",
+				casePreferred: "lowercase",
+				lettersActual: charNode.raw,
+				lettersPreferred: `\\x${code.toLowerCase()}`
+			},
+			end: charNode.end,
+			message: "unexpectedCase",
+			start: charNode.start
+		});
+	}
+	function checkControlEscape(charNode) {
+		const match = /^\\c([A-Za-z])$/u.exec(charNode.raw);
+		if (!match) return;
+		const controlChar = match[1];
+		if (controlChar === controlChar.toUpperCase()) return;
+		issues.push({
+			data: {
+				area: "control escapes",
+				caseActual: "lowercase",
+				casePreferred: "uppercase",
+				lettersActual: charNode.raw,
+				lettersPreferred: `\\c${controlChar.toUpperCase()}`
+			},
+			end: charNode.end,
+			message: "unexpectedCase",
+			start: charNode.start
+		});
+	}
+	visitRegExpAST(regexpAst, {
+		onCharacterClassRangeEnter(rangeNode) {
+			if (ignoreCase) checkCharacterClassRangeCaseInsensitive(rangeNode);
+		},
+		onCharacterEnter(charNode) {
+			if (ignoreCase) checkCaseInsensitive(charNode);
+			switch (getEscapeSequenceKind(charNode.raw)) {
+				case "control":
+					checkControlEscape(charNode);
+					break;
+				case "hexadecimal":
+					checkHexadecimalEscape(charNode);
+					break;
+				case "unicode":
+				case "unicodeCodePoint":
+					checkUnicodeEscape(charNode);
+					break;
+			}
+		}
+	});
+	return issues;
+}
+function getEscapeSequenceKind(raw) {
+	if (/^\\u\{[\dA-Fa-f]+\}$/u.test(raw)) return "unicodeCodePoint";
+	if (/^\\u[\dA-Fa-f]{4}$/u.test(raw)) return "unicode";
+	if (/^\\x[\dA-Fa-f]{2}$/u.test(raw)) return "hexadecimal";
+	if (/^\\c[A-Za-z]$/u.test(raw)) return "control";
+	return "none";
+}
+function isLetter(codePoint) {
+	return /^[a-zA-Z]$/u.test(String.fromCodePoint(codePoint));
+}
+function isLowercaseLetter(value) {
+	return /^[a-z]$/u.test(value);
+}
+var regexLetterCasing_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports inconsistent letter casing in regex sequences.",
+		id: "regexLetterCasing",
+		presets: ["stylisticStrict"]
+	},
+	messages: { unexpectedCase: {
+		primary: "Prefer {{ casePreferred }} {{ area }} (`{{ lettersPreferred }}`) rather than {{ caseActual }} (`{{ lettersActual }}`) for consistency.",
+		secondary: ["Consistent letter casing in improves readability."],
+		suggestions: ["Convert the escape sequence to {{ casePreferred }}."]
+	} },
+	setup(context) {
+		function reportIssues(issues, patternStart) {
+			for (const issue of issues) context.report({
+				data: issue.data,
+				fix: issue.data.lettersPreferred ? {
+					range: {
+						begin: patternStart + issue.start,
+						end: patternStart + issue.end
+					},
+					text: issue.data.lettersPreferred
+				} : void 0,
+				message: issue.message,
+				range: {
+					begin: patternStart + issue.start,
+					end: patternStart + issue.end
+				}
+			});
+		}
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			reportIssues(checkPattern(pattern, flags), start);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			reportIssues(checkPattern(construction.pattern, construction.flags), construction.start + 1);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexLetterCasing_default as default };
+
+//# sourceMappingURL=regexLetterCasing.js.map

package/lib/rules/regexLiterals.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Use a regular expression literal when the pattern is static.";
+    readonly id: "regexLiterals";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferLiteral", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexLiterals.d.ts.map

package/lib/rules/regexLiterals.js

@@ -0,0 +1,92 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/regexLiterals.ts
+function escapeForRegexLiteral(pattern) {
+	if (pattern === "") return "(?:)";
+	let result = "";
+	let escaped = false;
+	for (const char of pattern) {
+		if (escaped) {
+			result += char;
+			escaped = false;
+			continue;
+		}
+		switch (char) {
+			case "\n":
+				result += "\\n";
+				break;
+			case "\r":
+				result += "\\r";
+				break;
+			case "\u2028":
+				result += "\\u2028";
+				break;
+			case "\u2029":
+				result += "\\u2029";
+				break;
+			case "/":
+				result += "\\/";
+				break;
+			case "\\":
+				result += char;
+				escaped = true;
+				break;
+			default:
+				result += char;
+				break;
+		}
+	}
+	return result;
+}
+function isStaticString(node) {
+	return node.kind === ts$1.SyntaxKind.StringLiteral || node.kind === ts$1.SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+var regexLiterals_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Use a regular expression literal when the pattern is static.",
+		id: "regexLiterals",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferLiteral: {
+		primary: "This `RegExp` construction with a static value can be simplified to a regular expression literal.",
+		secondary: ["Regex literals are more concise and avoid unnecessary constructor calls."],
+		suggestions: ["Replace with regex literal `{{ literal }}`."]
+	} },
+	setup(context) {
+		function checkRegExpCall(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			if (!isStaticString(construction.args[0])) return;
+			if (construction.args.length === 2 && !isStaticString(construction.args[1])) return;
+			if (!parseRegexpAst(construction.pattern, construction.flags)) return;
+			const literal = `/${escapeForRegexLiteral(construction.raw)}/${construction.flags}`;
+			const begin = node.getStart(services.sourceFile);
+			context.report({
+				data: { literal },
+				fix: {
+					range: {
+						begin,
+						end: node.getEnd()
+					},
+					text: literal
+				},
+				message: "preferLiteral",
+				range: {
+					begin,
+					end: node.expression.getEnd()
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpCall,
+			NewExpression: checkRegExpCall
+		} };
+	}
+});
+//#endregion
+export { regexLiterals_default as default };
+
+//# sourceMappingURL=regexLiterals.js.map

package/lib/rules/regexLookaroundAssertions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports capturing groups at pattern boundaries that can be replaced with lookaround assertions.";
+    readonly id: "regexLookaroundAssertions";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferLookaround", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexLookaroundAssertions.d.ts.map