@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/objectHasOwns.js

@@ -0,0 +1,50 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/objectHasOwns.ts
+var objectHasOwns_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.",
+		id: "objectHasOwns",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferHasOwn: {
+		primary: "`hasOwnProperty()` calls can fail on objects without `Object.prototype` or with overridden properties.",
+		secondary: [
+			"`Object.hasOwn()` is a more modern and safer way to check if an object has its own property.",
+			"It avoids issues with objects that don't inherit from `Object.prototype` or have a modified hasOwnProperty property.",
+			"`Object.hasOwn()` was introduced in ES2022 and is more concise than the hasOwnProperty alternatives."
+		],
+		suggestions: ["Use the safer, more modern `Object.hasOwn(obj, key)`.", "Use an alternative key check such as the `in` operator."]
+	} },
+	setup(context) {
+		function isObjectPrototypeHasOwnProperty(node, typeChecker) {
+			return node.kind === SyntaxKind.PropertyAccessExpression && node.name.kind === SyntaxKind.Identifier && node.name.text === "prototype" && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Object", typeChecker);
+		}
+		function isObjectLiteralHasOwnProperty(node) {
+			return node.kind === SyntaxKind.ObjectLiteralExpression && !node.properties.length;
+		}
+		function isHasOwnProperty(node, typeChecker) {
+			if (node.kind !== SyntaxKind.PropertyAccessExpression || node.name.kind !== SyntaxKind.Identifier || node.name.text !== "hasOwnProperty") return false;
+			return isObjectPrototypeHasOwnProperty(node.expression, typeChecker) || isObjectLiteralHasOwnProperty(node.expression);
+		}
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.name.kind !== SyntaxKind.Identifier) return;
+			if (node.expression.name.text === "call" && node.arguments.length >= 2 && isHasOwnProperty(node.expression.expression, typeChecker)) {
+				context.report({
+					message: "preferHasOwn",
+					range: getTSNodeRange(node, sourceFile)
+				});
+				return;
+			}
+			if (node.expression.name.text === "hasOwnProperty" && node.arguments.length >= 1 && !isHasOwnProperty(node.expression, typeChecker)) context.report({
+				message: "preferHasOwn",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { objectHasOwns_default as default };
+
+//# sourceMappingURL=objectHasOwns.js.map

package/lib/rules/objectKeyDuplicates.d.ts

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

package/lib/rules/objectKeyDuplicates.js

@@ -0,0 +1,63 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/objectKeyDuplicates.ts
+var objectKeyDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary duplicate keys that override previous values.",
+		id: "objectKeyDuplicates",
+		presets: ["javascript"]
+	},
+	messages: { duplicateKey: {
+		primary: "This key is made redundant by an identical key later in the object.",
+		secondary: [
+			"Duplicate object keys are legal in JavaScript, but they can lead to unexpected behavior.",
+			"When duplicate keys exist, only the last value for a given key is used.",
+			"This can cause confusion and bugs, especially when maintaining the code."
+		],
+		suggestions: ["If both values are meant to exist, change one of the keys to be different.", "If only the last value is meant to exist, remove any prior values."]
+	} },
+	setup(context) {
+		return { visitors: { ObjectLiteralExpression(node, { sourceFile }) {
+			const seenKeys = {
+				getters: /* @__PURE__ */ new Map(),
+				setters: /* @__PURE__ */ new Map(),
+				values: /* @__PURE__ */ new Map()
+			};
+			for (const property of node.properties.toReversed()) {
+				const key = getPropertyKeyName(property);
+				if (!key) continue;
+				if (seenKeys[key.group].get(key.text)) context.report({
+					message: "duplicateKey",
+					range: getTSNodeRange(key.node, sourceFile)
+				});
+				seenKeys[key.group].set(key.text, property);
+			}
+		} } };
+	}
+});
+function getNameText(name) {
+	if (name.kind === SyntaxKind.Identifier || name.kind === SyntaxKind.NumericLiteral || name.kind === SyntaxKind.BigIntLiteral || name.kind === SyntaxKind.StringLiteral || name.kind === SyntaxKind.NoSubstitutionTemplateLiteral) return name.text;
+	if (name.kind === SyntaxKind.PrivateIdentifier) return `#${name.text}`;
+}
+function getPropertyKeyName(property) {
+	if (property.kind === SyntaxKind.ShorthandPropertyAssignment) return {
+		group: "values",
+		node: property.name,
+		text: property.name.text
+	};
+	if (property.kind === SyntaxKind.PropertyAssignment || property.kind === SyntaxKind.MethodDeclaration || property.kind === SyntaxKind.GetAccessor || property.kind === SyntaxKind.SetAccessor) {
+		const { name } = property;
+		const text = getNameText(name);
+		if (!text) return;
+		return {
+			group: property.kind === SyntaxKind.GetAccessor ? "getters" : property.kind === SyntaxKind.SetAccessor ? "setters" : "values",
+			node: name,
+			text
+		};
+	}
+}
+//#endregion
+export { objectKeyDuplicates_default as default };
+
+//# sourceMappingURL=objectKeyDuplicates.js.map

