@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/emptyStaticBlocks.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports empty static initialization blocks within class declarations.";
     readonly id: "emptyStaticBlocks";
-    readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "emptyStaticBlock", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "emptyStaticBlock", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=emptyStaticBlocks.d.ts.map

package/lib/rules/emptyStaticBlocks.js

@@ -1,54 +1,42 @@
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports empty static initialization blocks within class declarations.",
-        id: "emptyStaticBlocks",
-        preset: "stylistic",
-    },
-    messages: {
-        emptyStaticBlock: {
-            primary: "Empty static blocks serve no purpose and should be removed for cleaner code.",
-            secondary: [
-                "Static blocks are used to initialize static class properties or perform other one-time setup when a class is loaded.",
-                "An empty static block has no statements and therefore serves no purpose.",
-            ],
-            suggestions: [
-                "Remove the empty static block, or add initialization logic if needed.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                ClassStaticBlockDeclaration: (node) => {
-                    const statements = node.body.statements;
-                    if (statements.length) {
-                        return;
-                    }
-                    const openBrace = node.body.getFirstToken(context.sourceFile);
-                    if (!openBrace) {
-                        return;
-                    }
-                    const range = {
-                        begin: node.getStart(context.sourceFile),
-                        end: openBrace.getEnd(),
-                    };
-                    context.report({
-                        message: "emptyStaticBlock",
-                        range,
-                        suggestions: [
-                            {
-                                id: "removeEmptyStaticBlock",
-                                range: {
-                                    begin: node.getStart(context.sourceFile),
-                                    end: node.getEnd(),
-                                },
-                                text: "",
-                            },
-                        ],
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/emptyStaticBlocks.ts
+var emptyStaticBlocks_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports empty static initialization blocks within class declarations.",
+		id: "emptyStaticBlocks",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { emptyStaticBlock: {
+		primary: "Empty static blocks serve no purpose and should be removed for cleaner code.",
+		secondary: ["Static blocks are used to initialize static class properties or perform other one-time setup when a class is loaded.", "An empty static block has no statements and therefore serves no purpose."],
+		suggestions: ["Remove the empty static block, or add initialization logic if needed."]
+	} },
+	setup(context) {
+		return { visitors: { ClassStaticBlockDeclaration: (node, { sourceFile }) => {
+			if (node.body.statements.length) return;
+			const openBrace = node.body.getFirstToken(sourceFile);
+			if (!openBrace) return;
+			const range = {
+				begin: node.getStart(sourceFile),
+				end: openBrace.getEnd()
+			};
+			context.report({
+				message: "emptyStaticBlock",
+				range,
+				suggestions: [{
+					id: "removeEmptyStaticBlock",
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.getEnd()
+					},
+					text: ""
+				}]
+			});
+		} } };
+	}
 });
+//#endregion
+export { emptyStaticBlocks_default as default };
+
+//# sourceMappingURL=emptyStaticBlocks.js.map

package/lib/rules/emptyTypeParameterLists.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty type parameter lists in type aliases and interfaces.";
+    readonly id: "emptyTypeParameterLists";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "emptyTypeParameters", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=emptyTypeParameterLists.d.ts.map

package/lib/rules/emptyTypeParameterLists.js

@@ -0,0 +1,31 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/emptyTypeParameterLists.ts
+var emptyTypeParameterLists_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports empty type parameter lists in type aliases and interfaces.",
+		id: "emptyTypeParameterLists",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { emptyTypeParameters: {
+		primary: "Empty type parameter lists are unnecessary.",
+		secondary: ["TypeScript permits empty type parameter lists like `<>`, but this practice is discouraged.", "Empty type parameter lists can lead to unclear or ambiguous code."],
+		suggestions: ["Remove the empty type parameter list, or add type parameters if needed."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile }) {
+			if (node.typeParameters && !node.typeParameters.length) context.report({
+				message: "emptyTypeParameters",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		}
+		return { visitors: {
+			InterfaceDeclaration: checkNode,
+			TypeAliasDeclaration: checkNode
+		} };
+	}
+});
+//#endregion
+export { emptyTypeParameterLists_default as default };
+
+//# sourceMappingURL=emptyTypeParameterLists.js.map

package/lib/rules/enumInitializers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports enum members without explicit initial values.";
+    readonly id: "enumInitializers";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "defineInitializer", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=enumInitializers.d.ts.map

package/lib/rules/enumInitializers.js

@@ -0,0 +1,54 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/enumInitializers.ts
+var enumInitializers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports enum members without explicit initial values.",
+		id: "enumInitializers",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { defineInitializer: {
+		primary: "Enum member '{{ name }}' has an implicit initializer that may change if the enum is reordered.",
+		secondary: ["Enum members without explicit values are assigned sequentially increasing numbers.", "This can cause unintended value changes if enum members are reordered or removed."],
+		suggestions: ["For numeric enums, add an index-based value such as `{{ name }} = {{ suggestedIndex }}`.", "For string enums, add a string value such as `{{ name }} = '{{ name }}'`."]
+	} },
+	setup(context) {
+		return { visitors: { EnumDeclaration: (node, { sourceFile }) => {
+			for (const [index, member] of node.members.entries()) {
+				if (member.initializer !== void 0) continue;
+				const name = member.name.kind === SyntaxKind.Identifier ? member.name.text : member.name.getText(sourceFile);
+				const range = getTSNodeRange(member, sourceFile);
+				context.report({
+					data: {
+						name,
+						suggestedIndex: index
+					},
+					message: "defineInitializer",
+					range,
+					suggestions: [
+						{
+							id: "assignIndex",
+							range,
+							text: `${name} = ${index}`
+						},
+						{
+							id: "assignIncrementedIndex",
+							range,
+							text: `${name} = ${index + 1}`
+						},
+						{
+							id: "assignStringValue",
+							range,
+							text: `${name} = '${name}'`
+						}
+					]
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { enumInitializers_default as default };
+
+//# sourceMappingURL=enumInitializers.js.map

package/lib/rules/enumMemberLiterals.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Requires all enum members to be literal values.";
+    readonly id: "enumMemberLiterals";
+    readonly presets: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "requireLiteral", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=enumMemberLiterals.d.ts.map

package/lib/rules/enumMemberLiterals.js

@@ -0,0 +1,39 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/enumMemberLiterals.ts
+function isLiteralExpression(expression) {
+	switch (expression.kind) {
+		case SyntaxKind.NoSubstitutionTemplateLiteral:
+		case SyntaxKind.NumericLiteral:
+		case SyntaxKind.StringLiteral: return true;
+		case SyntaxKind.PrefixUnaryExpression:
+			if (expression.operator === SyntaxKind.PlusToken || expression.operator === SyntaxKind.MinusToken) return expression.operand.kind === SyntaxKind.NumericLiteral;
+			return false;
+		default: return false;
+	}
+}
+var enumMemberLiterals_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Requires all enum members to be literal values.",
+		id: "enumMemberLiterals",
+		presets: ["logicalStrict"]
+	},
+	messages: { requireLiteral: {
+		primary: "Prefer initializing enum members with literal values for predictability.",
+		secondary: ["Using computed values in enum initializers can lead to unexpected results.", "Enum members create their own scope, so variable references may not work as expected."],
+		suggestions: ["Use a literal string or number value instead of a computed expression."]
+	} },
+	setup(context) {
+		return { visitors: { EnumMember: (node, { sourceFile }) => {
+			if (node.initializer && !isLiteralExpression(node.initializer)) context.report({
+				message: "requireLiteral",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { enumMemberLiterals_default as default };
+
+//# sourceMappingURL=enumMemberLiterals.js.map

package/lib/rules/enumValueConsistency.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports enums that contain both string and number members.";
+    readonly id: "enumValueConsistency";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "mixedTypes", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=enumValueConsistency.d.ts.map

package/lib/rules/enumValueConsistency.js

@@ -0,0 +1,56 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/enumValueConsistency.ts
+const enumMemberKinds = {
+	Number: "number",
+	String: "string",
+	Unknown: "unknown"
+};
+function getEnumMemberKind(member, typeChecker) {
+	const type = typeChecker.getTypeAtLocation(member);
+	if (type.isNumberLiteral()) {
+		if ((type.flags & ts.TypeFlags.NumberLike) !== 0) return enumMemberKinds.Number;
+	} else if (type.isStringLiteral() && (type.flags & ts.TypeFlags.StringLike) !== 0) return enumMemberKinds.String;
+	return enumMemberKinds.Unknown;
+}
+var enumValueConsistency_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports enums that contain both string and number members.",
+		id: "enumValueConsistency",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { mixedTypes: {
+		primary: "Enum '{{ name }}' contains both number and string members, which can cause unexpected iteration behavior.",
+		secondary: [
+			"When iterating over a mixed enum with Object.keys(), Object.values(), or Object.entries(), numeric members will also include reverse mappings.",
+			"This results in a different number of items than the actual enum members.",
+			"Pure string enums don't have this issue since they don't create reverse mappings."
+		],
+		suggestions: ["Convert all members to strings for predictable iteration.", "Convert all members to numbers if reverse mappings are intentional."]
+	} },
+	setup(context) {
+		return { visitors: { EnumDeclaration: (node, { sourceFile, typeChecker }) => {
+			if (node.members.length < 2) return;
+			let hasNumber = false;
+			let hasString = false;
+			for (const member of node.members) {
+				const kind = getEnumMemberKind(member, typeChecker);
+				if (kind === enumMemberKinds.Number) hasNumber = true;
+				else if (kind === enumMemberKinds.String) hasString = true;
+				if (hasNumber && hasString) {
+					context.report({
+						data: { name: node.name.text },
+						message: "mixedTypes",
+						range: getTSNodeRange(node.name, sourceFile)
+					});
+					return;
+				}
+			}
+		} } };
+	}
+});
+//#endregion
+export { enumValueConsistency_default as default };
+
+//# sourceMappingURL=enumValueConsistency.js.map

package/lib/rules/enumValueDuplicates.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports enum members with duplicate values.";
+    readonly id: "enumValueDuplicates";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "duplicateValue", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=enumValueDuplicates.d.ts.map

package/lib/rules/enumValueDuplicates.js

@@ -0,0 +1,60 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/enumValueDuplicates.ts
+function getLiteralValue(initializer) {
+	switch (initializer.kind) {
+		case SyntaxKind.NoSubstitutionTemplateLiteral:
+		case SyntaxKind.StringLiteral: return initializer.text;
+		case SyntaxKind.NumericLiteral: return Number(initializer.text);
+		case SyntaxKind.PrefixUnaryExpression: {
+			if (initializer.operand.kind !== SyntaxKind.NumericLiteral) return;
+			const value = Number(initializer.operand.text);
+			if (initializer.operator === SyntaxKind.MinusToken) return -value;
+			if (initializer.operator === SyntaxKind.PlusToken) return value;
+			return;
+		}
+		default: return;
+	}
+}
+var enumValueDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports enum members with duplicate values.",
+		id: "enumValueDuplicates",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { duplicateValue: {
+		primary: "Enum member '{{ name }}' has a duplicate value '{{ value }}' which is already used by '{{ firstMember }}'.",
+		secondary: ["Duplicate enum values can lead to hard-to-track bugs since different members may be indistinguishable at runtime.", "When accessing enum members by value, only one of the duplicate members will be returned."],
+		suggestions: ["Use a unique value for each enum member.", "If duplication is intentional (e.g., for aliasing), consider using a type union instead."]
+	} },
+	setup(context) {
+		return { visitors: { EnumDeclaration: (node, { sourceFile }) => {
+			const seenValues = /* @__PURE__ */ new Map();
+			for (const member of node.members) {
+				if (!member.initializer) continue;
+				const value = getLiteralValue(member.initializer);
+				if (value === void 0) continue;
+				const memberName = member.name.kind === SyntaxKind.Identifier ? member.name.text : member.name.getText(sourceFile);
+				const firstMember = seenValues.get(value);
+				if (firstMember === void 0) {
+					seenValues.set(value, memberName);
+					continue;
+				}
+				context.report({
+					data: {
+						firstMember,
+						name: memberName,
+						value: String(value)
+					},
+					message: "duplicateValue",
+					range: getTSNodeRange(member, sourceFile)
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { enumValueDuplicates_default as default };
+
+//# sourceMappingURL=enumValueDuplicates.js.map

package/lib/rules/equalityOperatorNegations.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports negated expressions on the left side of equality checks.";
+    readonly id: "equalityOperatorNegations";
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "negatedEquality", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=equalityOperatorNegations.d.ts.map

package/lib/rules/equalityOperatorNegations.js

@@ -0,0 +1,60 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/equalityOperatorNegations.ts
+const equalityOperators = new Set([
+	SyntaxKind.EqualsEqualsEqualsToken,
+	SyntaxKind.EqualsEqualsToken,
+	SyntaxKind.ExclamationEqualsEqualsToken,
+	SyntaxKind.ExclamationEqualsToken
+]);
+const operatorStrings = new Map([
+	[SyntaxKind.EqualsEqualsEqualsToken, "==="],
+	[SyntaxKind.EqualsEqualsToken, "=="],
+	[SyntaxKind.ExclamationEqualsEqualsToken, "!=="],
+	[SyntaxKind.ExclamationEqualsToken, "!="]
+]);
+const negatedOperators = new Map([
+	[SyntaxKind.EqualsEqualsEqualsToken, "!=="],
+	[SyntaxKind.EqualsEqualsToken, "!="],
+	[SyntaxKind.ExclamationEqualsEqualsToken, "==="],
+	[SyntaxKind.ExclamationEqualsToken, "=="]
+]);
+var equalityOperatorNegations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports negated expressions on the left side of equality checks.",
+		id: "equalityOperatorNegations"
+	},
+	messages: { negatedEquality: {
+		primary: "Negating the left operand of '{{ operator }}' is likely a mistake.",
+		secondary: ["The logical not operator (!) applies to the left operand before the equality comparison.", "This converts the left operand to a boolean before comparing, which is rarely intended."],
+		suggestions: ["Use the opposite equality operator ('{{ suggested }}') and remove the negation."]
+	} },
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			if (!equalityOperators.has(node.operatorToken.kind)) return;
+			const left = unwrapParenthesizedNode(node.left);
+			if (left.kind !== SyntaxKind.PrefixUnaryExpression || left.operator !== SyntaxKind.ExclamationToken) return;
+			const innerExpression = unwrapParenthesizedNode(left.operand);
+			if (innerExpression.kind === SyntaxKind.PrefixUnaryExpression && innerExpression.operator === SyntaxKind.ExclamationToken) return;
+			const begin = left.getStart(sourceFile);
+			const operator = operatorStrings.get(node.operatorToken.kind);
+			const suggested = negatedOperators.get(node.operatorToken.kind);
+			context.report({
+				data: {
+					operator,
+					suggested
+				},
+				message: "negatedEquality",
+				range: {
+					begin,
+					end: begin + 1
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { equalityOperatorNegations_default as default };
+
+//# sourceMappingURL=equalityOperatorNegations.js.map

package/lib/rules/equalityOperators.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Enforces consistent use of strict equality operators (=== and !==) over loose equality operators (== and !=) for non-nullish comparisons.";
+    readonly id: "equalityOperators";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferStrictEquality", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=equalityOperators.d.ts.map

package/lib/rules/equalityOperators.js

@@ -0,0 +1,44 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isNullishLiteral, toEqualityOperator, toStrictOperator } from "./utils/equalityOperators.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/equalityOperators.ts
+var equalityOperators_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforces consistent use of strict equality operators (=== and !==) over loose equality operators (== and !=) for non-nullish comparisons.",
+		id: "equalityOperators",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferStrictEquality: {
+		primary: "Use the more precise strict equality ('{{ strictOperator }}') instead of the loose '{{ looseOperator }}'.",
+		secondary: ["The loose equality operators '=='/'!=' perform arcane type coercion and are difficult to reason about.", "Use strict equality operators '==='/'!==' instead."],
+		suggestions: ["Replace '{{ looseOperator }}' with '{{ strictOperator }}'."]
+	} },
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			const operator = toEqualityOperator(node.operatorToken.kind);
+			if (operator == null) return;
+			if (isNullishLiteral(node.left) || isNullishLiteral(node.right)) return;
+			if (operator === "==" || operator === "!=") {
+				const strictOperator = toStrictOperator(operator);
+				const operatorRange = getTSNodeRange(node.operatorToken, sourceFile);
+				context.report({
+					data: {
+						looseOperator: operator,
+						strictOperator
+					},
+					message: "preferStrictEquality",
+					range: operatorRange,
+					suggestions: [{
+						id: "useStrictOperator",
+						range: operatorRange,
+						text: strictOperator
+					}]
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { equalityOperators_default as default };
+
+//# sourceMappingURL=equalityOperators.js.map

package/lib/rules/errorMessages.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Requires a message value when creating a built-in error.";
+    readonly id: "errorMessages";
+    readonly presets: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missingMessage", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=errorMessages.d.ts.map

package/lib/rules/errorMessages.js

@@ -0,0 +1,60 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/errorMessages.ts
+const errorConstructors = [
+	"AggregateError",
+	"Error",
+	"EvalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError"
+];
+function getErrorConstructorWithoutMessage(node, typeChecker) {
+	if (node.expression.kind !== SyntaxKind.Identifier || hasValidMessageArgument(node.arguments)) return false;
+	return errorConstructors.find((errorConstructor) => isGlobalDeclarationOfName(node.expression, errorConstructor, typeChecker));
+}
+function hasValidMessageArgument(args) {
+	if (!args?.length) return false;
+	const firstArgument = args[0];
+	return !!firstArgument && !isEmptyString(firstArgument) && !isUndefinedLiteral(firstArgument);
+}
+function isEmptyString(node) {
+	if (node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral) return node.text === "";
+	return false;
+}
+function isUndefinedLiteral(node) {
+	return node.kind === SyntaxKind.Identifier && node.text === "undefined";
+}
+var errorMessages_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Requires a message value when creating a built-in error.",
+		id: "errorMessages",
+		presets: ["logicalStrict"]
+	},
+	messages: { missingMessage: {
+		primary: "`{{ errorConstructor }}`s created without a message are generally harder to debug.",
+		secondary: ["Error instances without messages are harder to debug because they don't explain what went wrong.", "A descriptive error message helps developers understand and fix issues more quickly."],
+		suggestions: ["Provide a string message describing what caused the error."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile, typeChecker }) {
+			const errorConstructor = getErrorConstructorWithoutMessage(node, typeChecker);
+			if (errorConstructor) context.report({
+				data: { errorConstructor },
+				message: "missingMessage",
+				range: getTSNodeRange(node.expression, sourceFile)
+			});
+		}
+		return { visitors: {
+			CallExpression: checkNode,
+			NewExpression: checkNode
+		} };
+	}
+});
+//#endregion
+export { errorMessages_default as default };
+
+//# sourceMappingURL=errorMessages.js.map

package/lib/rules/errorSubclassProperties.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports incorrect Error subclass definitions that don't follow best practices.";
+    readonly id: "errorSubclassProperties";
+    readonly presets: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "invalidClassName" | "missingName" | "redundantMessage" | "useConstructorName" | "wrongName", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=errorSubclassProperties.d.ts.map