@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/regexValidity.js

@@ -1,144 +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 * as ts$1 from "typescript";
-//#region src/rules/regexValidity.ts
-const validFlags = /* @__PURE__ */ new Set([
-	"d",
-	"g",
-	"i",
-	"m",
-	"s",
-	"u",
-	"v",
-	"y"
-]);
-var regexValidity_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports invalid regular expressions.",
-		id: "regexValidity",
-		presets: ["logical"]
-	},
-	messages: {
-		conflictingFlags: {
-			primary: "The `u` and `v` flags cannot be used together.",
-			secondary: ["These flags enable mutually exclusive Unicode modes."],
-			suggestions: ["Use either `u` or `v`, but not both."]
-		},
-		duplicateFlag: {
-			primary: "Duplicate regular expression flag `{{ flag }}`.",
-			secondary: ["Each flag can only appear once."],
-			suggestions: ["Remove the duplicate flag."]
-		},
-		invalidFlag: {
-			primary: "Invalid regular expression flag `{{ flag }}`.",
-			secondary: ["Valid flags are: d, g, i, m, s, u, v, y."],
-			suggestions: ["Remove the invalid flag."]
-		},
-		invalidPattern: {
-			primary: "Invalid regular expression pattern.",
-			secondary: ["This RegExp constructor call will throw at runtime."],
-			suggestions: ["Fix the regular expression syntax."]
-		}
-	},
-	setup(context) {
-		function checkFlags(flags, flagsStart) {
-			const seenFlags = /* @__PURE__ */ new Set();
-			let hasU = false;
-			let hasV = false;
-			let uPosition = -1;
-			let vPosition = -1;
-			let hasInvalidFlags = false;
-			for (let i = 0; i < flags.length; i += 1) {
-				const flag = flags[i];
-				if (!validFlags.has(flag)) {
-					hasInvalidFlags = true;
-					context.report({
-						data: { flag },
-						message: "invalidFlag",
-						range: {
-							begin: flagsStart + i,
-							end: flagsStart + i + 1
-						}
-					});
-					continue;
-				}
-				if (seenFlags.has(flag)) {
-					hasInvalidFlags = true;
-					context.report({
-						data: { flag },
-						message: "duplicateFlag",
-						range: {
-							begin: flagsStart + i,
-							end: flagsStart + i + 1
-						}
-					});
-					continue;
-				}
-				seenFlags.add(flag);
-				if (flag === "u") {
-					hasU = true;
-					uPosition = i;
-				} else if (flag === "v") {
-					hasV = true;
-					vPosition = i;
-				}
-			}
-			if (hasU && hasV) {
-				hasInvalidFlags = true;
-				const laterPosition = Math.max(uPosition, vPosition);
-				context.report({
-					message: "conflictingFlags",
-					range: {
-						begin: flagsStart + laterPosition,
-						end: flagsStart + laterPosition + 1
-					}
-				});
-			}
-			return hasInvalidFlags;
-		}
-		function checkPattern(pattern, flags, patternStart, patternEnd) {
-			if (parseRegexpAst(pattern, flags) === void 0) context.report({
-				message: "invalidPattern",
-				range: {
-					begin: patternStart,
-					end: patternEnd
-				}
-			});
-		}
-		function checkRegexLiteral(node, services) {
-			const details = getRegExpLiteralDetails(node, services);
-			const flagsStart = node.getStart(services.sourceFile) + node.text.length - details.flags.length;
-			if (checkFlags(details.flags, flagsStart)) return;
-			const patternStart = details.start;
-			const patternEnd = flagsStart - 1;
-			checkPattern(details.pattern, details.flags, patternStart, patternEnd);
-		}
-		function checkRegExpConstructor(node, services) {
-			const construction = getRegExpConstruction(node, services);
-			if (!construction) return;
-			const firstArgument = construction.args[0];
-			let hasInvalidFlags = false;
-			if (construction.args.length >= 2) {
-				const secondArgument = construction.args[1];
-				if (secondArgument.kind === ts$1.SyntaxKind.StringLiteral) {
-					const flagsStart = secondArgument.getStart(services.sourceFile) + 1;
-					hasInvalidFlags = checkFlags(construction.flags, flagsStart);
-				}
-			}
-			if (hasInvalidFlags) return;
-			const patternStart = firstArgument.getStart(services.sourceFile) + 1;
-			const patternEnd = firstArgument.getEnd() - 1;
-			checkPattern(construction.raw, construction.flags, patternStart, patternEnd);
-		}
-		return { visitors: {
-			CallExpression: checkRegExpConstructor,
-			NewExpression: checkRegExpConstructor,
-			RegularExpressionLiteral: checkRegexLiteral
-		} };
-	}
-});
-//#endregion
-export { regexValidity_default as default };