package/lib/rules/objectProto.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.";
     readonly id: "objectProto";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noProto", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noProto", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=objectProto.d.ts.map

package/lib/rules/objectProto.js

@@ -1,54 +1,50 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.",
-        id: "objectProto",
-        preset: "untyped",
-    },
-    messages: {
-        noProto: {
-            primary: "Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.",
-            secondary: [
-                "The __proto__ property is deprecated and not part of the ECMAScript standard.",
-                "It is maintained for compatibility with older browsers but can cause performance issues and unexpected behavior.",
-                "Direct manipulation of an object's prototype can lead to hidden classes deoptimizations in JavaScript engines.",
-            ],
-            suggestions: [
-                "Use Object.getPrototypeOf(obj) to read the prototype of an object.",
-                "Use Object.setPrototypeOf(obj, proto) to set the prototype of an object.",
-                "Use Object.create(proto) when creating new objects with a specific prototype.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                ElementAccessExpression: (node) => {
-                    if (ts.isStringLiteral(node.argumentExpression) &&
-                        node.argumentExpression.text === "__proto__") {
-                        context.report({
-                            message: "noProto",
-                            range: {
-                                begin: node.argumentExpression.getStart(context.sourceFile),
-                                end: node.argumentExpression.getEnd(),
-                            },
-                        });
-                    }
-                },
-                PropertyAccessExpression: (node) => {
-                    if (node.name.kind === ts.SyntaxKind.Identifier &&
-                        node.name.text === "__proto__") {
-                        context.report({
-                            message: "noProto",
-                            range: {
-                                begin: node.name.getStart(context.sourceFile),
-                                end: node.name.getEnd(),
-                            },
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/objectProto.ts
+var objectProto_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.",
+		id: "objectProto",
+		presets: ["javascript"]
+	},
+	messages: { noProto: {
+		primary: "Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.",
+		secondary: [
+			"The __proto__ property is deprecated and not part of the ECMAScript standard.",
+			"It is maintained for compatibility with older browsers but can cause performance issues and unexpected behavior.",
+			"Direct manipulation of an object's prototype can lead to hidden classes deoptimizations in JavaScript engines."
+		],
+		suggestions: [
+			"Use Object.getPrototypeOf(obj) to read the prototype of an object.",
+			"Use Object.setPrototypeOf(obj, proto) to set the prototype of an object.",
+			"Use Object.create(proto) when creating new objects with a specific prototype."
+		]
+	} },
+	setup(context) {
+		return { visitors: {
+			ElementAccessExpression: (node, { sourceFile }) => {
+				if (node.argumentExpression.kind === SyntaxKind.StringLiteral && node.argumentExpression.text === "__proto__") context.report({
+					message: "noProto",
+					range: {
+						begin: node.argumentExpression.getStart(sourceFile),
+						end: node.argumentExpression.getEnd()
+					}
+				});
+			},
+			PropertyAccessExpression: (node, { sourceFile }) => {
+				if (node.name.kind === SyntaxKind.Identifier && node.name.text === "__proto__") context.report({
+					message: "noProto",
+					range: {
+						begin: node.name.getStart(sourceFile),
+						end: node.name.getEnd()
+					}
+				});
+			}
+		} };
+	}
 });
+//#endregion
+export { objectProto_default as default };
+
+//# sourceMappingURL=objectProto.js.map

package/lib/rules/objectPrototypeBuiltIns.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports direct calls to Object.prototype methods on object instances.";
+    readonly id: "objectPrototypeBuiltIns";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "prototypeBuiltIn", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=objectPrototypeBuiltIns.d.ts.map

package/lib/rules/objectPrototypeBuiltIns.js

@@ -0,0 +1,54 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+import { nullThrows } from "@flint.fyi/utils";
+//#region src/rules/objectPrototypeBuiltIns.ts
+const prototypeMethods = new Set([
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable"
+]);
+var objectPrototypeBuiltIns_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports direct calls to Object.prototype methods on object instances.",
+		id: "objectPrototypeBuiltIns",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { prototypeBuiltIn: {
+		primary: "Prefer the safer `Object.prototype.{{ method }}.call()` over calling `{{ method }}()` directly on objects.",
+		secondary: [
+			"Objects can have properties that shadow built-in methods from `Object.prototype` such as `{{ method }}()`.",
+			"Objects created with `Object.create(null)` do not inherit from `Object.prototype` and will not have these methods.",
+			"Calling these methods directly can fail or execute unintended code if the object has shadowing properties."
+		],
+		suggestions: ["Call the method through `Object.prototype` using `.call()`."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile }) => {
+			if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.name.kind !== SyntaxKind.Identifier) return;
+			const method = node.expression.name.text;
+			if (!prototypeMethods.has(method)) return;
+			const openParenthesisToken = findToken(node, SyntaxKind.OpenParenToken, sourceFile);
+			const closeParenthesisToken = findToken(node, SyntaxKind.CloseParenToken, sourceFile);
+			const objectText = sourceFile.text.slice(node.expression.expression.getStart(sourceFile), node.expression.expression.getEnd());
+			const argumentsText = sourceFile.text.slice(openParenthesisToken.getEnd(), closeParenthesisToken.getStart(sourceFile));
+			context.report({
+				data: { method },
+				message: "prototypeBuiltIn",
+				range: getTSNodeRange(node, sourceFile),
+				suggestions: [{
+					id: "usePrototypeCall",
+					range: getTSNodeRange(node, sourceFile),
+					text: `Object.prototype.${method}.call(${objectText}, ${argumentsText})`
+				}]
+			});
+		} } };
+	}
+});
+function findToken(node, token, sourceFile) {
+	return nullThrows(node.getChildren(sourceFile).find((child) => child.kind === token), "Token is expected to be present by the find call");
+}
+//#endregion
+export { objectPrototypeBuiltIns_default as default };
+
+//# sourceMappingURL=objectPrototypeBuiltIns.js.map

