@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/returnThisTypes.js

@@ -0,0 +1,94 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { forEachReturnStatement } from "./utils/forEachReturnStatement.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/returnThisTypes.ts
+var returnThisTypes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforce that `this` is used when only `this` type is returned.",
+		id: "returnThisTypes",
+		presets: ["logical"]
+	},
+	messages: { preferThis: {
+		primary: "Prefer `this` as the return type instead of the class name for polymorphic chaining.",
+		secondary: [
+			"Annotating this method as returning the class extends to sub-classes as well.",
+			"Any sub-class will be implicitly typed as returning this parent class, rather than itself.",
+			"Using `this` preserves method chaining behavior in subclasses."
+		],
+		suggestions: ["Replace the class name with `this`."]
+	} },
+	setup(context) {
+		function checkFunction(functionNode, originalClassNode, { sourceFile, typeChecker }) {
+			if (originalClassNode.kind !== ts$1.SyntaxKind.ClassDeclaration && originalClassNode.kind !== ts$1.SyntaxKind.ClassExpression) return;
+			const className = originalClassNode.name?.text;
+			if (!className || !functionNode.type) return;
+			const nameNode = tryGetNameInType(className, functionNode.type);
+			if (!nameNode || !isFunctionReturningThis(functionNode, originalClassNode, typeChecker)) return;
+			const range = getTSNodeRange(nameNode, sourceFile);
+			context.report({
+				fix: {
+					range,
+					text: "this"
+				},
+				message: "preferThis",
+				range
+			});
+		}
+		function isFunctionReturningThis(functionNode, originalClassNode, typeChecker) {
+			if (!functionNode.body || isThisSpecifiedInParameters(functionNode)) return false;
+			const classType = typeChecker.getTypeAtLocation(originalClassNode);
+			if (functionNode.body.kind !== ts$1.SyntaxKind.Block) return classType.thisType === typeChecker.getTypeAtLocation(functionNode.body);
+			let hasReturnThis = false;
+			let hasReturnClassType = false;
+			forEachReturnStatement(functionNode.body, (statement) => {
+				if (!statement.expression) return;
+				if (statement.expression.kind === ts$1.SyntaxKind.ThisKeyword) {
+					hasReturnThis = true;
+					return;
+				}
+				const type = typeChecker.getTypeAtLocation(statement.expression);
+				if (classType === type) {
+					hasReturnClassType = true;
+					return true;
+				}
+				if (classType.thisType === type) {
+					hasReturnThis = true;
+					return;
+				}
+				if (tsutils.isUnionType(type) && type.types.includes(classType)) {
+					hasReturnClassType = true;
+					return true;
+				}
+			});
+			return !hasReturnClassType && hasReturnThis;
+		}
+		function isThisSpecifiedInParameters(functionNode) {
+			if (!functionNode.parameters.length) return false;
+			const firstArgument = functionNode.parameters[0];
+			return ts$1.isIdentifier(firstArgument.name) && firstArgument.name.text === "this";
+		}
+		function tryGetNameInType(name, typeNode) {
+			if (ts$1.isTypeReferenceNode(typeNode) && ts$1.isIdentifier(typeNode.typeName) && typeNode.typeName.text === name) return typeNode;
+			if (ts$1.isUnionTypeNode(typeNode)) for (const type of typeNode.types) {
+				const found = tryGetNameInType(name, type);
+				if (found) return found;
+			}
+		}
+		function checkMethodLike(node, services) {
+			checkFunction(node, node.parent, services);
+		}
+		return { visitors: {
+			GetAccessor: checkMethodLike,
+			MethodDeclaration: checkMethodLike,
+			PropertyDeclaration(node, services) {
+				if (node.initializer && (ts$1.isFunctionExpression(node.initializer) || ts$1.isArrowFunction(node.initializer))) checkFunction(node.initializer, node.parent, services);
+			}
+		} };
+	}
+});
+//#endregion
+export { returnThisTypes_default as default };
+
+//# sourceMappingURL=returnThisTypes.js.map

package/lib/rules/ruleCreator.d.ts

@@ -0,0 +1,3 @@
+import { RuleCreator } from "@flint.fyi/core";
+export declare const ruleCreator: RuleCreator<"javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict">;
+//# sourceMappingURL=ruleCreator.d.ts.map

