@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/objectEntriesMethods.js

@@ -1,82 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { skipParentheses } from "./utils/skipParentheses.js";
-import { isArrayOrTupleTypeAtLocation } from "./utils/isArrayOrTupleTypeAtLocation.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/objectEntriesMethods.ts
-function isArrowFunctionWithParams(node) {
-	return node.kind === SyntaxKind.ArrowFunction && !!node.parameters.length;
-}
-function isEmptyObject(node, typeChecker) {
-	const unwrapped = skipParentheses(node);
-	return isEmptyObjectLiteral(unwrapped) || isObjectCreateNull(unwrapped, typeChecker);
-}
-function isEmptyObjectLiteral(node) {
-	return node.kind === SyntaxKind.ObjectLiteralExpression && !node.properties.length;
-}
-function isObjectAssignPattern(callback, typeChecker) {
-	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;
-	const firstArg = body.arguments[0];
-	if (firstArg.kind !== SyntaxKind.Identifier || firstArg.text !== accumulatorName) return false;
-	const secondArg = body.arguments[1];
-	if (secondArg.kind !== SyntaxKind.ObjectLiteralExpression || secondArg.properties.length !== 1) return false;
-	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;
-	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 isReduceCallWithEmptyObject(node, typeChecker) {
-	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);
-}
-function isSpreadAccumulatorPattern(callback) {
-	if (callback.parameters.length < 1) return false;
-	const firstParam = callback.parameters[0];
-	if (firstParam?.name.kind !== SyntaxKind.Identifier) return false;
-	const accumulatorName = firstParam.name.text;
-	const body = skipParentheses(callback.body);
-	if (body.kind !== SyntaxKind.ObjectLiteralExpression || body.properties.length !== 2) return false;
-	const firstProp = body.properties[0];
-	if (firstProp.kind !== SyntaxKind.SpreadAssignment || firstProp.expression.kind !== SyntaxKind.Identifier || firstProp.expression.text !== accumulatorName) return false;
-	const secondProp = body.properties[1];
-	return secondProp.kind === SyntaxKind.PropertyAssignment && secondProp.name.kind === SyntaxKind.ComputedPropertyName;
-}
-var objectEntriesMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer Object.fromEntries() over reduce patterns that build objects from key-value pairs.",
-		id: "objectEntriesMethods",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferFromEntries: {
-		primary: "Using reduce to build an object from key-value pairs can be replaced with Object.fromEntries().",
-		secondary: ["Object.fromEntries() is more readable and concise for converting an iterable of key-value pairs into an object.", "The reduce pattern creates unnecessary intermediate objects on each iteration."],
-		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;
-			const callback = node.arguments[0];
-			if (!isArrowFunctionWithParams(callback) || callback.body.kind === SyntaxKind.Block) return;
-			if (!isObjectAssignPattern(callback, typeChecker) && !isSpreadAccumulatorPattern(callback)) return;
-			context.report({
-				message: "preferFromEntries",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { objectEntriesMethods_default as default };
-
-//# sourceMappingURL=objectEntriesMethods.js.map

package/lib/rules/objectHasOwns.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.";
-    readonly id: "objectHasOwns";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferHasOwn", undefined>;
-export default _default;
-//# sourceMappingURL=objectHasOwns.d.ts.map

package/lib/rules/objectHasOwns.js

@@ -1,50 +0,0 @@
-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

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

package/lib/rules/objectKeyDuplicates.js

@@ -1,63 +0,0 @@
-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,10 +0,0 @@
-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 presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noProto", undefined>;
-export default _default;
-//# sourceMappingURL=objectProto.d.ts.map

package/lib/rules/objectProto.js

@@ -1,50 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "prototypeBuiltIn", undefined>;
-export default _default;
-//# sourceMappingURL=objectPrototypeBuiltIns.d.ts.map

package/lib/rules/objectPrototypeBuiltIns.js

@@ -1,54 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "expectedMethodShorthand" | "expectedPropertyShorthand", undefined>;
-export default _default;
-//# sourceMappingURL=objectShorthand.d.ts.map

package/lib/rules/objectShorthand.js

@@ -1,84 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryFallback", undefined>;
-export default _default;
-//# sourceMappingURL=objectSpreadUnnecessaryFallbacks.d.ts.map

package/lib/rules/objectSpreadUnnecessaryFallbacks.js

@@ -1,43 +0,0 @@
-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

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

package/lib/rules/objectTypeDefinitions.js

@@ -1,34 +0,0 @@
-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,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using octal escape sequences in string literals.";
-    readonly id: "octalEscapes";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noOctalEscape", undefined>;
-export default _default;
-//# sourceMappingURL=octalEscapes.d.ts.map

package/lib/rules/octalEscapes.js

@@ -1,58 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/octalEscapes.ts
-/**
-* Finds the position and length of an octal escape sequence in a string.
-* Returns undefined if no octal escape is found.
-*/
-function findOctalEscape(text) {
-	const content = text.slice(1, -1);
-	const match = /(?<!\\)\\0[0-7]|(?<!\\)\\[1-7][0-7]*/.exec(content);
-	if (!match) return;
-	return {
-		index: match.index + 1,
-		length: match[0].length
-	};
-}
-var octalEscapes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using octal escape sequences in string literals.",
-		id: "octalEscapes",
-		presets: ["javascript"]
-	},
-	messages: { noOctalEscape: {
-		primary: "Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.",
-		secondary: ["Octal escape sequences (e.g., `\\01`, `\\02`, `\\377`) are a deprecated feature in JavaScript that can lead to confusion and are forbidden in strict mode and template literals.", "They are less readable than their modern alternatives and can cause portability issues."],
-		suggestions: ["Use hexadecimal escape sequences (e.g., `\\x01`) or Unicode escape sequences (e.g., `\\u0001`) instead."]
-	} },
-	setup(context) {
-		function checkNode(node, sourceFile) {
-			const octalEscape = findOctalEscape(node.getText(sourceFile));
-			if (!octalEscape) return;
-			const nodeStart = node.getStart(sourceFile);
-			context.report({
-				message: "noOctalEscape",
-				range: {
-					begin: nodeStart + octalEscape.index,
-					end: nodeStart + octalEscape.index + octalEscape.length
-				}
-			});
-		}
-		return { visitors: {
-			NoSubstitutionTemplateLiteral: (node, { sourceFile }) => {
-				checkNode(node, sourceFile);
-			},
-			StringLiteral: (node, { sourceFile }) => {
-				checkNode(node, sourceFile);
-			},
-			TemplateExpression: (node, { sourceFile }) => {
-				checkNode(node.head, sourceFile);
-				for (const span of node.templateSpans) checkNode(span.literal, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { octalEscapes_default as default };
-
-//# sourceMappingURL=octalEscapes.js.map

package/lib/rules/octalNumbers.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using legacy octal numeric literals.";
-    readonly id: "octalNumbers";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noOctalNumber", undefined>;
-export default _default;
-//# sourceMappingURL=octalNumbers.d.ts.map