package/lib/rules/objectShorthand.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Object property and method definitions can use shorthand syntax when the key matches the value identifier or when a function expression is assigned.";
+    readonly id: "objectShorthand";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "expectedMethodShorthand" | "expectedPropertyShorthand", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=objectShorthand.d.ts.map

package/lib/rules/objectShorthand.js

@@ -0,0 +1,84 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/objectShorthand.ts
+function containsThisOrArguments(node) {
+	function visit(current) {
+		if (current.kind === SyntaxKind.ThisKeyword || current.kind === SyntaxKind.SuperKeyword) return true;
+		if (ts.isIdentifier(current) && current.text === "arguments") return true;
+		if (ts.isMetaProperty(current) && current.keywordToken === SyntaxKind.NewKeyword) return true;
+		if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isClassDeclaration(current) || ts.isClassExpression(current)) return false;
+		return ts.forEachChild(current, visit) ?? false;
+	}
+	return visit(node);
+}
+function getPropertyKeyText(name) {
+	switch (name.kind) {
+		case SyntaxKind.ComputedPropertyName:
+			if (name.expression.kind === SyntaxKind.Identifier) return name.expression.text;
+			return;
+		case SyntaxKind.Identifier:
+		case SyntaxKind.NoSubstitutionTemplateLiteral:
+		case SyntaxKind.NumericLiteral:
+		case SyntaxKind.StringLiteral: return name.text;
+		default: return;
+	}
+}
+function hasAsyncModifier(modifiers) {
+	return modifiers?.some((modifier) => modifier.kind === SyntaxKind.AsyncKeyword);
+}
+var objectShorthand_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Object property and method definitions can use shorthand syntax when the key matches the value identifier or when a function expression is assigned.",
+		id: "objectShorthand",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: {
+		expectedMethodShorthand: {
+			primary: "Function expressions in object literals can use method shorthand syntax.",
+			secondary: ["Method shorthand syntax is more concise and clearly indicates the property is a method.", "Instead of `{ method: function() {} }`, use `{ method() {} }`."],
+			suggestions: ["Use method shorthand syntax."]
+		},
+		expectedPropertyShorthand: {
+			primary: "Object properties where the key matches the value identifier can use shorthand syntax.",
+			secondary: ["Property shorthand syntax reduces redundancy when the property name matches the variable name.", "Instead of `{ x: x }`, use `{ x }`."],
+			suggestions: ["Use property shorthand syntax."]
+		}
+	},
+	setup(context) {
+		return { visitors: { PropertyAssignment: (node, { sourceFile }) => {
+			const keyText = getPropertyKeyText(node.name);
+			if (keyText === void 0) return;
+			const initializer = unwrapParenthesizedNode(node.initializer);
+			switch (initializer.kind) {
+				case SyntaxKind.ArrowFunction:
+					if (initializer.body.kind === SyntaxKind.Block && !hasAsyncModifier(initializer.modifiers) && !containsThisOrArguments(initializer.body)) context.report({
+						message: "expectedMethodShorthand",
+						range: getTSNodeRange(node, sourceFile)
+					});
+					return;
+				case SyntaxKind.FunctionExpression:
+					if (!initializer.name) context.report({
+						message: "expectedMethodShorthand",
+						range: getTSNodeRange(node, sourceFile)
+					});
+					return;
+				case SyntaxKind.Identifier:
+					if (initializer.text !== keyText) return;
+					if (node.name.kind === SyntaxKind.StringLiteral && !isValidIdentifier(keyText)) return;
+					context.report({
+						message: "expectedPropertyShorthand",
+						range: getTSNodeRange(node, sourceFile)
+					});
+					return;
+			}
+		} } };
+	}
+});
+function isValidIdentifier(name) {
+	return /^[\p{ID_Start}$_][\p{ID_Continue}$]*$/u.test(name);
+}
+//#endregion
+export { objectShorthand_default as default };
+
+//# sourceMappingURL=objectShorthand.js.map