package/lib/rules/ruleCreator.js

@@ -0,0 +1,17 @@
+import { RuleCreator } from "@flint.fyi/core";
+//#region src/rules/ruleCreator.ts
+const ruleCreator = new RuleCreator({
+	docs: (ruleId) => `https://flint.fyi/rules/ts/${ruleId.toLowerCase()}`,
+	pluginId: "ts",
+	presets: [
+		"javascript",
+		"logical",
+		"logicalStrict",
+		"stylistic",
+		"stylisticStrict"
+	]
+});
+//#endregion
+export { ruleCreator };
+
+//# sourceMappingURL=ruleCreator.js.map

package/lib/rules/selfAssignments.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports self-assignments which have no effect and are likely errors.";
     readonly id: "selfAssignments";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "selfAssignment", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "selfAssignment", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=selfAssignments.d.ts.map

package/lib/rules/selfAssignments.js

@@ -1,45 +1,29 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { hasSameTokens } from "../utils/hasSameTokens.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports self-assignments which have no effect and are likely errors.",
-        id: "selfAssignments",
-        preset: "logical",
-    },
-    messages: {
-        selfAssignment: {
-            primary: "This value is being assigned to itself, which does nothing.",
-            secondary: [
-                "Self-assignments have no effect and typically indicate an incomplete refactoring or copy-paste error.",
-            ],
-            suggestions: [
-                "Review the assignment and ensure you're assigning the correct value.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                BinaryExpression: (node, { sourceFile }) => {
-                    if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken &&
-                        node.operatorToken.kind !==
-                            ts.SyntaxKind.AmpersandAmpersandEqualsToken &&
-                        node.operatorToken.kind !== ts.SyntaxKind.BarBarEqualsToken &&
-                        node.operatorToken.kind !==
-                            ts.SyntaxKind.QuestionQuestionEqualsToken) {
-                        return;
-                    }
-                    if (hasSameTokens(node.left, node.right, sourceFile)) {
-                        context.report({
-                            message: "selfAssignment",
-                            range: getTSNodeRange(node, sourceFile),
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/selfAssignments.ts
+var selfAssignments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports self-assignments which have no effect and are likely errors.",
+		id: "selfAssignments",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { selfAssignment: {
+		primary: "This value is being assigned to itself, which does nothing.",
+		secondary: ["Self-assignments have no effect and typically indicate an incomplete refactoring or copy-paste error."],
+		suggestions: ["Review the assignment and ensure you're assigning the correct value."]
+	} },
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			if (node.operatorToken.kind !== SyntaxKind.EqualsToken && node.operatorToken.kind !== SyntaxKind.AmpersandAmpersandEqualsToken && node.operatorToken.kind !== SyntaxKind.BarBarEqualsToken && node.operatorToken.kind !== SyntaxKind.QuestionQuestionEqualsToken) return;
+			if (hasSameTokens(node.left, node.right, sourceFile)) context.report({
+				message: "selfAssignment",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
 });
+//#endregion
+export { selfAssignments_default as default };
+
 //# sourceMappingURL=selfAssignments.js.map

package/lib/rules/sequences.d.ts

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

package/lib/rules/sequences.js

@@ -1,35 +1,28 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using the comma operator in expressions.",
-        id: "sequences",
-        preset: "untyped",
-    },
-    messages: {
-        noSequences: {
-            primary: 'The "sequence" (comma) operator is often confusing and a sign of mistaken logic.',
-            secondary: [
-                "The comma operator can make code harder to read and may hide side effects.",
-                "Prefer separate expressions instead of using a single sequence.",
-            ],
-            suggestions: ["Split the expression into separate statements."],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                BinaryExpression: (node, { sourceFile }) => {
-                    if (node.operatorToken.kind === ts.SyntaxKind.CommaToken) {
-                        context.report({
-                            message: "noSequences",
-                            range: getTSNodeRange(node.operatorToken, sourceFile),
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/sequences.ts
+var sequences_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using the comma operator in expressions.",
+		id: "sequences",
+		presets: ["javascript"]
+	},
+	messages: { noSequences: {
+		primary: "The \"sequence\" (comma) operator is often confusing and a sign of mistaken logic.",
+		secondary: ["The comma operator can make code harder to read and may hide side effects.", "Prefer separate expressions instead of using a single sequence."],
+		suggestions: ["Split the expression into separate statements."]
+	} },
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			if (node.operatorToken.kind === SyntaxKind.CommaToken) context.report({
+				message: "noSequences",
+				range: getTSNodeRange(node.operatorToken, sourceFile)
+			});
+		} } };
+	}
 });
+//#endregion
+export { sequences_default as default };
+
 //# sourceMappingURL=sequences.js.map

package/lib/rules/setSizeLengthChecks.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer `Set.size` over spreading into an array and accessing `.length`.";
+    readonly id: "setSizeLengthChecks";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferSize", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=setSizeLengthChecks.d.ts.map

package/lib/rules/setSizeLengthChecks.js

@@ -0,0 +1,48 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/setSizeLengthChecks.ts
+function isNewSetExpression(expression, typeChecker) {
+	return ts$1.isNewExpression(expression) && ts$1.isIdentifier(expression.expression) && expression.expression.text === "Set" && isGlobalDeclarationOfName(expression.expression, "Set", typeChecker);
+}
+function isSetExpression(expression, typeChecker) {
+	const unwrapped = unwrapParentheses(expression);
+	if (isNewSetExpression(unwrapped, typeChecker)) return true;
+	if (!ts$1.isIdentifier(unwrapped)) return false;
+	const symbol = typeChecker.getSymbolAtLocation(unwrapped);
+	if (!symbol?.valueDeclaration || !ts$1.isVariableDeclaration(symbol.valueDeclaration)) return false;
+	const declaration = symbol.valueDeclaration;
+	if (declaration.parent.kind !== ts$1.SyntaxKind.VariableDeclarationList || !(declaration.parent.flags & ts$1.NodeFlags.Const) || !declaration.initializer) return false;
+	return isNewSetExpression(unwrapParentheses(declaration.initializer), typeChecker);
+}
+function unwrapParentheses(expression) {
+	while (ts$1.isParenthesizedExpression(expression)) expression = expression.expression;
+	return expression;
+}
+var setSizeLengthChecks_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer `Set.size` over spreading into an array and accessing `.length`.",
+		id: "setSizeLengthChecks",
+		presets: ["logical"]
+	},
+	messages: { preferSize: {
+		primary: "Prefer `Set.size` instead of spreading into an array and accessing `.length`.",
+		secondary: ["`Set` has a built-in `.size` property that directly returns the number of elements.", "It is faster and more idiomatic to use that instead of creating an intermediate array."],
+		suggestions: ["Use `.size` directly on the `Set` instead."]
+	} },
+	setup(context) {
+		return { visitors: { PropertyAccessExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.questionDotToken || node.name.text !== "length" || !ts$1.isArrayLiteralExpression(node.expression) || node.expression.elements.length !== 1) return;
+			const element = node.expression.elements[0];
+			if (!ts$1.isSpreadElement(element) || !isSetExpression(element.expression, typeChecker)) return;
+			context.report({
+				message: "preferSize",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { setSizeLengthChecks_default as default };
+
+//# sourceMappingURL=setSizeLengthChecks.js.map

package/lib/rules/setterReturns.d.ts

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

package/lib/rules/setterReturns.js

@@ -0,0 +1,41 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/setterReturns.ts
+var setterReturns_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports return statements with values inside setters.",
+		id: "setterReturns",
+		presets: ["javascript"]
+	},
+	messages: { noSetterReturn: {
+		primary: "Values returned by setters are always ignored.",
+		secondary: ["Setters are expected to have side effects only and not produce a return value.", "Any returned value from a setter is ignored."],
+		suggestions: ["Remove the return value.", "Use a regular method instead."]
+	} },
+	setup(context) {
+		return { visitors: { SetAccessor: (node, { sourceFile }) => {
+			if (!node.body) return;
+			function checkForReturnStatements(node) {
+				if (ts.isReturnStatement(node)) {
+					if (node.expression) context.report({
+						message: "noSetterReturn",
+						range: {
+							begin: node.getStart(sourceFile),
+							end: node.getEnd()
+						}
+					});
+					return;
+				}
+				if (tsutils.isFunctionScopeBoundary(node)) return;
+				ts.forEachChild(node, checkForReturnStatements);
+			}
+			ts.forEachChild(node.body, checkForReturnStatements);
+		} } };
+	}
+});
+//#endregion
+export { setterReturns_default as default };
+
+//# sourceMappingURL=setterReturns.js.map

package/lib/rules/shadowedRestrictedNames.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports variable declarations that shadow JavaScript's restricted names.";
     readonly id: "shadowedRestrictedNames";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "shadowedRestrictedName", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "shadowedRestrictedName", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=shadowedRestrictedNames.d.ts.map

package/lib/rules/shadowedRestrictedNames.js

@@ -1,96 +1,68 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/shadowedRestrictedNames.ts
 const restrictedNames = new Set([
-    "arguments",
-    "eval",
-    "Infinity",
-    "NaN",
-    "undefined",
+	"arguments",
+	"eval",
+	"Infinity",
+	"NaN",
+	"undefined"
 ]);
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports variable declarations that shadow JavaScript's restricted names.",
-        id: "shadowedRestrictedNames",
-        preset: "untyped",
-    },
-    messages: {
-        shadowedRestrictedName: {
-            primary: "This variable misleadingly shadows the global `{{ name }}`.",
-            secondary: [
-                "JavaScript has certain built-in global identifiers that are considered restricted because shadowing them can lead to confusing or erroneous code.",
-                "When you declare a variable with a restricted name, it shadows the global identifier and can cause unexpected behavior.",
-            ],
-            suggestions: [
-                "Use a different variable name that doesn't shadow a restricted name.",
-            ],
-        },
-    },
-    setup(context) {
-        function checkIdentifier(node, sourceFile) {
-            if (restrictedNames.has(node.text)) {
-                context.report({
-                    data: {
-                        name: node.text,
-                    },
-                    message: "shadowedRestrictedName",
-                    range: getTSNodeRange(node, sourceFile),
-                });
-            }
-        }
-        function checkBindingName(name, sourceFile) {
-            if (ts.isIdentifier(name)) {
-                checkIdentifier(name, sourceFile);
-            }
-            else if (ts.isObjectBindingPattern(name) ||
-                ts.isArrayBindingPattern(name)) {
-                for (const element of name.elements) {
-                    if (ts.isBindingElement(element)) {
-                        checkBindingName(element.name, sourceFile);
-                    }
-                }
-            }
-        }
-        function checkParameters(parameters, sourceFile) {
-            for (const parameter of parameters) {
-                checkBindingName(parameter.name, sourceFile);
-            }
-        }
-        return {
-            visitors: {
-                ArrowFunction: (node, { sourceFile }) => {
-                    checkParameters(node.parameters, sourceFile);
-                },
-                ClassDeclaration: (node, { sourceFile }) => {
-                    if (node.name) {
-                        checkIdentifier(node.name, sourceFile);
-                    }
-                },
-                ClassExpression: (node, { sourceFile }) => {
-                    if (node.name) {
-                        checkIdentifier(node.name, sourceFile);
-                    }
-                },
-                FunctionDeclaration: (node, { sourceFile }) => {
-                    if (node.name) {
-                        checkIdentifier(node.name, sourceFile);
-                    }
-                    checkParameters(node.parameters, sourceFile);
-                },
-                FunctionExpression: (node, { sourceFile }) => {
-                    if (node.name) {
-                        checkIdentifier(node.name, sourceFile);
-                    }
-                    checkParameters(node.parameters, sourceFile);
-                },
-                MethodDeclaration: (node, { sourceFile }) => {
-                    checkParameters(node.parameters, sourceFile);
-                },
-                VariableDeclaration: (node, { sourceFile }) => {
-                    checkBindingName(node.name, sourceFile);
-                },
-            },
-        };
-    },
+var shadowedRestrictedNames_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports variable declarations that shadow JavaScript's restricted names.",
+		id: "shadowedRestrictedNames",
+		presets: ["javascript"]
+	},
+	messages: { shadowedRestrictedName: {
+		primary: "This variable misleadingly shadows the global `{{ name }}`.",
+		secondary: ["JavaScript has certain built-in global identifiers that are considered restricted because shadowing them can lead to confusing or erroneous code.", "When you declare a variable with a restricted name, it shadows the global identifier and can cause unexpected behavior."],
+		suggestions: ["Use a different variable name that doesn't shadow a restricted name."]
+	} },
+	setup(context) {
+		function checkIdentifier(node, sourceFile) {
+			if (restrictedNames.has(node.text)) context.report({
+				data: { name: node.text },
+				message: "shadowedRestrictedName",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		}
+		function checkBindingName(name, sourceFile) {
+			if (name.kind === SyntaxKind.Identifier) checkIdentifier(name, sourceFile);
+			else for (const element of name.elements) if (element.kind === SyntaxKind.BindingElement) checkBindingName(element.name, sourceFile);
+		}
+		function checkParameters(parameters, sourceFile) {
+			for (const parameter of parameters) checkBindingName(parameter.name, sourceFile);
+		}
+		return { visitors: {
+			ArrowFunction: (node, { sourceFile }) => {
+				checkParameters(node.parameters, sourceFile);
+			},
+			ClassDeclaration: (node, { sourceFile }) => {
+				if (node.name) checkIdentifier(node.name, sourceFile);
+			},
+			ClassExpression: (node, { sourceFile }) => {
+				if (node.name) checkIdentifier(node.name, sourceFile);
+			},
+			FunctionDeclaration: (node, { sourceFile }) => {
+				if (node.name) checkIdentifier(node.name, sourceFile);
+				checkParameters(node.parameters, sourceFile);
+			},
+			FunctionExpression: (node, { sourceFile }) => {
+				if (node.name) checkIdentifier(node.name, sourceFile);
+				checkParameters(node.parameters, sourceFile);
+			},
+			MethodDeclaration: (node, { sourceFile }) => {
+				checkParameters(node.parameters, sourceFile);
+			},
+			VariableDeclaration: (node, { sourceFile }) => {
+				checkBindingName(node.name, sourceFile);
+			}
+		} };
+	}
 });
+//#endregion
+export { shadowedRestrictedNames_default as default };
+
 //# sourceMappingURL=shadowedRestrictedNames.js.map

package/lib/rules/singleVariableDeclarations.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Enforces one variable per declaration statement.";
+    readonly id: "singleVariableDeclarations";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "singleVariable", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=singleVariableDeclarations.d.ts.map

package/lib/rules/singleVariableDeclarations.js

@@ -0,0 +1,36 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/singleVariableDeclarations.ts
+var singleVariableDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforces one variable per declaration statement.",
+		id: "singleVariableDeclarations",
+		presets: ["logical"]
+	},
+	messages: { singleVariable: {
+		primary: "Split this into separate variable declarations.",
+		secondary: ["Declaring multiple variables in one statement can reduce readability."],
+		suggestions: ["Use separate declaration statements for each variable."]
+	} },
+	setup(context) {
+		return { visitors: {
+			ForStatement: (node, { sourceFile }) => {
+				if (node.initializer && ts.isVariableDeclarationList(node.initializer) && node.initializer.declarations.length > 1) context.report({
+					message: "singleVariable",
+					range: getTSNodeRange(node.initializer, sourceFile)
+				});
+			},
+			VariableStatement: (node, { sourceFile }) => {
+				if (node.declarationList.declarations.length > 1) context.report({
+					message: "singleVariable",
+					range: getTSNodeRange(node.declarationList, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { singleVariableDeclarations_default as default };
+
+//# sourceMappingURL=singleVariableDeclarations.js.map

package/lib/rules/sizeComparisonOperators.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Enforce consistent style for `.length` and `.size` checks.";
+    readonly id: "sizeComparisonOperators";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "coercionNonZeroCheck" | "coercionZeroCheck" | "explicitNonZeroCheck" | "explicitZeroCheck", {
+    readonly style: z.ZodDefault<z.ZodEnum<{
+        coercion: "coercion";
+        explicit: "explicit";
+    }>>;
+}>;
+export default _default;
+//# sourceMappingURL=sizeComparisonOperators.d.ts.map