@flint.fyi/ts 0.20.0 → 0.21.0

package/lib/rules/negativeIndexLengthMethods.js

@@ -4,7 +4,7 @@ import { isTypeRecursive } from "./utils/isTypeRecursive.js";
 import { getTSNodeRange, hasSameTokens, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
 import * as ts$1 from "typescript";
 //#region src/rules/negativeIndexLengthMethods.ts
-const typedArrayNames = new Set([
+const typedArrayNames = /* @__PURE__ */ new Set([
 	"BigInt64Array",
 	"BigUint64Array",
 	"Float32Array",
@@ -17,10 +17,10 @@ const typedArrayNames = new Set([
 	"Uint16Array",
 	"Uint32Array"
 ]);
-const methodConfigurations = new Map([
+const methodConfigurations = /* @__PURE__ */ new Map([
 	["at", {
 		argumentIndexes: [0],
-		supportedTypes: new Set([
+		supportedTypes: /* @__PURE__ */ new Set([
 			"Array",
 			"String",
 			...typedArrayNames
@@ -28,7 +28,7 @@ const methodConfigurations = new Map([
 	}],
 	["slice", {
 		argumentIndexes: [0, 1],
-		supportedTypes: new Set([
+		supportedTypes: /* @__PURE__ */ new Set([
 			"Array",
 			"String",
 			...typedArrayNames
@@ -36,7 +36,7 @@ const methodConfigurations = new Map([
 	}],
 	["splice", {
 		argumentIndexes: [0],
-		supportedTypes: new Set(["Array"])
+		supportedTypes: /* @__PURE__ */ new Set(["Array"])
 	}],
 	["subarray", {
 		argumentIndexes: [0, 1],
@@ -44,11 +44,11 @@ const methodConfigurations = new Map([
 	}],
 	["toSpliced", {
 		argumentIndexes: [0],
-		supportedTypes: new Set(["Array"])
+		supportedTypes: /* @__PURE__ */ new Set(["Array"])
 	}],
 	["with", {
 		argumentIndexes: [0],
-		supportedTypes: new Set(["Array", ...typedArrayNames])
+		supportedTypes: /* @__PURE__ */ new Set(["Array", ...typedArrayNames])
 	}]
 ]);
 function getNegativeIndexLengthNode(node, target, sourceFile) {
@@ -176,5 +176,3 @@ var negativeIndexLengthMethods_default = ruleCreator.createRule(typescriptLangua
 });
 //#endregion
 export { negativeIndexLengthMethods_default as default };
-
-//# sourceMappingURL=negativeIndexLengthMethods.js.map

package/lib/rules/negativeZeroComparisons.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "unexpectedNegativeZeroComparison", undefined>;
 export default _default;
-//# sourceMappingURL=negativeZeroComparisons.d.ts.map

package/lib/rules/negativeZeroComparisons.js

@@ -44,5 +44,3 @@ var negativeZeroComparisons_default = ruleCreator.createRule(typescriptLanguage,
 });
 //#endregion
 export { negativeZeroComparisons_default as default };
-
-//# sourceMappingURL=negativeZeroComparisons.js.map

package/lib/rules/nestedStandaloneIfs.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "lonelyIfInElse" | "lonelyIfInIf", undefined>;
 export default _default;
-//# sourceMappingURL=nestedStandaloneIfs.d.ts.map

package/lib/rules/nestedStandaloneIfs.js

@@ -9,7 +9,7 @@ function hasCommentsInRange(sourceFile, start, end) {
 function isIfWithoutElse(node) {
 	return ts.isIfStatement(node) && node.elseStatement === void 0;
 }
-const lowerPrecedenceThanLogicalAnd = new Set([
+const lowerPrecedenceThanLogicalAnd = /* @__PURE__ */ new Set([
 	SyntaxKind.BinaryExpression,
 	SyntaxKind.ConditionalExpression,
 	SyntaxKind.YieldExpression
@@ -101,5 +101,3 @@ var nestedStandaloneIfs_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { nestedStandaloneIfs_default as default };
-
-//# sourceMappingURL=nestedStandaloneIfs.js.map

package/lib/rules/newDefinitions.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "classMethodNamedNew" | "interfaceConstructSignature" | "interfaceMethodNamedConstructor", undefined>;
 export default _default;
-//# sourceMappingURL=newDefinitions.d.ts.map

package/lib/rules/newDefinitions.js

@@ -80,5 +80,3 @@ var newDefinitions_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { newDefinitions_default as default };
-
-//# sourceMappingURL=newDefinitions.js.map

package/lib/rules/newExpressions.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "noStandaloneNew", undefined>;
 export default _default;
-//# sourceMappingURL=newExpressions.d.ts.map

package/lib/rules/newExpressions.js

@@ -34,5 +34,3 @@ var newExpressions_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { newExpressions_default as default };
-
-//# sourceMappingURL=newExpressions.js.map

package/lib/rules/newNativeNonConstructors.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "noNewNonConstructor", undefined>;
 export default _default;
-//# sourceMappingURL=newNativeNonConstructors.d.ts.map

package/lib/rules/newNativeNonConstructors.js

@@ -14,10 +14,10 @@ var newNativeNonConstructors_default = ruleCreator.createRule(typescriptLanguage
 		suggestions: ["Remove the `new` keyword and call the function directly."]
 	} },
 	setup(context) {
-		return { visitors: { NewExpression: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { NewExpression: (node, { program, sourceFile, typeChecker }) => {
 			if (node.expression.kind !== SyntaxKind.Identifier) return;
 			const name = node.expression.text;
-			if (!["BigInt", "Symbol"].includes(name) || !isGlobalDeclaration(node.expression, typeChecker)) return;
+			if (!["BigInt", "Symbol"].includes(name) || !isGlobalDeclaration(node.expression, typeChecker, program)) return;
 			context.report({
 				data: { name },
 				fix: {
@@ -35,5 +35,3 @@ var newNativeNonConstructors_default = ruleCreator.createRule(typescriptLanguage
 });
 //#endregion
 export { newNativeNonConstructors_default as default };
-
-//# sourceMappingURL=newNativeNonConstructors.js.map

package/lib/rules/nonNullAssertedNullishCoalesces.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "unnecessaryNonNullAssertion", undefined>;
 export default _default;
-//# sourceMappingURL=nonNullAssertedNullishCoalesces.d.ts.map

package/lib/rules/nonNullAssertedNullishCoalesces.js

@@ -59,5 +59,3 @@ var nonNullAssertedNullishCoalesces_default = ruleCreator.createRule(typescriptL
 });
 //#endregion
 export { nonNullAssertedNullishCoalesces_default as default };
-
-//# sourceMappingURL=nonNullAssertedNullishCoalesces.js.map

package/lib/rules/nonNullAssertedOptionalChains.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "nonNullOptionalChain", undefined>;
 export default _default;
-//# sourceMappingURL=nonNullAssertedOptionalChains.d.ts.map

package/lib/rules/nonNullAssertedOptionalChains.js

@@ -65,5 +65,3 @@ var nonNullAssertedOptionalChains_default = ruleCreator.createRule(typescriptLan
 });
 //#endregion
 export { nonNullAssertedOptionalChains_default as default };
-
-//# sourceMappingURL=nonNullAssertedOptionalChains.js.map

package/lib/rules/nonNullAssertionPlacement.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "confusingAssign" | "confusingEqual" | "confusingOperator", undefined>;
 export default _default;
-//# sourceMappingURL=nonNullAssertionPlacement.d.ts.map

package/lib/rules/nonNullAssertionPlacement.js

@@ -5,7 +5,7 @@ import { SyntaxKind } from "typescript";
 function endsWithNonNullAssertion(node, sourceFile) {
 	return node.getLastToken(sourceFile)?.kind === SyntaxKind.ExclamationToken;
 }
-const confusingOperatorTexts = new Map([
+const confusingOperatorTexts = /* @__PURE__ */ new Map([
 	[SyntaxKind.EqualsEqualsEqualsToken, "==="],
 	[SyntaxKind.EqualsEqualsToken, "=="],
 	[SyntaxKind.EqualsToken, "="],
@@ -90,5 +90,3 @@ var nonNullAssertionPlacement_default = ruleCreator.createRule(typescriptLanguag
 });
 //#endregion
 export { nonNullAssertionPlacement_default as default };
-
-//# sourceMappingURL=nonNullAssertionPlacement.js.map

package/lib/rules/nonNullableTypeAssertions.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "preferNonNullAssertion", undefined>;
 export default _default;
-//# sourceMappingURL=nonNullableTypeAssertions.d.ts.map

package/lib/rules/nonNullableTypeAssertions.js

@@ -74,5 +74,3 @@ var nonNullableTypeAssertions_default = ruleCreator.createRule(typescriptLanguag
 });
 //#endregion
 export { nonNullableTypeAssertions_default as default };
-
-//# sourceMappingURL=nonNullableTypeAssertions.js.map

package/lib/rules/nonOctalDecimalEscapes.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "unexpectedEscape", undefined>;
 export default _default;
-//# sourceMappingURL=nonOctalDecimalEscapes.d.ts.map

package/lib/rules/nonOctalDecimalEscapes.js

@@ -44,5 +44,3 @@ var nonOctalDecimalEscapes_default = ruleCreator.createRule(typescriptLanguage,
 });
 //#endregion
 export { nonOctalDecimalEscapes_default as default };
-
-//# sourceMappingURL=nonOctalDecimalEscapes.js.map

package/lib/rules/nullishCheckStyle.d.ts

@@ -18,4 +18,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     }>>;
 }>;
 export default _default;
-//# sourceMappingURL=nullishCheckStyle.d.ts.map

package/lib/rules/nullishCheckStyle.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { isNullishLiteral, isUndefinedIdentifier, toEqualityOperator, toLooseOperator, toStrictOperator } from "./utils/equalityOperators.js";
 import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 import { isNullKeyword } from "ts-api-utils";
-import { z } from "zod/v4";
+import { z as z$1 } from "zod/v4";
 //#region src/rules/nullishCheckStyle.ts
 var nullishCheckStyle_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -32,12 +32,12 @@ var nullishCheckStyle_default = ruleCreator.createRule(typescriptLanguage, {
 		}
 	},
 	options: {
-		looseNullishComparisonStyle: z.enum([
+		looseNullishComparisonStyle: z$1.enum([
 			"prefer-null",
 			"prefer-undefined",
 			"ignore"
 		]).default("prefer-null"),
-		nullishComparisonStrictness: z.enum([
+		nullishComparisonStrictness: z$1.enum([
 			"double-equals",
 			"triple-equals",
 			"ignore"
@@ -140,5 +140,3 @@ var nullishCheckStyle_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { nullishCheckStyle_default as default };
-
-//# sourceMappingURL=nullishCheckStyle.js.map

package/lib/rules/nullishCoalescingOperators.d.ts

@@ -19,4 +19,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     ignoreTernaryTests: z.ZodDefault<z.ZodBoolean>;
 }>;
 export default _default;
-//# sourceMappingURL=nullishCoalescingOperators.d.ts.map

package/lib/rules/nullishCoalescingOperators.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
 import ts from "typescript";
 import * as tsutils from "ts-api-utils";
-import { z } from "zod/v4";
+import { z as z$1 } from "zod/v4";
 //#region src/rules/nullishCoalescingOperators.ts
 function analyzeConditionalForNullish(node, sourceFile) {
 	const { condition, whenFalse, whenTrue } = node;
@@ -228,21 +228,21 @@ var nullishCoalescingOperators_default = ruleCreator.createRule(typescriptLangua
 		}
 	},
 	options: {
-		ignoreConditionalTests: z.boolean().default(true).describe("Whether to skip cases where the expression is in a conditional context."),
-		ignoreIfStatements: z.boolean().default(false).describe("Whether to skip if statement patterns with nullish checks."),
-		ignoreMixedLogicalExpressions: z.boolean().default(false).describe("Whether to skip expressions that mix && and || operators."),
-		ignorePrimitives: z.union([z.boolean(), z.record(z.enum([
+		ignoreConditionalTests: z$1.boolean().default(true).describe("Whether to skip cases where the expression is in a conditional context."),
+		ignoreIfStatements: z$1.boolean().default(false).describe("Whether to skip if statement patterns with nullish checks."),
+		ignoreMixedLogicalExpressions: z$1.boolean().default(false).describe("Whether to skip expressions that mix && and || operators."),
+		ignorePrimitives: z$1.union([z$1.boolean(), z$1.record(z$1.enum([
 			"bigint",
 			"boolean",
 			"number",
 			"string"
-		]), z.boolean())]).default({
+		]), z$1.boolean())]).default({
 			bigint: false,
 			boolean: false,
 			number: false,
 			string: false
 		}).describe("Whether to skip primitive types. Can be a boolean or an object with per-type configuration."),
-		ignoreTernaryTests: z.boolean().default(false).describe("Whether to skip ternary expressions.")
+		ignoreTernaryTests: z$1.boolean().default(false).describe("Whether to skip ternary expressions.")
 	},
 	setup(context) {
 		function getOptionalChainInsertPosition(node, test, sourceFile) {
@@ -319,5 +319,3 @@ var nullishCoalescingOperators_default = ruleCreator.createRule(typescriptLangua
 });
 //#endregion
 export { nullishCoalescingOperators_default as default };
-
-//# sourceMappingURL=nullishCoalescingOperators.js.map

package/lib/rules/numberMethodRanges.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "outOfRange", undefined>;
 export default _default;
-//# sourceMappingURL=numberMethodRanges.d.ts.map

package/lib/rules/numberMethodRanges.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 import { SyntaxKind } from "typescript";
 //#region src/rules/numberMethodRanges.ts
-const methodSpecs = new Map([
+const methodSpecs = /* @__PURE__ */ new Map([
 	["toExponential", {
 		max: 100,
 		min: 0,
@@ -70,5 +70,3 @@ var numberMethodRanges_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { numberMethodRanges_default as default };
-
-//# sourceMappingURL=numberMethodRanges.js.map

package/lib/rules/numberStaticMethods.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "preferNumberMethod", undefined>;
 export default _default;
-//# sourceMappingURL=numberStaticMethods.d.ts.map

package/lib/rules/numberStaticMethods.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, isGlobalVariable, typescriptLanguage } from "@flint.fyi/typescript-language";
 import ts from "typescript";
 //#region src/rules/numberStaticMethods.ts
-const globalReplacements = new Map([["isFinite", "Number.isFinite"], ["isNaN", "Number.isNaN"]]);
+const globalReplacements = /* @__PURE__ */ new Map([["isFinite", "Number.isFinite"], ["isNaN", "Number.isNaN"]]);
 function isDeclarationName(node) {
 	return ts.isFunctionDeclaration(node.parent) && node.parent.name === node || ts.isVariableDeclaration(node.parent) && node.parent.name === node || ts.isParameter(node.parent) && node.parent.name === node;
 }
@@ -27,9 +27,9 @@ var numberStaticMethods_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Replace `{{ name }}` with `{{ replacement }}`."]
 	} },
 	setup(context) {
-		return { visitors: { Identifier: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { Identifier: (node, { program, sourceFile, typeChecker }) => {
 			const replacement = globalReplacements.get(node.text);
-			if (!replacement || isPropertyAccessOfNode(node) || isPropertyShorthandOfNode(node) || isDeclarationName(node) || !isGlobalVariable(node, typeChecker) || isLeftHandSide(node)) return;
+			if (!replacement || isPropertyAccessOfNode(node) || isPropertyShorthandOfNode(node) || isDeclarationName(node) || !isGlobalVariable(node, typeChecker, program) || isLeftHandSide(node)) return;
 			const range = getTSNodeRange(node, sourceFile);
 			context.report({
 				data: {
@@ -49,5 +49,3 @@ var numberStaticMethods_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { numberStaticMethods_default as default };
-
-//# sourceMappingURL=numberStaticMethods.js.map

package/lib/rules/numericErasingOperations.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "erasingOperation", undefined>;
 export default _default;
-//# sourceMappingURL=numericErasingOperations.d.ts.map

package/lib/rules/numericErasingOperations.js

@@ -1,9 +1,9 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { getStaticNumberValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 import ts from "typescript";
 //#region src/rules/numericErasingOperations.ts
 function isZeroLiteral(node) {
-	return node.kind === ts.SyntaxKind.NumericLiteral && node.text === "0";
+	return Object.is(getStaticNumberValue(node), 0);
 }
 var numericErasingOperations_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -42,5 +42,3 @@ var numericErasingOperations_default = ruleCreator.createRule(typescriptLanguage
 });
 //#endregion
 export { numericErasingOperations_default as default };
-
-//# sourceMappingURL=numericErasingOperations.js.map

package/lib/rules/numericLiteralParsing.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "preferLiteral", undefined>;
 export default _default;
-//# sourceMappingURL=numericLiteralParsing.d.ts.map

package/lib/rules/numericLiteralParsing.js

@@ -1,5 +1,5 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { getStaticNumberValue, getStaticStringValue, getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
 import { SyntaxKind } from "typescript";
 import { nullThrows } from "@flint.fyi/utils";
 //#region src/rules/numericLiteralParsing.ts
@@ -13,19 +13,6 @@ function convertToLiteral(value, radix) {
 		default: return value;
 	}
 }
-function getRadixValue(node) {
-	if (node.kind !== SyntaxKind.NumericLiteral) return;
-	const value = Number(node.text);
-	if (![
-		2,
-		8,
-		16
-	].includes(value)) return;
-	return value;
-}
-function getStringValue(node) {
-	return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral ? node.text : void 0;
-}
 var numericLiteralParsing_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
 		description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.",
@@ -40,10 +27,14 @@ var numericLiteralParsing_default = ruleCreator.createRule(typescriptLanguage, {
 	setup(context) {
 		function checkParseIntCall(node, sourceFile) {
 			if (node.arguments.length !== 2) return;
-			const stringValue = getStringValue(nullThrows(node.arguments[0], "First argument is expected to be present by prior length check"));
+			const stringValue = getStaticStringValue(nullThrows(node.arguments[0], "First argument is expected to be present by prior length check"));
 			if (!stringValue) return;
-			const radixValue = getRadixValue(nullThrows(node.arguments[1], "Second argument is expected to be present by prior length check"));
-			if (!radixValue) return;
+			const radixValue = getStaticNumberValue(nullThrows(node.arguments[1], "Second argument is expected to be present by prior length check"));
+			if (radixValue === void 0 || ![
+				2,
+				8,
+				16
+			].includes(radixValue)) return;
 			context.report({
 				data: {
 					literal: convertToLiteral(stringValue, radixValue),
@@ -53,14 +44,12 @@ var numericLiteralParsing_default = ruleCreator.createRule(typescriptLanguage, {
 				range: getTSNodeRange(node, sourceFile)
 			});
 		}
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
 			if (node.expression.kind === SyntaxKind.Identifier) {
-				if (node.expression.text === "parseInt" && isGlobalDeclaration(node.expression, typeChecker)) checkParseIntCall(node, sourceFile);
-			} else if (node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.expression.kind === SyntaxKind.Identifier && node.expression.expression.text === "Number" && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === "parseInt" && isGlobalDeclaration(node.expression.expression, typeChecker)) checkParseIntCall(node, sourceFile);
+				if (node.expression.text === "parseInt" && isGlobalDeclaration(node.expression, typeChecker, program)) checkParseIntCall(node, sourceFile);
+			} else if (node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.expression.kind === SyntaxKind.Identifier && node.expression.expression.text === "Number" && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === "parseInt" && isGlobalDeclaration(node.expression.expression, typeChecker, program)) checkParseIntCall(node, sourceFile);
 		} } };
 	}
 });
 //#endregion
 export { numericLiteralParsing_default as default };
-
-//# sourceMappingURL=numericLiteralParsing.js.map

package/lib/rules/numericPrecision.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "lossOfPrecision", undefined>;
 export default _default;
-//# sourceMappingURL=numericPrecision.d.ts.map

package/lib/rules/numericPrecision.js

@@ -98,5 +98,3 @@ var numericPrecision_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { numericPrecision_default as default };
-
-//# sourceMappingURL=numericPrecision.js.map

package/lib/rules/numericSeparatorGroups.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "invalidGrouping", undefined>;
 export default _default;
-//# sourceMappingURL=numericSeparatorGroups.d.ts.map

package/lib/rules/numericSeparatorGroups.js

@@ -97,5 +97,3 @@ var numericSeparatorGroups_default = ruleCreator.createRule(typescriptLanguage,
 });
 //#endregion
 export { numericSeparatorGroups_default as default };
-
-//# sourceMappingURL=numericSeparatorGroups.js.map

package/lib/rules/objectAssignSpreads.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "preferObjectLiteral" | "preferObjectSpread", undefined>;
 export default _default;
-//# sourceMappingURL=objectAssignSpreads.d.ts.map

package/lib/rules/objectAssignSpreads.js

@@ -11,8 +11,8 @@ function hasArgumentsWithAccessors(node) {
 function hasArraySpread(node) {
 	return node.arguments.some((argument) => argument.kind === SyntaxKind.SpreadElement);
 }
-function isObjectAssignCall(node, typeChecker) {
-	return node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === "assign" && node.expression.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker);
+function isObjectAssignCall(node, typeChecker, program) {
+	return node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === "assign" && node.expression.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker, program);
 }
 var objectAssignSpreads_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -37,8 +37,8 @@ var objectAssignSpreads_default = ruleCreator.createRule(typescriptLanguage, {
 		}
 	},
 	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!isObjectAssignCall(node, typeChecker) || node.arguments.length < 1) return;
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
+			if (!isObjectAssignCall(node, typeChecker, program) || node.arguments.length < 1) return;
 			if (node.arguments[0].kind !== SyntaxKind.ObjectLiteralExpression || hasArraySpread(node) || hasArgumentsWithAccessors(node)) return;
 			context.report({
 				message: node.arguments.length === 1 ? "preferObjectLiteral" : "preferObjectSpread",
@@ -49,5 +49,3 @@ var objectAssignSpreads_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { objectAssignSpreads_default as default };
-
-//# sourceMappingURL=objectAssignSpreads.js.map

package/lib/rules/objectCalls.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "preferObjectLiteral", undefined>;
 export default _default;
-//# sourceMappingURL=objectCalls.d.ts.map

package/lib/rules/objectCalls.js

@@ -18,8 +18,8 @@ var objectCalls_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Replace `Object()` or `new Object()` with `{}` to create an empty object.", "Use `Object.create(null)` when you need an object without a prototype."]
 	} },
 	setup(context) {
-		function checkNode(node, { sourceFile, typeChecker }) {
-			if (node.expression.kind !== SyntaxKind.Identifier || !isGlobalDeclarationOfName(node.expression, "Object", typeChecker)) return;
+		function checkNode(node, { program, sourceFile, typeChecker }) {
+			if (node.expression.kind !== SyntaxKind.Identifier || !isGlobalDeclarationOfName(node.expression, "Object", typeChecker, program)) return;
 			const reportNode = node.kind === SyntaxKind.NewExpression ? node.getChildAt(0, sourceFile) : node.expression;
 			context.report({
 				message: "preferObjectLiteral",
@@ -34,5 +34,3 @@ var objectCalls_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { objectCalls_default as default };
-
-//# sourceMappingURL=objectCalls.js.map

package/lib/rules/objectEntriesMethods.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "preferFromEntries", undefined>;
 export default _default;
-//# sourceMappingURL=objectEntriesMethods.d.ts.map

package/lib/rules/objectEntriesMethods.js

@@ -7,20 +7,20 @@ import { SyntaxKind } from "typescript";
 function isArrowFunctionWithParams(node) {
 	return node.kind === SyntaxKind.ArrowFunction && !!node.parameters.length;
 }
-function isEmptyObject(node, typeChecker) {
+function isEmptyObject(node, typeChecker, program) {
 	const unwrapped = skipParentheses(node);
-	return isEmptyObjectLiteral(unwrapped) || isObjectCreateNull(unwrapped, typeChecker);
+	return isEmptyObjectLiteral(unwrapped) || isObjectCreateNull(unwrapped, typeChecker, program);
 }
 function isEmptyObjectLiteral(node) {
 	return node.kind === SyntaxKind.ObjectLiteralExpression && !node.properties.length;
 }
-function isObjectAssignPattern(callback, typeChecker) {
+function isObjectAssignPattern(callback, typeChecker, program) {
 	if (callback.parameters.length < 1) return false;
 	const firstParameter = callback.parameters[0];
 	if (firstParameter.name.kind !== SyntaxKind.Identifier) return false;
 	const accumulatorName = firstParameter.name.text;
 	const body = skipParentheses(callback.body);
-	if (!isObjectMethodCall(body, "assign", typeChecker) || body.arguments.length !== 2 || !isGlobalDeclarationOfName(body.expression.expression, "Object", typeChecker)) return false;
+	if (!isObjectMethodCall(body, "assign", typeChecker, program) || body.arguments.length !== 2 || !isGlobalDeclarationOfName(body.expression.expression, "Object", typeChecker, program)) return false;
 	const firstArg = body.arguments[0];
 	if (firstArg.kind !== SyntaxKind.Identifier || firstArg.text !== accumulatorName) return false;
 	const secondArg = body.arguments[1];
@@ -28,17 +28,17 @@ function isObjectAssignPattern(callback, typeChecker) {
 	const property = secondArg.properties[0];
 	return property.kind === SyntaxKind.PropertyAssignment && property.name.kind === SyntaxKind.ComputedPropertyName;
 }
-function isObjectCreateNull(node, typeChecker) {
-	if (!isObjectMethodCall(node, "create", typeChecker) || !isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker) || node.arguments.length !== 1) return false;
+function isObjectCreateNull(node, typeChecker, program) {
+	if (!isObjectMethodCall(node, "create", typeChecker, program) || !isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker, program) || node.arguments.length !== 1) return false;
 	return node.arguments[0].kind === SyntaxKind.NullKeyword;
 }
-function isObjectMethodCall(node, text, typeChecker) {
-	return node.kind === SyntaxKind.CallExpression && node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === text && isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker);
+function isObjectMethodCall(node, text, typeChecker, program) {
+	return node.kind === SyntaxKind.CallExpression && node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === text && isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker, program);
 }
-function isReduceCallWithEmptyObject(node, typeChecker) {
+function isReduceCallWithEmptyObject(node, typeChecker, program) {
 	if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.name.kind !== SyntaxKind.Identifier || node.expression.name.text !== "reduce" || node.questionDotToken !== void 0 || node.arguments.length !== 2) return false;
 	const initialValue = node.arguments[1];
-	return isEmptyObject(initialValue, typeChecker) && isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker);
+	return isEmptyObject(initialValue, typeChecker, program) && isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker);
 }
 function isSpreadAccumulatorPattern(callback) {
 	if (callback.parameters.length < 1) return false;
@@ -64,11 +64,11 @@ var objectEntriesMethods_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Convert the array to key-value pairs with map() and use Object.fromEntries()."]
 	} },
 	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!isReduceCallWithEmptyObject(node, typeChecker)) return;
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
+			if (!isReduceCallWithEmptyObject(node, typeChecker, program)) return;
 			const callback = node.arguments[0];
 			if (!isArrowFunctionWithParams(callback) || callback.body.kind === SyntaxKind.Block) return;
-			if (!isObjectAssignPattern(callback, typeChecker) && !isSpreadAccumulatorPattern(callback)) return;
+			if (!isObjectAssignPattern(callback, typeChecker, program) && !isSpreadAccumulatorPattern(callback)) return;
 			context.report({
 				message: "preferFromEntries",
 				range: getTSNodeRange(node, sourceFile)
@@ -78,5 +78,3 @@ var objectEntriesMethods_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { objectEntriesMethods_default as default };
-
-//# sourceMappingURL=objectEntriesMethods.js.map

package/lib/rules/objectHasOwns.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "preferHasOwn", undefined>;
 export default _default;
-//# sourceMappingURL=objectHasOwns.d.ts.map