@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/regexCharacterClassRanges.js

@@ -1,135 +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/regexCharacterClassRanges.ts
-const ALPHANUMERIC_RANGES = [
-	{
-		max: 57,
-		min: 48
-	},
-	{
-		max: 90,
-		min: 65
-	},
-	{
-		max: 122,
-		min: 97
-	}
-];
-function inRange(ranges, min, max = min) {
-	for (const range of ranges) if (range.min <= min && max <= range.max) return true;
-	return false;
-}
-function processCharacterClass(node) {
-	const groups = [];
-	for (const element of node.elements) {
-		let data;
-		if (element.type === "Character") {
-			if (!inRange(ALPHANUMERIC_RANGES, element.value)) continue;
-			data = {
-				max: {
-					raw: element.raw,
-					value: element.value
-				},
-				min: {
-					raw: element.raw,
-					value: element.value
-				},
-				node: element
-			};
-		} else if (element.type === "CharacterClassRange") {
-			if (!inRange(ALPHANUMERIC_RANGES, element.min.value, element.max.value)) continue;
-			data = {
-				max: {
-					raw: element.max.raw,
-					value: element.max.value
-				},
-				min: {
-					raw: element.min.raw,
-					value: element.min.value
-				},
-				node: element
-			};
-		} else continue;
-		const group = groups.find((gp) => {
-			if (!(gp.min.value - 1 <= data.max.value && data.min.value <= gp.max.value + 1)) return false;
-			return inRange(ALPHANUMERIC_RANGES, Math.min(gp.min.value, data.min.value), Math.max(gp.max.value, data.max.value));
-		});
-		if (group) {
-			if (data.min.value < group.min.value) group.min = data.min;
-			if (group.max.value < data.max.value) group.max = data.max;
-			group.nodes.push(data.node);
-		} else groups.push({
-			max: data.max,
-			min: data.min,
-			nodes: [data.node]
-		});
-	}
-	for (const group of groups) if (group.max.value - group.min.value + 1 >= 4 && group.nodes.length > 1) return {
-		newRange: `${group.min.raw}-${group.max.raw}`,
-		nodes: group.nodes
-	};
-}
-var regexCharacterClassRanges_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports character class elements that can be simplified to ranges.",
-		id: "regexCharacterClassRanges",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferRange: {
-		primary: "Multiple adjacent characters can be simplified to a range '{{ range }}'.",
-		secondary: ["Character class ranges are more concise and readable than listing individual characters."],
-		suggestions: ["Replace the characters with the range '{{ range }}'."]
-	} },
-	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) return;
-			const regexpAst = parseRegexpAst(pattern, flags);
-			if (!regexpAst) return;
-			const nodeStart = node.getStart(sourceFile);
-			const patternOffset = 1;
-			visitRegExpAST(regexpAst, { onCharacterClassEnter(ccNode) {
-				const result = processCharacterClass(ccNode);
-				if (result) {
-					const sortedNodes = [...result.nodes].sort((a, b) => a.start - b.start);
-					const firstNode = sortedNodes[0];
-					const lastNode = sortedNodes.at(-1);
-					if (!firstNode || !lastNode) return;
-					const fixRanges = [];
-					for (const currentNode of sortedNodes) {
-						const begin = nodeStart + patternOffset + currentNode.start;
-						const end = nodeStart + patternOffset + currentNode.end;
-						if (!fixRanges.length) fixRanges.push({
-							begin,
-							end
-						});
-						else {
-							const lastRange = fixRanges.at(-1);
-							if (lastRange && lastRange.end >= begin) lastRange.end = Math.max(lastRange.end, end);
-							else fixRanges.push({
-								begin,
-								end
-							});
-						}
-					}
-					context.report({
-						data: { range: result.newRange },
-						fix: fixRanges.map((range, index) => ({
-							range,
-							text: index === 0 ? result.newRange : ""
-						})),
-						message: "preferRange",
-						range: getTSNodeRange(node, sourceFile)
-					});
-				}
-			} });
-		} } };
-	}
-});
-//#endregion
-export { regexCharacterClassRanges_default as default };

package/lib/rules/regexCharacterClassSetOperations.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports lookarounds that can be replaced with character class set operations.";
-    readonly id: "regexCharacterClassSetOperations";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferSetOperation", undefined>;
-export default _default;

package/lib/rules/regexCharacterClassSetOperations.js