package/lib/rules/regexWordMatchers.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports character classes that match word characters and could use \\w or \\W instead.";
-    readonly id: "regexWordMatchers";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferWord", undefined>;
-export default _default;

package/lib/rules/regexWordMatchers.js

@@ -1,144 +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/regexWordMatchers.ts
-function findIssues(pattern, flags) {
-	const issues = [];
-	const hasIgnoreCase = flags.includes("i");
-	const ast = parseRegexpAst(pattern, flags);
-	if (!ast) return issues;
-	visitRegExpAST(ast, { onCharacterClassEnter(characterClassNode) {
-		const expectedCount = hasIgnoreCase ? 3 : 4;
-		if (characterClassNode.elements.length !== expectedCount) return;
-		let hasDigit = false;
-		let hasLower = false;
-		let hasUpper = false;
-		let hasUnderscore = false;
-		for (const element of characterClassNode.elements) if (isDigitRange(element)) {
-			if (hasDigit) return;
-			hasDigit = true;
-		} else if (isLowerRange(element)) {
-			if (hasLower) return;
-			hasLower = true;
-		} else if (isUpperRange(element)) {
-			if (hasUpper) return;
-			hasUpper = true;
-		} else if (isUnderscore(element)) {
-			if (hasUnderscore) return;
-			hasUnderscore = true;
-		} else return;
-		if (!(hasIgnoreCase ? hasDigit && hasLower && hasUnderscore && !hasUpper : hasDigit && hasLower && hasUpper && hasUnderscore)) return;
-		issues.push({
-			end: characterClassNode.end,
-			negated: characterClassNode.negate,
-			raw: characterClassNode.raw,
-			start: characterClassNode.start
-		});
-	} });
-	return issues;
-}
-function isDigitRange(element) {
-	if (element.type === "CharacterSet" && element.kind === "digit") return true;
-	if (element.type === "CharacterClassRange") return element.min.value === 48 && element.max.value === 57;
-	return false;
-}
-function isLowerRange(element) {
-	if (element.type === "CharacterClassRange") return element.min.value === 97 && element.max.value === 122;
-	return false;
-}
-function isUnderscore(element) {
-	if (element.type === "Character") return element.value === 95;
-	return false;
-}
-function isUpperRange(element) {
-	if (element.type === "CharacterClassRange") return element.min.value === 65 && element.max.value === 90;
-	return false;
-}
-var regexWordMatchers_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports character classes that match word characters and could use \\w or \\W instead.",
-		id: "regexWordMatchers",
-		presets: ["stylisticStrict"]
-	},
-	messages: { preferWord: {
-		primary: "Character class '{{ raw }}' can be replaced with '{{ replacement }}'.",
-		secondary: ["The \\w shorthand matches [a-zA-Z0-9_] (word characters)."],
-		suggestions: ["Replace with '{{ replacement }}'."]
-	} },
-	setup(context) {
-		function checkRegexLiteral(node, services) {
-			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
-			const issues = findIssues(pattern, flags);
-			for (const issue of issues) {
-				const replacement = issue.negated ? "\\W" : "\\w";
-				context.report({
-					data: {
-						raw: issue.raw,
-						replacement
-					},
-					fix: {
-						range: {
-							begin: start + issue.start,
-							end: start + issue.end
-						},
-						text: replacement
-					},
-					message: "preferWord",
-					range: {
-						begin: start + issue.start,
-						end: start + issue.end
-					}
-				});
-			}
-		}
-		function checkRegExpConstructor(node, services) {
-			const construction = getRegExpConstruction(node, services);
-			if (!construction) return;
-			const { flags, pattern, start } = construction;
-			const issues = findIssues(pattern.replace(/\\\\/g, "\\"), flags);
-			function mapPositionToSource(pos) {
-				let sourcePos = 0;
-				let patternPos = 0;
-				while (patternPos < pos && sourcePos < pattern.length) {
-					if (pattern[sourcePos] === "\\" && pattern[sourcePos + 1] === "\\") sourcePos += 2;
-					else sourcePos += 1;
-					patternPos += 1;
-				}
-				return sourcePos;
-			}
-			for (const issue of issues) {
-				const replacement = issue.negated ? "\\\\W" : "\\\\w";
-				const adjustedStart = mapPositionToSource(issue.start);
-				const adjustedEnd = mapPositionToSource(issue.end);
-				context.report({
-					data: {
-						raw: issue.raw,
-						replacement: issue.negated ? "\\W" : "\\w"
-					},
-					fix: {
-						range: {
-							begin: start + 1 + adjustedStart,
-							end: start + 1 + adjustedEnd
-						},
-						text: replacement
-					},
-					message: "preferWord",
-					range: {
-						begin: start + 1 + adjustedStart,
-						end: start + 1 + adjustedEnd
-					}
-				});
-			}
-		}
-		return { visitors: {
-			CallExpression: checkRegExpConstructor,
-			NewExpression: checkRegExpConstructor,
-			RegularExpressionLiteral: checkRegexLiteral
-		} };
-	}
-});
-//#endregion
-export { regexWordMatchers_default as default };

