@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/regexUnusedLazyQuantifiers.js

@@ -0,0 +1,63 @@
+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/regexUnusedLazyQuantifiers.ts
+var regexUnusedLazyQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports lazy quantifiers that have no effect because the quantifier is constant.",
+		id: "regexUnusedLazyQuantifiers",
+		presets: ["logical"]
+	},
+	messages: { uselessLazy: {
+		primary: "Lazy quantifier `{{ raw }}` has no effect because the quantifier matches exactly {{ count }} time(s).",
+		secondary: ["When a quantifier has fixed bounds (min equals max), there is no choice in how many times to match, so lazy vs greedy is irrelevant."],
+		suggestions: ["Remove the '?' to use the greedy form."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onQuantifierEnter(node) {
+				if (!node.greedy && node.min === node.max) {
+					const range = {
+						begin: patternStart + node.start,
+						end: patternStart + node.end
+					};
+					context.report({
+						data: {
+							count: node.min,
+							raw: node.raw
+						},
+						fix: {
+							range,
+							text: node.raw.slice(0, -1)
+						},
+						message: "uselessLazy",
+						range
+					});
+				}
+			} });
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			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 { regexUnusedLazyQuantifiers_default as default };
+
+//# sourceMappingURL=regexUnusedLazyQuantifiers.js.map

package/lib/rules/regexUnusedQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports quantifiers that match exactly once, making them unnecessary.";
+    readonly id: "regexUnusedQuantifiers";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "uselessQuantifier", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnusedQuantifiers.d.ts.map

package/lib/rules/regexUnusedQuantifiers.js

@@ -0,0 +1,63 @@
+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/regexUnusedQuantifiers.ts
+var regexUnusedQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports quantifiers that match exactly once, making them unnecessary.",
+		id: "regexUnusedQuantifiers",
+		presets: ["logical"]
+	},
+	messages: { uselessQuantifier: {
+		primary: "Quantifier `{{ raw }}` is unnecessary because it matches exactly once.",
+		secondary: ["A quantifier that matches exactly once can be removed without changing the pattern's behavior."],
+		suggestions: ["Remove the quantifier if one match is all that is needed.", "Change the quantifier if multiple matches are intended."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onQuantifierEnter(node) {
+				if (node.min === 1 && node.max === 1) {
+					const quantifierStart = node.element.end;
+					context.report({
+						data: { raw: node.raw },
+						fix: {
+							range: {
+								begin: patternStart + quantifierStart,
+								end: patternStart + node.end
+							},
+							text: ""
+						},
+						message: "uselessQuantifier",
+						range: {
+							begin: patternStart + node.start,
+							end: patternStart + node.end
+						}
+					});
+				}
+			} });
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			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 { regexUnusedQuantifiers_default as default };
+
+//# sourceMappingURL=regexUnusedQuantifiers.js.map

package/lib/rules/regexValidity.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports invalid regular expressions.";
+    readonly id: "regexValidity";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "conflictingFlags" | "duplicateFlag" | "invalidFlag" | "invalidPattern", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexValidity.d.ts.map

package/lib/rules/regexValidity.js

@@ -0,0 +1,146 @@
+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 = 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 };
+
+//# sourceMappingURL=regexValidity.js.map

package/lib/rules/regexWordMatchers.d.ts

@@ -0,0 +1,10 @@
+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: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferWord", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexWordMatchers.d.ts.map

package/lib/rules/regexWordMatchers.js

@@ -0,0 +1,146 @@
+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 };
+
+//# sourceMappingURL=regexWordMatchers.js.map

package/lib/rules/regexZeroQuantifiers.d.ts

@@ -0,0 +1,10 @@
+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: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "uselessZero", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexZeroQuantifiers.d.ts.map

package/lib/rules/regexZeroQuantifiers.js

@@ -0,0 +1,60 @@
+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 };
+
+//# sourceMappingURL=regexZeroQuantifiers.js.map

package/lib/rules/responseJsonMethods.d.ts

@@ -0,0 +1,10 @@
+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: ["stylistic"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferResponseJson", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=responseJsonMethods.d.ts.map

package/lib/rules/responseJsonMethods.js

@@ -0,0 +1,51 @@
+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 };
+
+//# sourceMappingURL=responseJsonMethods.js.map

package/lib/rules/restrictedIdentifiers.d.ts

@@ -0,0 +1,13 @@
+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: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "restricted", {
+    readonly deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}>;
+export default _default;
+//# sourceMappingURL=restrictedIdentifiers.d.ts.map

package/lib/rules/restrictedIdentifiers.js

@@ -0,0 +1,41 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import z$1 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$1.array(z$1.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 };
+
+//# sourceMappingURL=restrictedIdentifiers.js.map

package/lib/rules/returnAssignments.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using assignment expressions in return statements.";
     readonly id: "returnAssignments";
-    readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noReturnAssign", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noReturnAssign", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=returnAssignments.d.ts.map