@@ -1,79 +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/regexCharacterClassSetOperations.ts
-function escapeRaw(raw) {
-	return /^[&\-^]$/u.test(raw) ? `\\${raw}` : raw;
-}
-function isCharElement(node) {
-	return node.type === "Character" || node.type === "CharacterSet" || node.type === "CharacterClass" || node.type === "ExpressionCharacterClass";
-}
-function isCharLookaround(node) {
-	if (node.type !== "Assertion" || node.kind !== "lookahead" && node.kind !== "lookbehind") return false;
-	const firstAlt = node.alternatives[0];
-	if (!firstAlt || node.alternatives.length !== 1) return false;
-	const firstElement = firstAlt.elements[0];
-	if (firstAlt.elements.length !== 1) return false;
-	return isCharElement(firstElement);
-}
-var regexCharacterClassSetOperations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports lookarounds that can be replaced with character class set operations.",
-		id: "regexCharacterClassSetOperations",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferSetOperation: {
-		primary: "This lookaround can be combined with '{{ char }}' using a set operation.",
-		secondary: ["Character class set operations (using the v flag) are more readable and performant than lookarounds."],
-		suggestions: ["Replace the lookaround with a character class set operation."]
-	} },
-	setup(context) {
-		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
-			const text = node.getText(sourceFile);
-			const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(text);
-			if (!match) return;
-			const [, pattern, flagsStr] = match;
-			if (!pattern || !flagsStr?.includes("v")) return;
-			const regexpAst = parseRegexpAst(pattern);
-			if (!regexpAst) return;
-			visitRegExpAST(regexpAst, { onAlternativeEnter(alternative) {
-				const { elements } = alternative;
-				for (let i = 1; i < elements.length; i++) {
-					const previous = elements[i - 1];
-					const current = elements[i];
-					if (isCharElement(previous) && isCharLookaround(current) && current.kind === "lookbehind") {
-						const assertElement = current.alternatives[0].elements[0];
-						const operator = current.negate ? "--" : "&&";
-						const replacement = `[${escapeRaw(previous.raw)}${operator}${escapeRaw(assertElement.raw)}]`;
-						const nodeRange = getTSNodeRange(node, sourceFile);
-						context.report({
-							data: {
-								char: previous.raw,
-								replacement
-							},
-							message: "preferSetOperation",
-							range: nodeRange
-						});
-					}
-					if (isCharLookaround(previous) && previous.kind === "lookahead" && isCharElement(current)) {
-						const assertElement = previous.alternatives[0].elements[0];
-						const operator = previous.negate ? "--" : "&&";
-						const replacement = `[${escapeRaw(current.raw)}${operator}${escapeRaw(assertElement.raw)}]`;
-						const nodeRange = getTSNodeRange(node, sourceFile);
-						context.report({
-							data: {
-								char: current.raw,
-								replacement
-							},
-							message: "preferSetOperation",
-							range: nodeRange
-						});
-					}
-				}
-			} });
-		} } };
-	}
-});
-//#endregion
-export { regexCharacterClassSetOperations_default as default };

package/lib/rules/regexCharacterClasses.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports regex alternations that can be simplified to character classes.";
-    readonly id: "regexCharacterClasses";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferCharacterClass", undefined>;
-export default _default;

package/lib/rules/regexCharacterClasses.js