package/lib/rules/regexZeroQuantifiers.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports quantifiers with a maximum of zero, which are useless.";
-    readonly id: "regexZeroQuantifiers";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "uselessZero", undefined>;
-export default _default;

package/lib/rules/regexZeroQuantifiers.js

@@ -1,58 +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/regexZeroQuantifiers.ts
-var regexZeroQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports quantifiers with a maximum of zero, which are useless.",
-		id: "regexZeroQuantifiers",
-		presets: ["logical"]
-	},
-	messages: { uselessZero: {
-		primary: "Quantifier '{{ raw }}' has a maximum of 0 and is useless.",
-		secondary: ["This quantified element will always be repeated zero times and can be removed."],
-		suggestions: ["Remove the quantifier and its quantified element."]
-	} },
-	setup(context) {
-		function checkPattern(pattern, patternStart, flags, emptyReplacement) {
-			const regexpAst = parseRegexpAst(pattern, flags);
-			if (!regexpAst) return;
-			visitRegExpAST(regexpAst, { onQuantifierEnter(node) {
-				if (node.max !== 0) return;
-				const range = {
-					begin: patternStart + node.start,
-					end: patternStart + node.end
-				};
-				const isWholePattern = node.start === 0 && node.end === pattern.length;
-				context.report({
-					data: { raw: node.raw },
-					fix: {
-						range,
-						text: isWholePattern ? emptyReplacement : ""
-					},
-					message: "uselessZero",
-					range
-				});
-			} });
-		}
-		function checkRegexLiteral(node, { sourceFile }) {
-			const details = getRegExpLiteralDetails(node, { sourceFile });
-			checkPattern(details.pattern, details.start, details.flags, "(?:)");
-		}
-		function checkRegExpConstructor(node, services) {
-			const construction = getRegExpConstruction(node, services);
-			if (!construction) return;
-			checkPattern(construction.pattern, construction.start + 1, construction.flags, "");
-		}
-		return { visitors: {
-			CallExpression: checkRegExpConstructor,
-			NewExpression: checkRegExpConstructor,
-			RegularExpressionLiteral: checkRegexLiteral
-		} };
-	}
-});
-//#endregion
-export { regexZeroQuantifiers_default as default };

