@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/forDirections.js

@@ -1,132 +1,75 @@
-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/forDirections.ts
 function getConditionDirection(condition, counterName) {
-    if (!ts.isBinaryExpression(condition)) {
-        return undefined;
-    }
-    const leftName = getCounterName(condition.left);
-    const rightName = getCounterName(condition.right);
-    if (!leftName && !rightName) {
-        return condition.operatorToken.kind ===
-            ts.SyntaxKind.AmpersandAmpersandToken
-            ? (getConditionDirection(condition.left, counterName) ??
-                getConditionDirection(condition.right, counterName))
-            : undefined;
-    }
-    const isCounterLeft = leftName === counterName;
-    const isCounterRight = rightName === counterName;
-    if (!isCounterLeft && !isCounterRight) {
-        return undefined;
-    }
-    const { operatorToken } = condition;
-    if (isCounterLeft) {
-        if (operatorToken.kind === ts.SyntaxKind.LessThanToken ||
-            operatorToken.kind === ts.SyntaxKind.LessThanEqualsToken) {
-            return 1;
-        }
-        if (operatorToken.kind === ts.SyntaxKind.GreaterThanToken ||
-            operatorToken.kind === ts.SyntaxKind.GreaterThanEqualsToken) {
-            return -1;
-        }
-    }
-    else {
-        if (operatorToken.kind === ts.SyntaxKind.LessThanToken ||
-            operatorToken.kind === ts.SyntaxKind.LessThanEqualsToken) {
-            return -1;
-        }
-        if (operatorToken.kind === ts.SyntaxKind.GreaterThanToken ||
-            operatorToken.kind === ts.SyntaxKind.GreaterThanEqualsToken) {
-            return 1;
-        }
-    }
-    return undefined;
+	if (condition.kind !== SyntaxKind.BinaryExpression) return;
+	const leftName = getCounterName(condition.left);
+	const rightName = getCounterName(condition.right);
+	if (!leftName && !rightName) return condition.operatorToken.kind === SyntaxKind.AmpersandAmpersandToken ? getConditionDirection(condition.left, counterName) ?? getConditionDirection(condition.right, counterName) : void 0;
+	const isCounterLeft = leftName === counterName;
+	if (!isCounterLeft && !(rightName === counterName)) return;
+	const { operatorToken } = condition;
+	if (isCounterLeft) {
+		if (operatorToken.kind === SyntaxKind.LessThanToken || operatorToken.kind === SyntaxKind.LessThanEqualsToken) return 1;
+		if (operatorToken.kind === SyntaxKind.GreaterThanToken || operatorToken.kind === SyntaxKind.GreaterThanEqualsToken) return -1;
+	} else {
+		if (operatorToken.kind === SyntaxKind.LessThanToken || operatorToken.kind === SyntaxKind.LessThanEqualsToken) return -1;
+		if (operatorToken.kind === SyntaxKind.GreaterThanToken || operatorToken.kind === SyntaxKind.GreaterThanEqualsToken) return 1;
+	}
 }
 function getCounterName(node) {
-    return ts.isIdentifier(node) ? node.text : undefined;
+	return node.kind === SyntaxKind.Identifier ? node.text : void 0;
 }
 function getIncrementorDirection(incrementor) {
-    if (ts.isPostfixUnaryExpression(incrementor) ||
-        ts.isPrefixUnaryExpression(incrementor)) {
-        switch (incrementor.operator) {
-            case ts.SyntaxKind.MinusMinusToken:
-                return -1;
-            case ts.SyntaxKind.PlusPlusToken:
-                return 1;
-            default:
-                return undefined;
-        }
-    }
-    if (ts.isBinaryExpression(incrementor)) {
-        const { operatorToken, right } = incrementor;
-        if (operatorToken.kind === ts.SyntaxKind.PlusEqualsToken ||
-            operatorToken.kind === ts.SyntaxKind.MinusEqualsToken) {
-            if (ts.isNumericLiteral(right)) {
-                const value = Number(right.text);
-                if (operatorToken.kind === ts.SyntaxKind.PlusEqualsToken) {
-                    return value > 0 ? 1 : value < 0 ? -1 : 0;
-                }
-                return value > 0 ? -1 : value < 0 ? 1 : 0;
-            }
-            if (ts.isPrefixUnaryExpression(right) &&
-                right.operator === ts.SyntaxKind.MinusToken &&
-                ts.isNumericLiteral(right.operand)) {
-                const value = Number(right.operand.text);
-                if (operatorToken.kind === ts.SyntaxKind.PlusEqualsToken) {
-                    return value > 0 ? -1 : 1;
-                }
-                return value > 0 ? 1 : -1;
-            }
-        }
-    }
-    return undefined;
+	if (incrementor.kind === SyntaxKind.PostfixUnaryExpression || incrementor.kind === SyntaxKind.PrefixUnaryExpression) switch (incrementor.operator) {
+		case SyntaxKind.MinusMinusToken: return -1;
+		case SyntaxKind.PlusPlusToken: return 1;
+		default: return;
+	}
+	if (incrementor.kind === SyntaxKind.BinaryExpression) {
+		const { operatorToken, right } = incrementor;
+		if (operatorToken.kind === SyntaxKind.PlusEqualsToken || operatorToken.kind === SyntaxKind.MinusEqualsToken) {
+			if (right.kind === SyntaxKind.NumericLiteral) {
+				const value = Number(right.text);
+				if (operatorToken.kind === SyntaxKind.PlusEqualsToken) return value > 0 ? 1 : value < 0 ? -1 : 0;
+				return value > 0 ? -1 : value < 0 ? 1 : 0;
+			}
+			if (right.kind === SyntaxKind.PrefixUnaryExpression && right.operator === SyntaxKind.MinusToken && right.operand.kind === SyntaxKind.NumericLiteral) {
+				const value = Number(right.operand.text);
+				if (operatorToken.kind === SyntaxKind.PlusEqualsToken) return value > 0 ? -1 : 1;
+				return value > 0 ? 1 : -1;
+			}
+		}
+	}
 }
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports for loops with counter variables that move in the wrong direction.",
-        id: "forDirections",
-        preset: "stylistic",
-    },
-    messages: {
-        wrongDirection: {
-            primary: "The update moves the counter in the wrong direction for this loop condition.",
-            secondary: [
-                "A for loop with a counter that moves in the wrong direction relative to its stop condition will run infinitely or never execute.",
-                "When the counter increases but the condition expects it to decrease (or vice versa), the loop logic is incorrect.",
-            ],
-            suggestions: [
-                "Verify the loop counter update direction matches the condition.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                ForStatement: (node, { sourceFile }) => {
-                    if (!node.condition ||
-                        !node.incrementor ||
-                        !node.initializer ||
-                        !ts.isVariableDeclarationList(node.initializer)) {
-                        return;
-                    }
-                    const declaration = node.initializer.declarations.at(0);
-                    if (!declaration || !ts.isIdentifier(declaration.name)) {
-                        return;
-                    }
-                    const updateDirection = getIncrementorDirection(node.incrementor);
-                    if (!updateDirection) {
-                        return;
-                    }
-                    const conditionDirection = getConditionDirection(node.condition, declaration.name.text);
-                    if (conditionDirection && conditionDirection !== updateDirection) {
-                        context.report({
-                            message: "wrongDirection",
-                            range: getTSNodeRange(node.incrementor, sourceFile),
-                        });
-                    }
-                },
-            },
-        };
-    },
+var forDirections_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports for loops with counter variables that move in the wrong direction.",
+		id: "forDirections",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { wrongDirection: {
+		primary: "The update moves the counter in the wrong direction for this loop condition.",
+		secondary: ["A for loop with a counter that moves in the wrong direction relative to its stop condition will run infinitely or never execute.", "When the counter increases but the condition expects it to decrease (or vice versa), the loop logic is incorrect."],
+		suggestions: ["Verify the loop counter update direction matches the condition."]
+	} },
+	setup(context) {
+		return { visitors: { ForStatement: (node, { sourceFile }) => {
+			if (!node.condition || !node.incrementor || node.initializer?.kind !== SyntaxKind.VariableDeclarationList) return;
+			const declaration = node.initializer.declarations.at(0);
+			if (declaration?.name.kind !== SyntaxKind.Identifier) return;
+			const updateDirection = getIncrementorDirection(node.incrementor);
+			if (!updateDirection) return;
+			const conditionDirection = getConditionDirection(node.condition, declaration.name.text);
+			if (conditionDirection && conditionDirection !== updateDirection) context.report({
+				message: "wrongDirection",
+				range: getTSNodeRange(node.incrementor, sourceFile)
+			});
+		} } };
+	}
 });