@@ -1,232 +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/regexCharacterClasses.ts
-const reservedDoublePunctuatorCharacters = /* @__PURE__ */ new Set([
-	"!",
-	"#",
-	"$",
-	"%",
-	"&",
-	"*",
-	"+",
-	",",
-	".",
-	":",
-	";",
-	"<",
-	"=",
-	">",
-	"?",
-	"@",
-	"^",
-	"`",
-	"~"
-]);
-function categorizeAlternative(alternative) {
-	if (isSingleCharElement(alternative.elements)) {
-		const element = alternative.elements[0];
-		const elements = toCharacterClassElement(element);
-		if (elements) return {
-			elements,
-			isCharacter: true,
-			raw: alternative.raw
-		};
-	}
-	return {
-		isCharacter: false,
-		raw: alternative.raw
-	};
-}
-function containsCharacterClass(alternatives) {
-	for (const alt of alternatives) if (alt.isCharacter && alt.raw.startsWith("[") && !alt.raw.startsWith("[^")) return true;
-	return false;
-}
-function elementsToCharacterClass(elements) {
-	const parts = [];
-	for (const element of elements) switch (element.type) {
-		case "Character":
-			if (element.raw === "-") parts.push("\\-");
-			else if (element.raw === "]") parts.push("\\]");
-			else parts.push(element.raw);
-			break;
-		case "CharacterClass":
-		case "CharacterClassRange":
-		case "CharacterSet":
-		case "ClassStringDisjunction":
-		case "ExpressionCharacterClass":
-			parts.push(element.raw);
-			break;
-	}
-	if (!parts.length) return "[]";
-	if (parts[0]?.[0] === "^") parts[0] = `\\${parts[0]}`;
-	for (let i = 1; i < parts.length; i++) {
-		const prev = parts[i - 1];
-		const curr = parts[i];
-		if (prev && curr) {
-			const pChar = prev.slice(-1);
-			const cChar = curr[0];
-			if (cChar && reservedDoublePunctuatorCharacters.has(cChar) && cChar === pChar && !prev.endsWith(`\\${pChar}`)) parts[i - 1] = `${prev.slice(0, -1)}\\${pChar}`;
-		}
-	}
-	return `[${parts.join("")}]`;
-}
-function getParentPrefixAndSuffix(parent) {
-	switch (parent.type) {
-		case "Assertion": return [`(?${parent.kind === "lookahead" ? "" : "<"}${parent.negate ? "!" : "="}`, ")"];
-		case "CapturingGroup":
-			if (parent.name !== null) return [`(?<${parent.name}>`, ")"];
-			return ["(", ")"];
-		case "Group": return ["(?:", ")"];
-		case "Pattern": return ["", ""];
-	}
-}
-function isSingleCharElement(elements) {
-	if (elements.length !== 1) return false;
-	const element = elements[0];
-	return element !== void 0 && (element.type === "Character" || element.type === "CharacterClass" || element.type === "CharacterSet" || element.type === "ExpressionCharacterClass");
-}
-function mergeCharacterAlternatives(a, b) {
-	const elements = [...a.elements, ...b.elements];
-	return {
-		elements,
-		isCharacter: true,
-		raw: elementsToCharacterClass(elements)
-	};
-}
-function optimizeAlternatives(alternatives) {
-	const result = [...alternatives];
-	for (let i = 0; i < result.length - 1; i++) {
-		let current = result[i];
-		if (!current?.isCharacter) continue;
-		for (let j = i + 1; j < result.length; j++) {
-			const next = result[j];
-			if (!next) continue;
-			if (next.isCharacter) {
-				current = mergeCharacterAlternatives(current, next);
-				result.splice(j, 1);
-				j--;
-			} else break;
-		}
-		result[i] = current;
-	}
-	return result;
-}
-function toCharacterClassElement(element) {
-	switch (element.type) {
-		case "Character": return [element];
-		case "CharacterClass":
-			if (element.negate && !element.unicodeSets) return;
-			if (element.negate) return [element];
-			return element.elements;
-		case "CharacterSet":
-			if (element.kind === "any") return;
-			return [element];
-		case "ExpressionCharacterClass": return [element];
-		default: return;
-	}
-}
-var regexCharacterClasses_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports regex alternations that can be simplified to character classes.",
-		id: "regexCharacterClasses",
-		presets: ["stylisticStrict"]
-	},
-	messages: { preferCharacterClass: {
-		primary: "This alternation can be simplified to a character class '{{ replacement }}'.",
-		secondary: ["Character classes are more efficient than alternations and don't require backtracking."],
-		suggestions: ["Replace the alternation with a character class '{{ replacement }}'."]
-	} },
-	setup(context) {
-		function processAlternatives(node) {
-			const alternatives = node.alternatives;
-			if (alternatives.length < 2) return;
-			const parsed = alternatives.map(categorizeAlternative);
-			const characterCount = parsed.filter((a) => a.isCharacter).length;
-			if (characterCount < 2) return;
-			if (characterCount < 3 && !containsCharacterClass(parsed)) return;
-			const optimized = optimizeAlternatives(parsed);
-			if (optimized.length === parsed.length) return;
-			const replacement = optimized.map((a) => a.raw).join("|");
-			const [prefix, suffix] = getParentPrefixAndSuffix(node);
-			return {
-				fixedPattern: prefix + replacement + suffix,
-				replacement
-			};
-		}
-		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
-			const text = node.getText(sourceFile);
-			const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(text);
-			if (!match) return;
-			const [, pattern, flags = ""] = match;
-			if (!pattern) return;
-			const regexpAst = parseRegexpAst(pattern, flags);
-			if (!regexpAst) return;
-			const nodeRange = getTSNodeRange(node, sourceFile);
-			visitRegExpAST(regexpAst, {
-				onAssertionEnter(assertion) {
-					if (assertion.kind === "lookahead" || assertion.kind === "lookbehind") {
-						const result = processAlternatives(assertion);
-						if (result) {
-							const newPattern = pattern.slice(0, assertion.start) + result.fixedPattern + pattern.slice(assertion.end);
-							context.report({
-								data: { replacement: result.replacement },
-								fix: {
-									range: nodeRange,
-									text: `/${newPattern}/${flags}`
-								},
-								message: "preferCharacterClass",
-								range: nodeRange
-							});
-						}
-					}
-				},
-				onCapturingGroupEnter(group) {
-					const result = processAlternatives(group);
-					if (result) {
-						const newPattern = pattern.slice(0, group.start) + result.fixedPattern + pattern.slice(group.end);
-						context.report({
-							data: { replacement: result.replacement },
-							fix: {
-								range: nodeRange,
-								text: `/${newPattern}/${flags}`
-							},
-							message: "preferCharacterClass",
-							range: nodeRange
-						});
-					}
-				},
-				onGroupEnter(group) {
-					const result = processAlternatives(group);
-					if (result) {
-						const newPattern = pattern.slice(0, group.start) + result.fixedPattern + pattern.slice(group.end);
-						context.report({
-							data: { replacement: result.replacement },
-							fix: {
-								range: nodeRange,
-								text: `/${newPattern}/${flags}`
-							},
-							message: "preferCharacterClass",
-							range: nodeRange
-						});
-					}
-				},
-				onPatternEnter(patternNode) {
-					const result = processAlternatives(patternNode);
-					if (result) context.report({
-						data: { replacement: result.replacement },
-						fix: {
-							range: nodeRange,
-							text: `/${result.replacement}/${flags}`
-						},
-						message: "preferCharacterClass",
-						range: nodeRange
-					});
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { regexCharacterClasses_default as default };

package/lib/rules/regexConciseCharacterClassNegations.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports negated character classes that can use shorthand escapes.";
-    readonly id: "regexConciseCharacterClassNegations";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNegatedEscape", undefined>;
-export default _default;

package/lib/rules/regexConciseCharacterClassNegations.js

@@ -1,50 +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/regexConciseCharacterClassNegations.ts
-function getNegationText(node) {
-	if (node.type === "ExpressionCharacterClass") return `[${node.raw.slice(2, -1)}]`;
-	const kind = node.raw[1];
-	if (!kind) return;
-	return `\\${kind.toLowerCase() === kind ? kind.toUpperCase() : kind.toLowerCase()}${node.raw.slice(2)}`;
-}
-var regexConciseCharacterClassNegations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports negated character classes that can use shorthand escapes.",
-		id: "regexConciseCharacterClassNegations",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferNegatedEscape: {
-		primary: "Use '{{ replacement }}' instead of negated character class.",
-		secondary: ["Shorthand escape sequences like \\D, \\W, and \\S are more concise than negated character classes."],
-		suggestions: ["Replace the negated character class with '{{ replacement }}'."]
-	} },
-	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) return;
-			const regexpAst = parseRegexpAst(pattern, flags);
-			if (!regexpAst) return;
-			const hasIgnoreCase = flags?.includes("i") ?? false;
-			visitRegExpAST(regexpAst, { onCharacterClassEnter(characterClassNode) {
-				if (!characterClassNode.negate || characterClassNode.elements.length !== 1) return;
-				const element = characterClassNode.elements[0];
-				if (element.type !== "CharacterSet" && element.type !== "ExpressionCharacterClass") return;
-				if (element.type === "CharacterSet" && element.kind === "property" && hasIgnoreCase) return;
-				const replacement = getNegationText(element);
-				if (!replacement) return;
-				context.report({
-					data: { replacement },
-					message: "preferNegatedEscape",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			} });
-		} } };
-	}
-});
-//#endregion
-export { regexConciseCharacterClassNegations_default as default };

package/lib/rules/regexContradictoryAssertions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports elements in regular expressions that contradict assertions.";
-    readonly id: "regexContradictoryAssertions";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "alwaysEnter" | "cannotEnter", undefined>;
-export default _default;