@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/objectPrototypeBuiltIns.js

@@ -1,65 +1,54 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
+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",
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable"
 ]);
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports direct calls to Object.prototype methods on object instances.",
-        id: "objectPrototypeBuiltIns",
-        preset: "logical",
-    },
-    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 (!ts.isPropertyAccessExpression(node.expression) ||
-                        !ts.isIdentifier(node.expression.name)) {
-                        return;
-                    }
-                    const method = node.expression.name.text;
-                    if (!prototypeMethods.has(method)) {
-                        return;
-                    }
-                    const openParenthesisToken = findToken(node, ts.SyntaxKind.OpenParenToken, sourceFile);
-                    const closeParenthesisToken = findToken(node, ts.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})`,
-                            },
-                        ],
-                    });
-                },
-            },
-        };
-    },
+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) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return node.getChildren(sourceFile).find((child) => child.kind === token);
+	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,7 +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").TypeScriptFileServices, "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

package/lib/rules/octalEscapes.js

@@ -1,76 +1,58 @@
-import { typescriptLanguage } from "../language.js";
+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.
- */
+* Finds the position and length of an octal escape sequence in a string.
+* Returns undefined if no octal escape is found.
+*/
 function findOctalEscape(text) {
-    // Remove quotes from the string literal
-    const content = text.slice(1, -1);
-    // Match octal escapes: \0 followed by [0-7], or \1-7 optionally followed by [0-7]
-    // But exclude escaped backslashes (\\)
-    const octalEscapePattern = /(?<!\\)\\0[0-7]|(?<!\\)\\[1-7][0-7]*/;
-    const match = octalEscapePattern.exec(content);
-    if (!match) {
-        return undefined;
-    }
-    // Add 1 to account for the opening quote
-    return {
-        index: match.index + 1,
-        length: match[0].length,
-    };
+	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
+	};
 }
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using octal escape sequences in string literals.",
-        id: "octalEscapes",
-        preset: "logical",
-    },
-    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 text = node.getText(sourceFile);
-            const octalEscape = findOctalEscape(text);
-            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 }) => {
-                    // Check the head of the template
-                    checkNode(node.head, sourceFile);
-                    // Check each template span
-                    for (const span of node.templateSpans) {
-                        checkNode(span.literal, sourceFile);
-                    }
-                },
-            },
-        };
-    },
+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,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using legacy octal numeric literals.";
     readonly id: "octalNumbers";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noOctalNumber", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noOctalNumber", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=octalNumbers.d.ts.map

package/lib/rules/octalNumbers.js

@@ -1,69 +1,55 @@
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using legacy octal numeric literals.",
-        id: "octalNumbers",
-        preset: "untyped",
-    },
-    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);
-                    // Check for legacy octal literal: starts with 0 followed by octal digits (0-7)
-                    // But not just "0" alone, and not modern formats like 0x, 0o, 0b
-                    // cspell:ignore xobi
-                    if (text.length > 1 &&
-                        text.startsWith("0") &&
-                        text[1] >= "0" &&
-                        text[1] <= "7" &&
-                        !/^0[xobi]/i.test(text)) {
-                        const range = {
-                            begin: node.getStart(sourceFile),
-                            end: node.getEnd(),
-                        };
-                        // Parse the octal value
-                        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,
-                                },
-                            ],
-                        });
-                    }
-                },
-            },
-        };
-    },
+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 };
+
 //# sourceMappingURL=octalNumbers.js.map

package/lib/rules/operatorAssignmentShorthand.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer assignment operator shorthand where possible.";
+    readonly id: "operatorAssignmentShorthand";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferShorthand", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=operatorAssignmentShorthand.d.ts.map