package/lib/rules/requireImports.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports CommonJS require() imports in favor of ES module imports.";
-    readonly id: "requireImports";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noRequireImports", undefined>;
-export default _default;

package/lib/rules/requireImports.js

@@ -1,46 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/requireImports.ts
-function isGlobalRequire(node, typeChecker) {
-	if (!ts.isIdentifier(node) || node.text !== "require") return false;
-	const symbol = typeChecker.getSymbolAtLocation(node);
-	if (!symbol) return true;
-	const declarations = symbol.getDeclarations();
-	if (!declarations?.length) return true;
-	return declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile);
-}
-var requireImports_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports CommonJS require() imports in favor of ES module imports.",
-		id: "requireImports",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noRequireImports: {
-		primary: "Prefer ESM `import` statements over legacy CommonJS `require()` calls.",
-		secondary: [
-			"ESM (EcmaScript Modules) provide better static analysis, tree-shaking, and are the standard in modern JavaScript/TypeScript.",
-			"CJS (CommonJS) `require()` calls are a legacy pattern that don't play as well with modern tooling.",
-			"It's generally preferable in modern projects to prefer ESM over CJS."
-		],
-		suggestions: ["Convert this CJS `require()` call to an ESM `import` statement."]
-	} },
-	setup(context) {
-		return { visitors: {
-			CallExpression: (node, { sourceFile, typeChecker }) => {
-				if (isGlobalRequire(node.expression, typeChecker)) context.report({
-					message: "noRequireImports",
-					range: getTSNodeRange(node.expression, sourceFile)
-				});
-			},
-			ImportEqualsDeclaration: (node, { sourceFile }) => {
-				if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) context.report({
-					message: "noRequireImports",
-					range: getTSNodeRange(node.moduleReference, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { requireImports_default as default };

package/lib/rules/responseJsonMethods.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer `Response.json()` over `new Response(JSON.stringify(...))` for JSON responses.";
-    readonly id: "responseJsonMethods";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferResponseJson", undefined>;
-export default _default;

package/lib/rules/responseJsonMethods.js

@@ -1,49 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/responseJsonMethods.ts
-function isAcceptableSecondArgument(node) {
-	return isEmptyObjectLiteral(node) || isJsonContentTypeHeadersObject(node);
-}
-function isEmptyObjectLiteral(node) {
-	return ts$1.isObjectLiteralExpression(node) && !node.properties.length;
-}
-function isJsonContentTypeHeader(node) {
-	if (!ts$1.isObjectLiteralExpression(node) || node.properties.length !== 1) return false;
-	const property = node.properties[0];
-	return ts$1.isPropertyAssignment(property) && (ts$1.isIdentifier(property.name) || ts$1.isStringLiteral(property.name)) && property.name.text.toLowerCase() === "content-type" && ts$1.isStringLiteral(property.initializer) && property.initializer.text.toLowerCase().startsWith("application/json");
-}
-function isJsonContentTypeHeadersObject(node) {
-	if (!ts$1.isObjectLiteralExpression(node) || node.properties.length !== 1) return false;
-	const property = node.properties[0];
-	return ts$1.isPropertyAssignment(property) && (ts$1.isIdentifier(property.name) || ts$1.isStringLiteral(property.name)) && property.name.text.toLowerCase() === "headers" && isJsonContentTypeHeader(property.initializer);
-}
-function isJsonStringifyCall(node) {
-	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && ts$1.isIdentifier(node.expression.expression) && node.expression.expression.text === "JSON" && ts$1.isIdentifier(node.expression.name) && node.expression.name.text === "stringify";
-}
-var responseJsonMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer `Response.json()` over `new Response(JSON.stringify(...))` for JSON responses.",
-		id: "responseJsonMethods",
-		presets: ["stylistic"]
-	},
-	messages: { preferResponseJson: {
-		primary: "Prefer the cleaner `Response.json()` instead of `new Response(JSON.stringify(...))`.",
-		secondary: ["Response.json() is more concise and sets the Content-Type header automatically."],
-		suggestions: ["Replace with `Response.json()`."]
-	} },
-	setup(context) {
-		return { visitors: { NewExpression: (node, { sourceFile }) => {
-			if (!ts$1.isIdentifier(node.expression) || node.expression.text !== "Response" || !node.arguments?.length || node.arguments.length > 2) return;
-			const firstArgument = node.arguments[0];
-			if (!isJsonStringifyCall(firstArgument) || firstArgument.arguments.length !== 1) return;
-			if (node.arguments.length === 2 && !isAcceptableSecondArgument(node.arguments[1])) return;
-			context.report({
-				message: "preferResponseJson",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { responseJsonMethods_default as default };

package/lib/rules/restrictedIdentifiers.d.ts

@@ -1,12 +0,0 @@
-import z from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Disallows specific identifier names in binding positions.";
-    readonly id: "restrictedIdentifiers";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "restricted", {
-    deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}>;
-export default _default;

package/lib/rules/restrictedIdentifiers.js

@@ -1,39 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import z from "zod/v4";
-//#region src/rules/restrictedIdentifiers.ts
-var restrictedIdentifiers_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Disallows specific identifier names in binding positions.",
-		id: "restrictedIdentifiers",
-		presets: ["stylisticStrict"]
-	},
-	messages: { restricted: {
-		primary: "Identifier '{{ name }}' is restricted.",
-		secondary: ["This identifier name is on this project's denylist."],
-		suggestions: ["Rename the identifier to something allowed in the project."]
-	} },
-	options: { deny: z.array(z.string()).optional() },
-	setup(context) {
-		function checkNode(node, { options, sourceFile }) {
-			if (node.name?.kind !== ts.SyntaxKind.Identifier || !options.deny?.includes(node.name.text)) return;
-			context.report({
-				data: { name: node.name.text },
-				message: "restricted",
-				range: getTSNodeRange(node.name, sourceFile)
-			});
-		}
-		return { visitors: {
-			ClassDeclaration: checkNode,
-			FunctionDeclaration: checkNode,
-			ImportClause: checkNode,
-			ImportSpecifier: checkNode,
-			NamespaceImport: checkNode,
-			Parameter: checkNode,
-			VariableDeclaration: checkNode
-		} };
-	}
-});
-//#endregion
-export { restrictedIdentifiers_default as default };

package/lib/rules/restrictedImports.d.ts

@@ -1,26 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Restricts specified modules from being imported.";
-    readonly id: "restrictedImports";
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "restricted" | "moduleRestricted" | "moduleRestrictedWithMessage" | "namespaceRestricted" | "namespaceRestrictedWithMessage" | "restrictedWithMessage", {
-    restrictions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        allowTypeImports: z.ZodOptional<z.ZodBoolean>;
-        message: z.ZodOptional<z.ZodString>;
-        specifier: z.ZodUnion<readonly [z.ZodObject<{
-            from: z.ZodLiteral<"file">;
-            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-            path: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            from: z.ZodLiteral<"lib">;
-            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-        }, z.core.$strip>, z.ZodObject<{
-            from: z.ZodLiteral<"package">;
-            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-            package: z.ZodString;
-        }, z.core.$strip>]>;
-    }, z.core.$strip>>>;
-}>;
-export default _default;