package/lib/rules/objectSpreadUnnecessaryFallbacks.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty object fallbacks in object spread expressions that have no effect.";
+    readonly id: "objectSpreadUnnecessaryFallbacks";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryFallback", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=objectSpreadUnnecessaryFallbacks.d.ts.map

package/lib/rules/objectSpreadUnnecessaryFallbacks.js

@@ -0,0 +1,43 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/objectSpreadUnnecessaryFallbacks.ts
+function isEmptyObjectLiteral(node) {
+	const unwrapped = unwrapParentheses(node);
+	return ts$1.isObjectLiteralExpression(unwrapped) && !unwrapped.properties.length;
+}
+function unwrapParentheses(node) {
+	return ts$1.isParenthesizedExpression(node) ? unwrapParentheses(node.expression) : node;
+}
+var objectSpreadUnnecessaryFallbacks_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports empty object fallbacks in object spread expressions that have no effect.",
+		id: "objectSpreadUnnecessaryFallbacks",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unnecessaryFallback: {
+		primary: "Spreading `undefined` or `null` in an object literal has no effect, making this empty object fallback unnecessary.",
+		secondary: ["When spreading `undefined` or `null` in an object literal, JavaScript skips those values without throwing an error.", "A fallback like `|| {}` or `?? {}` is not needed because the spread will work correctly without it."],
+		suggestions: ["Remove the empty object fallback and spread the value directly."]
+	} },
+	setup(context) {
+		return { visitors: { ObjectLiteralExpression: (node, { sourceFile }) => {
+			for (const property of node.properties) {
+				if (!ts$1.isSpreadAssignment(property)) continue;
+				const spreadExpression = unwrapParentheses(property.expression);
+				if (!ts$1.isBinaryExpression(spreadExpression)) continue;
+				const operatorKind = spreadExpression.operatorToken.kind;
+				if (operatorKind !== ts$1.SyntaxKind.BarBarToken && operatorKind !== ts$1.SyntaxKind.QuestionQuestionToken) continue;
+				if (!isEmptyObjectLiteral(spreadExpression.right)) continue;
+				context.report({
+					message: "unnecessaryFallback",
+					range: getTSNodeRange(spreadExpression.right, sourceFile)
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { objectSpreadUnnecessaryFallbacks_default as default };
+
+//# sourceMappingURL=objectSpreadUnnecessaryFallbacks.js.map

package/lib/rules/objectTypeDefinitions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer interface declarations over type aliases for object types.";
+    readonly id: "objectTypeDefinitions";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferInterface", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=objectTypeDefinitions.d.ts.map

package/lib/rules/objectTypeDefinitions.js

@@ -0,0 +1,34 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/objectTypeDefinitions.ts
+var objectTypeDefinitions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer interface declarations over type aliases for object types.",
+		id: "objectTypeDefinitions",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferInterface: {
+		primary: "Type aliases for object types have different behavior from interfaces in some cases.",
+		secondary: [
+			"Interfaces support declaration merging and can be extended with the `extends` keyword.",
+			"Interfaces can be implemented by classes, providing clearer contracts.",
+			"Error messages from the TypeScript compiler often display the interface name directly, making them more readable."
+		],
+		suggestions: ["Use an interface declaration instead: `interface Name { ... }`."]
+	} },
+	setup(context) {
+		return { visitors: { TypeAliasDeclaration: (node, { sourceFile }) => {
+			if (node.type.kind !== SyntaxKind.TypeLiteral) return;
+			const typeKeyword = node.getChildren(sourceFile).find((child) => child.kind === SyntaxKind.TypeKeyword);
+			context.report({
+				message: "preferInterface",
+				range: typeKeyword ? getTSNodeRange(typeKeyword, sourceFile) : getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { objectTypeDefinitions_default as default };
+
+//# sourceMappingURL=objectTypeDefinitions.js.map

package/lib/rules/octalEscapes.d.ts

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