@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/regexIgnoreCaseFlags.js

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

@@ -1,10 +0,0 @@
-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: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unexpectedInvisible", undefined>;
-export default _default;
-//# sourceMappingURL=regexInvisibleCharacters.d.ts.map

package/lib/rules/regexInvisibleCharacters.js

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

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

package/lib/rules/regexLetterCasing.js

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

@@ -1,10 +0,0 @@
-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: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferLiteral", undefined>;
-export default _default;
-//# sourceMappingURL=regexLiterals.d.ts.map

package/lib/rules/regexLiterals.js

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

@@ -1,10 +0,0 @@
-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: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferLookaround", undefined>;
-export default _default;
-//# sourceMappingURL=regexLookaroundAssertions.d.ts.map