+//#endregion
+export { forDirections_default as default };
+
 //# sourceMappingURL=forDirections.js.map

package/lib/rules/forInArrays.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports iterating over an array with a for-in loop.";
     readonly id: "forInArrays";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "forIn", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "forIn", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=forInArrays.d.ts.map

package/lib/rules/forInArrays.js

@@ -1,54 +1,46 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
+import { ruleCreator } from "./ruleCreator.js";
 import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
 import { isTypeRecursive } from "./utils/isTypeRecursive.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports iterating over an array with a for-in loop.",
-        id: "forInArrays",
-        preset: "logical",
-    },
-    messages: {
-        forIn: {
-            primary: "For-in loops over arrays have surprising behavior that often leads to bugs.",
-            secondary: [
-                "A for-in loop (`for (const i in o)`) iterates over all enumerable properties of an object, including those that are not array indices.",
-                "This can lead to unexpected behavior when used with arrays, as it may include properties that are not part of the array's numeric indices.",
-                "It also returns the index key (`i`) as a string, which is not the expected numeric type for array indices.",
-            ],
-            suggestions: [
-                "Use a construct more suited for arrays, such as a for-of loop (`for (const i of o)`).",
-            ],
-        },
-    },
-    setup(context) {
-        function hasNumberLikeLength(type, typeChecker) {
-            const lengthProperty = type.getProperty("length");
-            if (lengthProperty == null) {
-                return false;
-            }
-            return tsutils.isTypeFlagSet(typeChecker.getTypeOfSymbol(lengthProperty), ts.TypeFlags.NumberLike);
-        }
-        function isArrayLike(type, typeChecker) {
-            return isTypeRecursive(type, (t) => t.getNumberIndexType() != null && hasNumberLikeLength(t, typeChecker));
-        }
-        return {
-            visitors: {
-                ForInStatement: (node, { typeChecker }) => {
-                    const type = getConstrainedTypeAtLocation(node.expression, typeChecker);
-                    if (isArrayLike(type, typeChecker)) {
-                        context.report({
-                            message: "forIn",
-                            range: {
-                                begin: node.getStart(),
-                                end: node.statement.getStart() - 1,
-                            },
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/forInArrays.ts
+var forInArrays_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports iterating over an array with a for-in loop.",
+		id: "forInArrays",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { forIn: {
+		primary: "For-in loops over arrays have surprising behavior that often leads to bugs.",
+		secondary: [
+			"A for-in loop (`for (const i in o)`) iterates over all enumerable properties of an object, including those that are not array indices.",
+			"This can lead to unexpected behavior when used with arrays, as it may include properties that are not part of the array's numeric indices.",
+			"It also returns the index key (`i`) as a string, which is not the expected numeric type for array indices."
+		],
+		suggestions: ["Use a construct more suited for arrays, such as a for-of loop (`for (const i of o)`)."]
+	} },
+	setup(context) {
+		function hasNumberLikeLength(type, typeChecker) {
+			const lengthProperty = type.getProperty("length");
+			if (lengthProperty == null) return false;
+			return tsutils.isTypeFlagSet(typeChecker.getTypeOfSymbol(lengthProperty), ts.TypeFlags.NumberLike);
+		}
+		function isArrayLike(type, typeChecker) {
+			return isTypeRecursive(type, (t) => t.getNumberIndexType() != null && hasNumberLikeLength(t, typeChecker));
+		}
+		return { visitors: { ForInStatement: (node, { sourceFile, typeChecker }) => {
+			if (isArrayLike(getConstrainedTypeAtLocation(node.expression, typeChecker), typeChecker)) context.report({
+				message: "forIn",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.statement.getStart(sourceFile) - 1
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { forInArrays_default as default };
+
 //# sourceMappingURL=forInArrays.js.map

package/lib/rules/forInGuards.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports for-in loops without an if statement to filter inherited properties.";
+    readonly id: "forInGuards";
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missingGuard", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=forInGuards.d.ts.map

package/lib/rules/forInGuards.js

@@ -0,0 +1,44 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/forInGuards.ts
+function isIfStatementGuard(node) {
+	if (ts.isContinueStatement(node.thenStatement)) return true;
+	if (ts.isBlock(node.thenStatement) && node.thenStatement.statements.length === 1 && ts.isContinueStatement(node.thenStatement.statements[0])) return true;
+	return false;
+}
+var forInGuards_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports for-in loops without an if statement to filter inherited properties.",
+		id: "forInGuards"
+	},
+	messages: { missingGuard: {
+		primary: "For-in loop body should be wrapped in an if statement to filter inherited properties.",
+		secondary: ["Looping over objects with a for-in loop will include properties inherited through the prototype chain.", "This behavior can lead to unexpected items being iterated over."],
+		suggestions: ["Wrap the loop body with `if (Object.hasOwn(object, key))` or `if (Object.prototype.hasOwnProperty.call(object, key))`."]
+	} },
+	setup(context) {
+		return { visitors: { ForInStatement: (node, { sourceFile }) => {
+			switch (node.statement.kind) {
+				case ts.SyntaxKind.EmptyStatement:
+				case ts.SyntaxKind.IfStatement: return;
+				case ts.SyntaxKind.Block: {
+					if (!node.statement.statements.length) return;
+					const firstStatement = node.statement.statements[0];
+					if (firstStatement.kind === ts.SyntaxKind.IfStatement && (node.statement.statements.length === 1 || isIfStatementGuard(firstStatement))) return;
+				}
+			}
+			context.report({
+				message: "missingGuard",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.statement.getStart(sourceFile)
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { forInGuards_default as default };
+
+//# sourceMappingURL=forInGuards.js.map

package/lib/rules/functionApplySpreads.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer the spread operator over `.apply()` calls.";
+    readonly id: "functionApplySpreads";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferSpread", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=functionApplySpreads.d.ts.map

package/lib/rules/functionApplySpreads.js

@@ -0,0 +1,63 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, hasSameTokens, isFunction, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/functionApplySpreads.ts
+var functionApplySpreads_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer the spread operator over `.apply()` calls.",
+		id: "functionApplySpreads",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferSpread: {
+		primary: "Use the spread operator instead of `.apply()`.",
+		secondary: ["The spread operator (`...`) provides cleaner syntax for variadic function calls.", "`func.apply(thisArg, args)` can be replaced with `func.call(thisArg, ...args)` or `thisArg.func(...args)`."],
+		suggestions: ["Replace `.apply(thisArg, args)` with spread syntax like `func(...args)`."]
+	} },
+	setup(context) {
+		function isNullOrUndefined(node) {
+			return node.kind === SyntaxKind.NullKeyword || node.kind === SyntaxKind.Identifier && node.text === "undefined";
+		}
+		function isApplyCall(node) {
+			if (node.expression.kind !== SyntaxKind.PropertyAccessExpression) return false;
+			const propertyAccess = node.expression;
+			if (propertyAccess.name.kind !== SyntaxKind.Identifier) return false;
+			return propertyAccess.name.text === "apply";
+		}
+		function getVariadicArgumentsNode(node) {
+			if (!isApplyCall(node) || node.arguments.length !== 2) return;
+			const argumentsNode = node.arguments[1];
+			if (argumentsNode.kind === SyntaxKind.ArrayLiteralExpression || argumentsNode.kind === SyntaxKind.SpreadElement) return;
+			return argumentsNode;
+		}
+		function getExpectedThis(node) {
+			const applied = node.expression;
+			if (applied.kind === SyntaxKind.PropertyAccessExpression) return applied.expression;
+		}
+		function isValidThisArg(expectedThis, thisArg, sourceFile) {
+			return expectedThis ? hasSameTokens(expectedThis, thisArg, sourceFile) : isNullOrUndefined(thisArg);
+		}
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			const argumentsNode = getVariadicArgumentsNode(node);
+			if (!argumentsNode) return;
+			if (!ts.isPropertyAccessExpression(node.expression) || !isFunction(node.expression.expression, typeChecker)) return;
+			const expectedThis = getExpectedThis(node.expression);
+			const thisArg = node.arguments[0];
+			if (!isValidThisArg(expectedThis, thisArg, sourceFile)) return;
+			const argumentsText = argumentsNode.getText(sourceFile);
+			const range = getTSNodeRange(node, sourceFile);
+			const fixedText = `${node.expression.expression.getText(sourceFile)}(...${argumentsText})`;
+			context.report({
+				fix: {
+					range,
+					text: fixedText
+				},
+				message: "preferSpread",
+				range
+			});
+		} } };
+	}
+});
+//#endregion
+export { functionApplySpreads_default as default };
+
+//# sourceMappingURL=functionApplySpreads.js.map

package/lib/rules/functionAssignments.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports reassigning variables declared with function declarations.";
     readonly id: "functionAssignments";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noFunctionAssignment", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noFunctionAssignment", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=functionAssignments.d.ts.map

package/lib/rules/functionAssignments.js

@@ -1,43 +1,32 @@
-import { typescriptLanguage } from "../language.js";
-import { getModifyingReferences } from "../utils/getModifyingReferences.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports reassigning variables declared with function declarations.",
-        id: "functionAssignments",
-        preset: "untyped",
-    },
-    messages: {
-        noFunctionAssignment: {
-            primary: "Variables declared with function declarations should not be reassigned.",
-            secondary: [
-                "Reassigning a function declaration can make code harder to understand and maintain.",
-                "Function declarations are hoisted to the top of their scope, and reassigning them can lead to unexpected behavior.",
-            ],
-            suggestions: [
-                "Use a function expression or const variable instead if you need to reassign the function.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                FunctionDeclaration: (node, { sourceFile, typeChecker }) => {
-                    if (!node.name) {
-                        return;
-                    }
-                    const modifyingReferences = getModifyingReferences(node.name, sourceFile, typeChecker);
-                    for (const reference of modifyingReferences) {
-                        context.report({
-                            message: "noFunctionAssignment",
-                            range: {
-                                begin: reference.getStart(sourceFile),
-                                end: reference.getEnd(),
-                            },
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getModifyingReferences, typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/functionAssignments.ts
+var functionAssignments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports reassigning variables declared with function declarations.",
+		id: "functionAssignments",
+		presets: ["javascript"]
+	},
+	messages: { noFunctionAssignment: {
+		primary: "Variables declared with function declarations should not be reassigned.",
+		secondary: ["Reassigning a function declaration can make code harder to understand and maintain.", "Function declarations are hoisted to the top of their scope, and reassigning them can lead to unexpected behavior."],
+		suggestions: ["Use a function expression or const variable instead if you need to reassign the function."]
+	} },
+	setup(context) {
+		return { visitors: { FunctionDeclaration: (node, { sourceFile, typeChecker }) => {
+			if (!node.name) return;
+			const modifyingReferences = getModifyingReferences(node.name, sourceFile, typeChecker);
+			for (const reference of modifyingReferences) context.report({
+				message: "noFunctionAssignment",
+				range: {
+					begin: reference.getStart(sourceFile),
+					end: reference.getEnd()
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { functionAssignments_default as default };
+
 //# sourceMappingURL=functionAssignments.js.map

package/lib/rules/functionCurryingRedundancy.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using `.apply()` or `.call()` or  when the context (`this` value) provides no benefit.";
     readonly id: "functionCurryingRedundancy";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "unnecessaryCall", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryCall", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=functionCurryingRedundancy.d.ts.map