@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/unnecessaryMathClamps.js

@@ -1,106 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticNumberValue, getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/unnecessaryMathClamps.ts
-function getMathMethodInfo(node, typeChecker, program) {
-	const unwrapped = unwrapParenthesizedNode(node);
-	if (unwrapped.kind !== SyntaxKind.CallExpression || unwrapped.questionDotToken || unwrapped.arguments.length < 1 || unwrapped.arguments.some((arg) => arg.kind === SyntaxKind.SpreadElement)) return;
-	if (isMathMethod(unwrapped.expression, "min", typeChecker, program)) return {
-		arguments: Array.from(unwrapped.arguments),
-		method: "min",
-		node: unwrapped
-	};
-	if (isMathMethod(unwrapped.expression, "max", typeChecker, program)) return {
-		arguments: Array.from(unwrapped.arguments),
-		method: "max",
-		node: unwrapped
-	};
-}
-function isMathMethod(node, methodName, typeChecker, program) {
-	return node.kind === SyntaxKind.PropertyAccessExpression && !node.questionDotToken && node.name.kind === SyntaxKind.Identifier && node.name.text === methodName && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Math", typeChecker, program);
-}
-var unnecessaryMathClamps_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary Math.min and Math.max calls with constant arguments or incorrect clamping patterns.",
-		id: "unnecessaryMathClamps",
-		presets: ["logical"]
-	},
-	messages: {
-		constantArguments: {
-			primary: "This `Math.{{ method }}` with all constant arguments will always return `{{ result }}`.",
-			secondary: ["When all arguments to `Math.{{ method }}` are constants, the result is always the same value.", "You can replace this call with the constant `{{ result }}` directly."],
-			suggestions: ["Replace with the constant value `{{ result }}`."]
-		},
-		incorrectClampOrder: {
-			primary: "Incorrect clamping pattern: `Math.{{ outerMethod }}({{ min }}, Math.{{ innerMethod }}({{ max }}, x))` should be `Math.min({{ max }}, Math.max({{ min }}, x))`.",
-			secondary: ["To clamp a value between a minimum and maximum, use `Math.min(max, Math.max(min, value))`.", "The current pattern will not correctly constrain the value to the intended range."],
-			suggestions: ["Use the correct clamping pattern: `Math.min(max, Math.max(min, value))`."]
-		}
-	},
-	setup(context) {
-		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
-			const outerInfo = getMathMethodInfo(node, typeChecker, program);
-			if (!outerInfo) return;
-			const numericValues = [];
-			let allNumeric = true;
-			for (const arg of outerInfo.arguments) {
-				const value = getStaticNumberValue(arg);
-				if (value === void 0) {
-					allNumeric = false;
-					break;
-				}
-				numericValues.push(value);
-			}
-			if (allNumeric) {
-				const result = outerInfo.method === "min" ? Math.min(...numericValues) : Math.max(...numericValues);
-				context.report({
-					data: {
-						method: outerInfo.method,
-						result: String(result)
-					},
-					message: "constantArguments",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (outerInfo.arguments.length === 2) {
-				const firstArgument = outerInfo.arguments[0];
-				const secondArgument = outerInfo.arguments[1];
-				const innerInfo = getMathMethodInfo(secondArgument, typeChecker, program);
-				if (innerInfo && innerInfo.method !== outerInfo.method && innerInfo.arguments.length === 2) {
-					const innerFirstArg = innerInfo.arguments[0];
-					const innerSecondArg = innerInfo.arguments[1];
-					if (!innerFirstArg || !innerSecondArg) return;
-					const outerConstant = getStaticNumberValue(firstArgument);
-					const innerConstantFirst = getStaticNumberValue(innerFirstArg);
-					const innerConstantSecond = getStaticNumberValue(innerSecondArg);
-					if (outerInfo.method === "max" && innerInfo.method === "min" && outerConstant !== void 0 && innerConstantFirst !== void 0 && outerConstant < innerConstantFirst) {
-						context.report({
-							data: {
-								innerMethod: innerInfo.method,
-								max: String(innerConstantFirst),
-								min: String(outerConstant),
-								outerMethod: outerInfo.method
-							},
-							message: "incorrectClampOrder",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						return;
-					}
-					if (outerInfo.method === "max" && innerInfo.method === "min" && outerConstant !== void 0 && innerConstantSecond !== void 0 && outerConstant < innerConstantSecond) context.report({
-						data: {
-							innerMethod: innerInfo.method,
-							max: String(innerConstantSecond),
-							min: String(outerConstant),
-							outerMethod: outerInfo.method
-						},
-						message: "incorrectClampOrder",
-						range: getTSNodeRange(node, sourceFile)
-					});
-				}
-			}
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryMathClamps_default as default };

package/lib/rules/unnecessaryNumericFractions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports numeric literals with unnecessary zero fractions or dangling dots.";
-    readonly id: "unnecessaryNumericFractions";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "danglingDot" | "zeroFraction", undefined>;
-export default _default;

package/lib/rules/unnecessaryNumericFractions.js

@@ -1,48 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/unnecessaryNumericFractions.ts
-var unnecessaryNumericFractions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports numeric literals with unnecessary zero fractions or dangling dots.",
-		id: "unnecessaryNumericFractions",
-		presets: ["stylistic"]
-	},
-	messages: {
-		danglingDot: {
-			primary: "Prefer `{{ fixed }}` over `{{ raw }}` to avoid a dangling dot.",
-			secondary: ["Numeric literals with dangling dots (e.g., `1.`) are harder to read and can be confusing.", "The dot doesn't add any precision information to the number."],
-			suggestions: ["Remove the dangling dot from the numeric literal."]
-		},
-		zeroFraction: {
-			primary: "Prefer `{{ fixed }}` over `{{ raw }}` to avoid an unnecessary zero fraction.",
-			secondary: ["Numeric literals with zero fractions (e.g., `1.0`) are unnecessarily verbose.", "The zero fraction doesn't add any precision information to the number."],
-			suggestions: ["Remove the zero fraction from the numeric literal."]
-		}
-	},
-	setup(context) {
-		return { visitors: { NumericLiteral: (node, { sourceFile }) => {
-			const raw = node.getText(sourceFile);
-			const match = /^([\d_]*)(\.[\d_]*)(?:e[+-]?\d+)?$/.exec(raw);
-			if (!match) return;
-			const before = match[1];
-			const dotAndFractions = match[2];
-			const after = raw.slice(before.length + dotAndFractions.length);
-			const fixed = (before + dotAndFractions.replace(/[0_]+$/, "").replace(/\.$/, "") || "0") + after;
-			if (fixed === raw) return;
-			context.report({
-				data: {
-					fixed,
-					raw
-				},
-				fix: {
-					range: getTSNodeRange(node, sourceFile),
-					text: fixed
-				},
-				message: dotAndFractions === "." ? "danglingDot" : "zeroFraction",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryNumericFractions_default as default };

package/lib/rules/unnecessaryRenames.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Renames that don't change the identifier name are unnecessary.";
-    readonly id: "unnecessaryRenames";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryRename", undefined>;
-export default _default;

package/lib/rules/unnecessaryRenames.js

@@ -1,90 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { countCommentsInRange } from "./utils/countCommentsInRange.js";
-import { getTSNodeRange, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryRenames.ts
-function getModuleNameText(node) {
-	if (!node) return;
-	if (ts.isIdentifier(node) || ts.isStringLiteral(node)) return node.text;
-}
-function getPropertyAssignmentTargetInfo(node) {
-	if (node.initializer.kind === ts.SyntaxKind.BinaryExpression && node.initializer.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-		const targetParent = node.initializer.left;
-		return {
-			parenthesizesTarget: targetParent.kind === ts.SyntaxKind.ParenthesizedExpression,
-			replacementNode: node.initializer,
-			targetNode: unwrapParenthesizedNode(targetParent)
-		};
-	}
-	const targetNode = unwrapParenthesizedNode(node.initializer);
-	return {
-		parenthesizesTarget: false,
-		replacementNode: targetNode,
-		targetNode
-	};
-}
-var unnecessaryRenames_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Renames that don't change the identifier name are unnecessary.",
-		id: "unnecessaryRenames",
-		presets: ["stylistic"]
-	},
-	messages: { unnecessaryRename: {
-		primary: "Renaming to the same identifier name is unnecessary.",
-		secondary: ["Using the same name for both the source and target is redundant.", "Remove the rename and use the shorthand syntax instead."],
-		suggestions: ["Remove the unnecessary rename."]
-	} },
-	setup(context) {
-		function reportUnnecessaryRename(node, parenthesizesTarget, replacementRange, sourceFile) {
-			const range = getTSNodeRange(node, sourceFile);
-			const shouldSkipFix = parenthesizesTarget || countCommentsInRange(sourceFile.text, range) > countCommentsInRange(sourceFile.text, replacementRange);
-			context.report({
-				fix: shouldSkipFix ? void 0 : {
-					range,
-					text: sourceFile.text.slice(replacementRange.begin, replacementRange.end)
-				},
-				message: "unnecessaryRename",
-				range
-			});
-		}
-		function checkExportOrImportSpecifier(original, rangeNode, sourceFile) {
-			if (getModuleNameText(original.propertyName) !== getModuleNameText(original.name)) return;
-			reportUnnecessaryRename(original, false, getTSNodeRange(rangeNode, sourceFile), sourceFile);
-		}
-		function checkObjectLiteralDestructuring(node, sourceFile) {
-			for (const property of node.properties) {
-				if (!ts.isPropertyAssignment(property) || property.name.kind === ts.SyntaxKind.ComputedPropertyName) continue;
-				const { parenthesizesTarget, replacementNode, targetNode } = getPropertyAssignmentTargetInfo(property);
-				if (ts.isObjectLiteralExpression(targetNode)) {
-					checkObjectLiteralDestructuring(targetNode, sourceFile);
-					continue;
-				}
-				if (targetNode.kind !== ts.SyntaxKind.Identifier) continue;
-				if (getModuleNameText(property.name) !== targetNode.text) continue;
-				reportUnnecessaryRename(property, parenthesizesTarget, getTSNodeRange(replacementNode, sourceFile), sourceFile);
-			}
-		}
-		return { visitors: {
-			BinaryExpression: (node, { sourceFile }) => {
-				if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return;
-				const left = unwrapParenthesizedNode(node.left);
-				if (left.kind !== ts.SyntaxKind.ObjectLiteralExpression) return;
-				checkObjectLiteralDestructuring(left, sourceFile);
-			},
-			BindingElement: (node, { sourceFile }) => {
-				if (node.propertyName?.kind !== ts.SyntaxKind.ComputedPropertyName && node.name.kind === ts.SyntaxKind.Identifier && getModuleNameText(node.propertyName) === getModuleNameText(node.name)) reportUnnecessaryRename(node, false, {
-					begin: node.name.getStart(sourceFile),
-					end: node.getEnd()
-				}, sourceFile);
-			},
-			ExportSpecifier: (node, { sourceFile }) => {
-				if (node.propertyName) checkExportOrImportSpecifier(node, node.propertyName, sourceFile);
-			},
-			ImportSpecifier: (node, { sourceFile }) => {
-				checkExportOrImportSpecifier(node, node.name, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { unnecessaryRenames_default as default };

package/lib/rules/unnecessaryTernaries.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports ternary expressions that can be simplified to boolean expressions or logical operators";
-    readonly id: "unnecessaryTernaries";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryBooleanTernary" | "unnecessaryLogicalTernary", undefined>;
-export default _default;

package/lib/rules/unnecessaryTernaries.js

@@ -1,86 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryTernaries.ts
-function getNodeText(node, sourceFile) {
-	return sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
-}
-var unnecessaryTernaries_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports ternary expressions that can be simplified to boolean expressions or logical operators",
-		id: "unnecessaryTernaries",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		unnecessaryBooleanTernary: {
-			primary: "This ternary expression can be simplified to a boolean expression.",
-			secondary: ["Using a ternary to return true or false based on a condition is redundant.", "The condition itself already evaluates to a boolean value."],
-			suggestions: ["Simplify to a boolean expression."]
-		},
-		unnecessaryLogicalTernary: {
-			primary: "This ternary expression can be simplified to a logical operator.",
-			secondary: ["Using a ternary where the consequent matches the condition is redundant.", "A logical OR operator (`||`) expresses the same logic more clearly."],
-			suggestions: ["Replace with logical OR operator."]
-		}
-	},
-	setup(context) {
-		return { visitors: { ConditionalExpression(node, { sourceFile }) {
-			const { condition, whenFalse, whenTrue } = node;
-			if (whenTrue.kind === ts.SyntaxKind.TrueKeyword && whenFalse.kind === ts.SyntaxKind.FalseKeyword) {
-				const range = getTSNodeRange(node, sourceFile);
-				context.report({
-					fix: {
-						range,
-						text: getNodeText(condition, sourceFile)
-					},
-					message: "unnecessaryBooleanTernary",
-					range
-				});
-				return;
-			}
-			if (whenTrue.kind === ts.SyntaxKind.FalseKeyword && whenFalse.kind === ts.SyntaxKind.TrueKeyword) {
-				const range = getTSNodeRange(node, sourceFile);
-				const conditionText = getNodeText(condition, sourceFile);
-				const negatedCondition = ts.isBinaryExpression(condition) || ts.isConditionalExpression(condition) ? `!(${conditionText})` : `!${conditionText}`;
-				context.report({
-					fix: {
-						range,
-						text: negatedCondition
-					},
-					message: "unnecessaryBooleanTernary",
-					range
-				});
-				return;
-			}
-			if (hasSameTokens(condition, whenTrue, sourceFile)) {
-				const range = getTSNodeRange(node, sourceFile);
-				const conditionText = getNodeText(condition, sourceFile);
-				const alternateText = getNodeText(whenFalse, sourceFile);
-				context.report({
-					fix: {
-						range,
-						text: `${conditionText} || ${alternateText}`
-					},
-					message: "unnecessaryLogicalTernary",
-					range
-				});
-				return;
-			}
-			if (ts.isPrefixUnaryExpression(condition) && condition.operator === ts.SyntaxKind.ExclamationToken && hasSameTokens(condition.operand, whenFalse, sourceFile)) {
-				const range = getTSNodeRange(node, sourceFile);
-				const operandText = getNodeText(condition.operand, sourceFile);
-				const alternateText = getNodeText(whenTrue, sourceFile);
-				context.report({
-					fix: {
-						range,
-						text: `${operandText} || ${alternateText}`
-					},
-					message: "unnecessaryLogicalTernary",
-					range
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryTernaries_default as default };

package/lib/rules/unnecessaryUseStricts.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary \"use strict\" directives in ES modules and classes.";
-    readonly id: "unnecessaryUseStricts";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryUseStrict", undefined>;
-export default _default;

package/lib/rules/unnecessaryUseStricts.js

@@ -1,38 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryUseStricts.ts
-var unnecessaryUseStricts_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary \"use strict\" directives in ES modules and classes.",
-		id: "unnecessaryUseStricts",
-		presets: ["logical"]
-	},
-	messages: { unnecessaryUseStrict: {
-		primary: "This `\"use strict\"` directive is redundant and can be safely removed.",
-		secondary: ["ECMAScript modules and class bodies are automatically in strict mode.", "The `\"use strict\"` directive has no effect and is redundant."],
-		suggestions: ["Remove the `\"use strict\"` directive."]
-	} },
-	setup(context) {
-		return { visitors: { SourceFile(node, { sourceFile }) {
-			if (!ts.isExternalModule(sourceFile)) return;
-			const firstStatement = node.statements[0];
-			if (!ts.isExpressionStatement(firstStatement) || !ts.isStringLiteral(firstStatement.expression) || firstStatement.expression.text !== "use strict") return;
-			const secondStatement = node.statements[1];
-			const fixEnd = secondStatement ? secondStatement.getStart(sourceFile) : firstStatement.getEnd();
-			context.report({
-				fix: {
-					range: {
-						begin: firstStatement.getStart(sourceFile),
-						end: fixEnd
-					},
-					text: ""
-				},
-				message: "unnecessaryUseStrict",
-				range: getTSNodeRange(firstStatement, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryUseStricts_default as default };

package/lib/rules/unsafeNegations.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports negating the left operand of `in` or `instanceof` relations.";
-    readonly id: "unsafeNegations";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNegatingRelation", undefined>;
-export default _default;

package/lib/rules/unsafeNegations.js

@@ -1,36 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/unsafeNegations.ts
-const operatorStrings = /* @__PURE__ */ new Map([[SyntaxKind.InKeyword, "in"], [SyntaxKind.InstanceOfKeyword, "instanceof"]]);
-var unsafeNegations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports negating the left operand of `in` or `instanceof` relations.",
-		id: "unsafeNegations",
-		presets: ["javascript"]
-	},
-	messages: { preferNegatingRelation: {
-		primary: "This negation applies before the `{{ operator }}` operator.",
-		secondary: ["The logical not operator (!) has higher precedence than `in` and `instanceof`.", "Write `!(left in right)` or `!(left instanceof Right)` to negate the relation as intended."],
-		suggestions: ["Wrap the relation in parentheses and negate it."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			const operator = operatorStrings.get(node.operatorToken.kind);
-			if (!operator) return;
-			const left = unwrapParenthesizedNode(node.left);
-			if (left.kind !== SyntaxKind.PrefixUnaryExpression || left.operator !== SyntaxKind.ExclamationToken) return;
-			const begin = left.getStart(sourceFile);
-			context.report({
-				data: { operator },
-				message: "preferNegatingRelation",
-				range: {
-					begin,
-					end: begin + 1
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { unsafeNegations_default as default };

package/lib/rules/utils/collectAccessorPairs.d.ts

@@ -1,11 +0,0 @@
-import ts from "typescript";
-import type { AST } from "@flint.fyi/typescript-language";
-export interface AccessorInfo {
-    index: number;
-    node: AST.GetAccessorDeclaration | AST.SetAccessorDeclaration;
-}
-export interface AccessorPair {
-    getter?: AccessorInfo;
-    setter?: AccessorInfo;
-}
-export declare function collectAccessorPairs(members: ts.NodeArray<AST.AnyNode>, sourceFile: AST.SourceFile): Map<string, AccessorPair>;

package/lib/rules/utils/collectAccessorPairs.js

@@ -1,27 +0,0 @@
-import ts from "typescript";
-//#region src/rules/utils/collectAccessorPairs.ts
-function collectAccessorPairs(members, sourceFile) {
-	const pairs = /* @__PURE__ */ new Map();
-	members.forEach((member, index) => {
-		if (member.kind !== ts.SyntaxKind.GetAccessor && member.kind !== ts.SyntaxKind.SetAccessor) return;
-		const name = getPropertyName(member, sourceFile);
-		let pair = pairs.get(name);
-		if (!pair) {
-			pair = {};
-			pairs.set(name, pair);
-		}
-		const entry = {
-			index,
-			node: member
-		};
-		if (member.kind === ts.SyntaxKind.GetAccessor) pair.getter = entry;
-		else pair.setter = entry;
-	});
-	return pairs;
-}
-function getPropertyName(accessor, sourceFile) {
-	if (ts.isIdentifier(accessor.name) || ts.isStringLiteral(accessor.name) || ts.isNumericLiteral(accessor.name)) return accessor.name.text;
-	return accessor.name.getText(sourceFile);
-}
-//#endregion
-export { collectAccessorPairs };

package/lib/rules/utils/countCommentsInRange.d.ts

@@ -1,2 +0,0 @@
-import type { CharacterReportRange } from "@flint.fyi/core";
-export declare function countCommentsInRange(sourceText: string, { begin, end }: CharacterReportRange): number;

package/lib/rules/utils/countCommentsInRange.js

@@ -1,10 +0,0 @@
-import ts from "typescript";
-//#region src/rules/utils/countCommentsInRange.ts
-function countCommentsInRange(sourceText, { begin, end }) {
-	const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.Standard, sourceText.slice(begin, end));
-	let count = 0;
-	for (let token = scanner.scan(); token !== ts.SyntaxKind.EndOfFileToken; token = scanner.scan()) if (token === ts.SyntaxKind.SingleLineCommentTrivia || token === ts.SyntaxKind.MultiLineCommentTrivia) count++;
-	return count;
-}
-//#endregion
-export { countCommentsInRange };

package/lib/rules/utils/discriminateAnyType.d.ts

@@ -1,15 +0,0 @@
-import ts from "typescript";
-import type { Checker } from "@flint.fyi/typescript-language";
-export declare const AnyType: {
-    readonly Any: "any";
-    readonly AnyArray: "any[]";
-    readonly Error: "error";
-    readonly PromiseAny: "Promise<any>";
-    readonly Safe: "safe";
-};
-export type AnyType = (typeof AnyType)[keyof typeof AnyType];
-/**
- * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise&lt;any>`,
- * `AnyType.Error` if the type is an intrinsic error type, otherwise it returns `AnyType.Safe`.
- */
-export declare function discriminateAnyType(type: ts.Type, checker: Checker, tsNode: ts.Node): AnyType;

package/lib/rules/utils/discriminateAnyType.js

@@ -1,36 +0,0 @@
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/utils/discriminateAnyType.ts
-const AnyType = {
-	Any: "any",
-	AnyArray: "any[]",
-	Error: "error",
-	PromiseAny: "Promise<any>",
-	Safe: "safe"
-};
-/**
-* @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise&lt;any>`,
-* `AnyType.Error` if the type is an intrinsic error type, otherwise it returns `AnyType.Safe`.
-*/
-function discriminateAnyType(type, checker, tsNode) {
-	return discriminateAnyTypeWorker(type, checker, tsNode, /* @__PURE__ */ new Set());
-}
-function discriminateAnyTypeWorker(type, checker, tsNode, visited) {
-	if (visited.has(type)) return AnyType.Safe;
-	visited.add(type);
-	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) return tsutils.isIntrinsicErrorType(type) ? AnyType.Error : AnyType.Any;
-	if (checker.isArrayType(type)) {
-		const elementType = nullThrows(checker.getTypeArguments(type)[0], "Array type should have at least one type argument");
-		if (tsutils.isTypeFlagSet(elementType, ts.TypeFlags.Any) && !tsutils.isIntrinsicErrorType(elementType)) return AnyType.AnyArray;
-	}
-	for (const part of tsutils.typeConstituents(type)) if (tsutils.isThenableType(checker, tsNode, part)) {
-		const awaitedType = checker.getAwaitedType(part);
-		if (awaitedType) {
-			if (discriminateAnyTypeWorker(awaitedType, checker, tsNode, visited) === AnyType.Any && !tsutils.isIntrinsicErrorType(awaitedType)) return AnyType.PromiseAny;
-		}
-	}
-	return AnyType.Safe;
-}
-//#endregion
-export { AnyType, discriminateAnyType };

package/lib/rules/utils/equalityOperators.d.ts

@@ -1,8 +0,0 @@
-import { SyntaxKind } from "typescript";
-import { type AST } from "@flint.fyi/typescript-language";
-export type EqualityOperator = "!=" | "!==" | "==" | "===";
-export declare function isNullishLiteral(node: AST.Expression): boolean;
-export declare function isUndefinedIdentifier(node: AST.Expression): boolean;
-export declare function toEqualityOperator(kind: SyntaxKind): EqualityOperator | undefined;
-export declare function toLooseOperator(operator: EqualityOperator): EqualityOperator;
-export declare function toStrictOperator(operator: EqualityOperator): EqualityOperator;

package/lib/rules/utils/equalityOperators.js

@@ -1,34 +0,0 @@
-import { unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/utils/equalityOperators.ts
-function isNullishLiteral(node) {
-	return isNullLiteral(node) || isUndefinedIdentifier(node);
-}
-function isUndefinedIdentifier(node) {
-	const unwrapped = unwrapParenthesizedNode(node);
-	return unwrapped.kind === SyntaxKind.Identifier && unwrapped.text === "undefined";
-}
-function toEqualityOperator(kind) {
-	switch (kind) {
-		case SyntaxKind.EqualsEqualsEqualsToken: return "===";
-		case SyntaxKind.EqualsEqualsToken: return "==";
-		case SyntaxKind.ExclamationEqualsEqualsToken: return "!==";
-		case SyntaxKind.ExclamationEqualsToken: return "!=";
-		default: return;
-	}
-}
-function toLooseOperator(operator) {
-	if (operator === "===") return "==";
-	if (operator === "!==") return "!=";
-	return operator;
-}
-function toStrictOperator(operator) {
-	if (operator === "==") return "===";
-	if (operator === "!=") return "!==";
-	return operator;
-}
-function isNullLiteral(node) {
-	return unwrapParenthesizedNode(node).kind === SyntaxKind.NullKeyword;
-}
-//#endregion
-export { isNullishLiteral, isUndefinedIdentifier, toEqualityOperator, toLooseOperator, toStrictOperator };

package/lib/rules/utils/forEachReturnStatement.d.ts

@@ -1,2 +0,0 @@
-import * as ts from "typescript";
-export declare function forEachReturnStatement<T>(body: ts.Block, visitor: (statement: ts.ReturnStatement) => T): T | undefined;

package/lib/rules/utils/forEachReturnStatement.js

@@ -1,27 +0,0 @@
-import * as ts$1 from "typescript";
-//#region src/rules/utils/forEachReturnStatement.ts
-function forEachReturnStatement(body, visitor) {
-	return traverse(body);
-	function traverse(node) {
-		switch (node.kind) {
-			case ts$1.SyntaxKind.Block:
-			case ts$1.SyntaxKind.CaseBlock:
-			case ts$1.SyntaxKind.CaseClause:
-			case ts$1.SyntaxKind.CatchClause:
-			case ts$1.SyntaxKind.DefaultClause:
-			case ts$1.SyntaxKind.DoStatement:
-			case ts$1.SyntaxKind.ForInStatement:
-			case ts$1.SyntaxKind.ForOfStatement:
-			case ts$1.SyntaxKind.ForStatement:
-			case ts$1.SyntaxKind.IfStatement:
-			case ts$1.SyntaxKind.LabeledStatement:
-			case ts$1.SyntaxKind.SwitchStatement:
-			case ts$1.SyntaxKind.TryStatement:
-			case ts$1.SyntaxKind.WhileStatement:
-			case ts$1.SyntaxKind.WithStatement: return ts$1.forEachChild(node, traverse);
-			case ts$1.SyntaxKind.ReturnStatement: return visitor(node);
-		}
-	}
-}
-//#endregion
-export { forEachReturnStatement };

package/lib/rules/utils/formatReportedType.d.ts

@@ -1,3 +0,0 @@
-import type ts from "typescript";
-import type { Checker } from "@flint.fyi/typescript-language";
-export declare function formatReportedType(type: ts.Type, typeChecker: Checker): string;