@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/objectKeyDuplicates.d.ts

@@ -1,9 +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;

package/lib/rules/objectKeyDuplicates.js

@@ -1,61 +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 };

package/lib/rules/objectProto.d.ts

@@ -1,9 +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;

package/lib/rules/objectProto.js

@@ -1,48 +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 };

package/lib/rules/objectPrototypeBuiltIns.d.ts

@@ -1,9 +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;

package/lib/rules/objectPrototypeBuiltIns.js

@@ -1,52 +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 = /* @__PURE__ */ 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 };

package/lib/rules/objectShorthand.d.ts

@@ -1,9 +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;

package/lib/rules/objectShorthand.js

@@ -1,82 +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 };

package/lib/rules/objectSpreadUnnecessaryFallbacks.d.ts

@@ -1,9 +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;

package/lib/rules/objectSpreadUnnecessaryFallbacks.js

@@ -1,41 +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 };

package/lib/rules/objectTypeDefinitions.d.ts

@@ -1,9 +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;

package/lib/rules/objectTypeDefinitions.js

@@ -1,32 +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 };

package/lib/rules/octalEscapes.d.ts

@@ -1,9 +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;

package/lib/rules/octalEscapes.js

@@ -1,56 +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 };

package/lib/rules/octalNumbers.d.ts

@@ -1,9 +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;

package/lib/rules/octalNumbers.js

@@ -1,53 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/octalNumbers.ts
-var octalNumbers_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using legacy octal numeric literals.",
-		id: "octalNumbers",
-		presets: ["javascript"]
-	},
-	messages: { noOctalNumber: {
-		primary: "This legacy octal numeric literal evaluates to {{ raw }}. Did you mean that value, or to use a modern octal syntax such as {{ equivalent }}?",
-		secondary: [
-			"Legacy octal numeric literals (e.g., `077`, `0123`) are a deprecated feature in JavaScript that can lead to confusion and errors.",
-			"They are forbidden in strict mode and are less readable than their modern alternatives.",
-			"The digit `0` by itself is allowed as it represents zero, not an octal literal."
-		],
-		suggestions: ["Use the explicit octal syntax (e.g., `0o77`) introduced in ES6, which is clearer and works in both strict and non-strict modes.", "Remove the leading `0` if you intended to use the decimal value."]
-	} },
-	setup(context) {
-		return { visitors: { NumericLiteral: (node, { sourceFile }) => {
-			const text = node.getText(sourceFile);
-			if (text.length > 1 && text.startsWith("0") && nullThrows(text[1], "Second character is expected to be present by prior length check") >= "0" && nullThrows(text[1], "Second character is expected to be present by prior length check") <= "7" && !/^0[xobi]/i.test(text)) {
-				const range = {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				};
-				const octalValue = parseInt(text, 8);
-				const modernOctalSyntax = `0o${text.slice(1)}`;
-				const decimalWithoutLeadingZero = text.slice(1);
-				context.report({
-					data: {
-						equivalent: modernOctalSyntax,
-						raw: octalValue.toString()
-					},
-					message: "noOctalNumber",
-					range,
-					suggestions: [{
-						id: "useModernOctalSyntax",
-						range,
-						text: modernOctalSyntax
-					}, {
-						id: "removeLeadingZero",
-						range,
-						text: decimalWithoutLeadingZero
-					}]
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { octalNumbers_default as default };

package/lib/rules/operatorAssignmentShorthand.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer assignment operator shorthand where possible.";
-    readonly id: "operatorAssignmentShorthand";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferShorthand", undefined>;
-export default _default;

package/lib/rules/operatorAssignmentShorthand.js

@@ -1,75 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/operatorAssignmentShorthand.ts
-const operatorTexts = /* @__PURE__ */ new Map([
-	[ts.SyntaxKind.AmpersandToken, "&"],
-	[ts.SyntaxKind.AsteriskAsteriskToken, "**"],
-	[ts.SyntaxKind.AsteriskToken, "*"],
-	[ts.SyntaxKind.BarToken, "|"],
-	[ts.SyntaxKind.CaretToken, "^"],
-	[ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, ">>>"],
-	[ts.SyntaxKind.GreaterThanGreaterThanToken, ">>"],
-	[ts.SyntaxKind.LessThanLessThanToken, "<<"],
-	[ts.SyntaxKind.MinusToken, "-"],
-	[ts.SyntaxKind.PercentToken, "%"],
-	[ts.SyntaxKind.PlusToken, "+"],
-	[ts.SyntaxKind.SlashToken, "/"]
-]);
-const commutativeOperatorsWithShorthand = /* @__PURE__ */ new Set([
-	"&",
-	"*",
-	"^",
-	"|"
-]);
-const nonCommutativeOperatorsWithShorthand = /* @__PURE__ */ new Set([
-	"%",
-	"**",
-	"+",
-	"-",
-	"/",
-	"<<",
-	">>",
-	">>>"
-]);
-var operatorAssignmentShorthand_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer assignment operator shorthand where possible.",
-		id: "operatorAssignmentShorthand",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferShorthand: {
-		primary: "This `=` assignment can be replaced with an `{{ operator }}=` operator assignment.",
-		secondary: ["The shorthand operator assignment accomplishes the same operation with less code."],
-		suggestions: ["Switch the `=` assignment with an `{{ operator }}` operator assignment."]
-	} },
-	setup(context) {
-		function report(operator, node, right, sourceFile) {
-			const range = getTSNodeRange(node, sourceFile);
-			context.report({
-				data: { operator },
-				fix: {
-					range,
-					text: [
-						node.left.getText(sourceFile),
-						`${operator}=`,
-						right.getText(sourceFile)
-					].join(" ")
-				},
-				message: "preferShorthand",
-				range
-			});
-		}
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !ts.isBinaryExpression(node.right)) return;
-			const operator = operatorTexts.get(node.right.operatorToken.kind);
-			if (!operator) return;
-			const isCommutative = commutativeOperatorsWithShorthand.has(operator);
-			if (!isCommutative && !nonCommutativeOperatorsWithShorthand.has(operator)) return;
-			if (hasSameTokens(node.left, node.right.left, sourceFile)) report(operator, node, node.right.right, sourceFile);
-			else if (isCommutative && hasSameTokens(node.left, node.right.right, sourceFile)) report(operator, node, node.right.left, sourceFile);
-		} } };
-	}
-});
-//#endregion
-export { operatorAssignmentShorthand_default as default };

package/lib/rules/overloadSignaturesAdjacent.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Require that function overload signatures be consecutive.";
-    readonly id: "overloadSignaturesAdjacent";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "overloadSignatureSeparated", undefined>;
-export default _default;