@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/utils/isUnsafeAssignment.js

@@ -1,76 +1,45 @@
+import ts, { SyntaxKind } from "typescript";
 import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
+import { nullThrows } from "@flint.fyi/utils";
+//#region src/rules/utils/isUnsafeAssignment.ts
 /**
- * Does a simple check to see if there is an any being assigned to a non-any type.
- *
- * This also checks generic positions to ensure there's no unsafe sub-assignments.
- * Note: in the case of generic positions, it makes the assumption that the two types are the same.
- * @example See tests for examples
- * @returns false if it's safe, or an object with the two types if it's unsafe
- */
-export function isUnsafeAssignment(type, receiver, checker, senderNode) {
-    return isUnsafeAssignmentWorker(type, receiver, checker, senderNode, new Map());
+* Does a simple check to see if there is an any being assigned to a non-any type.
+*
+* This also checks generic positions to ensure there's no unsafe sub-assignments.
+* Note: in the case of generic positions, it makes the assumption that the two types are the same.
+* @example See tests for examples
+* @returns false if it's safe, or an object with the two types if it's unsafe
+*/
+function isUnsafeAssignment(type, receiver, senderNode) {
+	return isUnsafeAssignmentWorker(type, receiver, senderNode, /* @__PURE__ */ new Map());
 }
-function isUnsafeAssignmentWorker(type, receiver, checker, senderNode, visited) {
-    if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) {
-        // Allow assignment of any ==> unknown.
-        if (tsutils.isTypeFlagSet(receiver, ts.TypeFlags.Unknown)) {
-            return false;
-        }
-        if (!tsutils.isTypeFlagSet(receiver, ts.TypeFlags.Any)) {
-            return { receiver, sender: type };
-        }
-    }
-    const typeAlreadyVisited = visited.get(type);
-    if (typeAlreadyVisited) {
-        if (typeAlreadyVisited.has(receiver)) {
-            return false;
-        }
-        typeAlreadyVisited.add(receiver);
-    }
-    else {
-        visited.set(type, new Set([receiver]));
-    }
-    if (tsutils.isTypeReference(type) && tsutils.isTypeReference(receiver)) {
-        // TODO - figure out how to handle cases like this,
-        // where the types are assignable, but not the same type
-        /*
-    function foo(): ReadonlySet<number> { return new Set<any>(); }
-
-    // and
-
-    type Test<T> = { prop: T }
-    type Test2 = { prop: string }
-    declare const a: Test<any>;
-    const b: Test2 = a;
-    */
-        if (type.target !== receiver.target) {
-            // if the type references are different, assume safe, as we won't know how to compare the two types
-            // the generic positions might not be equivalent for both types
-            return false;
-        }
-        if (senderNode != null &&
-            ts.isNewExpression(senderNode) &&
-            ts.isIdentifier(senderNode.expression) &&
-            senderNode.expression.text === "Map" &&
-            (senderNode.arguments == null || senderNode.arguments.length === 0) &&
-            senderNode.typeArguments == null) {
-            // special case to handle `new Map()`
-            // unfortunately Map's default empty constructor is typed to return `Map<any, any>` :(
-            // https://github.com/typescript-eslint/typescript-eslint/issues/2109#issuecomment-634144396
-            return false;
-        }
-        const typeArguments = type.typeArguments ?? [];
-        const receiverTypeArguments = receiver.typeArguments ?? [];
-        for (let i = 0; i < typeArguments.length; i += 1) {
-            const arg = typeArguments[i];
-            const receiverArg = receiverTypeArguments[i];
-            const unsafe = isUnsafeAssignmentWorker(arg, receiverArg, checker, senderNode, visited);
-            if (unsafe) {
-                return { receiver, sender: type };
-            }
-        }
-        return false;
-    }
-    return false;
+function isUnsafeAssignmentWorker(type, receiver, senderNode, visited) {
+	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) {
+		if (tsutils.isTypeFlagSet(receiver, ts.TypeFlags.Unknown)) return false;
+		if (!tsutils.isTypeFlagSet(receiver, ts.TypeFlags.Any)) return {
+			receiver,
+			sender: type
+		};
+	}
+	const typeAlreadyVisited = visited.get(type);
+	if (typeAlreadyVisited) {
+		if (typeAlreadyVisited.has(receiver)) return false;
+		typeAlreadyVisited.add(receiver);
+	} else visited.set(type, new Set([receiver]));
+	if (tsutils.isTypeReference(type) && tsutils.isTypeReference(receiver)) {
+		if (type.target !== receiver.target) return false;
+		if (senderNode.kind === SyntaxKind.NewExpression && senderNode.expression.kind === SyntaxKind.Identifier && senderNode.expression.text === "Map" && !senderNode.arguments?.length && senderNode.typeArguments == null) return false;
+		const typeArguments = type.typeArguments ?? [];
+		const receiverTypeArguments = receiver.typeArguments ?? [];
+		for (let i = 0; i < typeArguments.length; i += 1) if (isUnsafeAssignmentWorker(nullThrows(typeArguments[i], "Type argument is expected to be present by the loop condition"), nullThrows(receiverTypeArguments[i], "Receiver type should have the same number of type arguments as the sender type when they share the same target"), senderNode, visited)) return {
+			receiver,
+			sender: type
+		};
+		return false;
+	}
+	return false;
 }
+//#endregion
+export { isUnsafeAssignment };
+
+//# sourceMappingURL=isUnsafeAssignment.js.map

package/lib/rules/utils/operators.d.ts

@@ -1,4 +1,5 @@
-import * as ts from "typescript";
-export declare function isComparisonOperator(token: ts.BinaryOperatorToken): boolean;
-export declare function isEqualityOperator(token: ts.BinaryOperatorToken): boolean;
-export declare function isNegatedEqualityOperator(token: ts.BinaryOperatorToken): boolean;
+import type { AST } from "@flint.fyi/typescript-language";
+export declare function isComparisonOperator(token: AST.BinaryOperatorToken): boolean;
+export declare function isEqualityOperator(token: AST.BinaryOperatorToken): boolean;
+export declare function isNegatedEqualityOperator(token: AST.BinaryOperatorToken): boolean;
+//# sourceMappingURL=operators.d.ts.map

package/lib/rules/utils/operators.js

@@ -1,36 +1,35 @@
-import * as ts from "typescript";
-export function isComparisonOperator(token) {
-    switch (token.kind) {
-        case ts.SyntaxKind.EqualsEqualsEqualsToken:
-        case ts.SyntaxKind.EqualsEqualsToken:
-        case ts.SyntaxKind.ExclamationEqualsEqualsToken:
-        case ts.SyntaxKind.ExclamationEqualsToken:
-        case ts.SyntaxKind.GreaterThanEqualsToken:
-        case ts.SyntaxKind.GreaterThanToken:
-        case ts.SyntaxKind.LessThanEqualsToken:
-        case ts.SyntaxKind.LessThanToken:
-            return true;
-        default:
-            return false;
-    }
+import { SyntaxKind } from "typescript";
+//#region src/rules/utils/operators.ts
+function isComparisonOperator(token) {
+	switch (token.kind) {
+		case SyntaxKind.EqualsEqualsEqualsToken:
+		case SyntaxKind.EqualsEqualsToken:
+		case SyntaxKind.ExclamationEqualsEqualsToken:
+		case SyntaxKind.ExclamationEqualsToken:
+		case SyntaxKind.GreaterThanEqualsToken:
+		case SyntaxKind.GreaterThanToken:
+		case SyntaxKind.LessThanEqualsToken:
+		case SyntaxKind.LessThanToken: return true;
+		default: return false;
+	}
 }
-export function isEqualityOperator(token) {
-    switch (token.kind) {
-        case ts.SyntaxKind.EqualsEqualsEqualsToken:
-        case ts.SyntaxKind.EqualsEqualsToken:
-        case ts.SyntaxKind.ExclamationEqualsEqualsToken:
-        case ts.SyntaxKind.ExclamationEqualsToken:
-            return true;
-        default:
-            return false;
-    }
+function isEqualityOperator(token) {
+	switch (token.kind) {
+		case SyntaxKind.EqualsEqualsEqualsToken:
+		case SyntaxKind.EqualsEqualsToken:
+		case SyntaxKind.ExclamationEqualsEqualsToken:
+		case SyntaxKind.ExclamationEqualsToken: return true;
+		default: return false;
+	}
 }
-export function isNegatedEqualityOperator(token) {
-    switch (token.kind) {
-        case ts.SyntaxKind.ExclamationEqualsEqualsToken:
-        case ts.SyntaxKind.ExclamationEqualsToken:
-            return true;
-        default:
-            return false;
-    }
+function isNegatedEqualityOperator(token) {
+	switch (token.kind) {
+		case SyntaxKind.ExclamationEqualsEqualsToken:
+		case SyntaxKind.ExclamationEqualsToken: return true;
+		default: return false;
+	}
 }
+//#endregion
+export { isComparisonOperator, isEqualityOperator, isNegatedEqualityOperator };
+
+//# sourceMappingURL=operators.js.map

package/lib/rules/utils/parseRegexpAst.d.ts

@@ -0,0 +1,2 @@
+export declare function parseRegexpAst(pattern: string, flags?: string): import("@eslint-community/regexpp/ast").Pattern | undefined;
+//# sourceMappingURL=parseRegexpAst.d.ts.map

package/lib/rules/utils/parseRegexpAst.js

@@ -0,0 +1,17 @@
+import { RegExpParser } from "@eslint-community/regexpp";
+//#region src/rules/utils/parseRegexpAst.ts
+const parser = new RegExpParser();
+function parseRegexpAst(pattern, flags = "") {
+	try {
+		return parser.parsePattern(pattern, void 0, void 0, {
+			unicode: flags.includes("u"),
+			unicodeSets: flags.includes("v")
+		});
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { parseRegexpAst };
+
+//# sourceMappingURL=parseRegexpAst.js.map

package/lib/rules/utils/parseRegexpAstFull.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedLiteral } from "scslre";
+export declare function parseRegexpAstFull(pattern: string, flags?: string): ParsedLiteral | undefined;
+//# sourceMappingURL=parseRegexpAstFull.d.ts.map

package/lib/rules/utils/parseRegexpAstFull.js

@@ -0,0 +1,18 @@
+import { RegExpParser } from "@eslint-community/regexpp";
+//#region src/rules/utils/parseRegexpAstFull.ts
+const parser = new RegExpParser();
+function parseRegexpAstFull(pattern, flags = "") {
+	try {
+		const regexpFlags = parser.parseFlags(flags);
+		return {
+			flags: regexpFlags,
+			pattern: parser.parsePattern(pattern, void 0, void 0, regexpFlags)
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { parseRegexpAstFull };
+
+//# sourceMappingURL=parseRegexpAstFull.js.map

package/lib/rules/utils/skipParentheses.d.ts

@@ -0,0 +1,3 @@
+import type { AST } from "@flint.fyi/typescript-language";
+export declare function skipParentheses(node: AST.Expression): AST.Expression;
+//# sourceMappingURL=skipParentheses.d.ts.map

package/lib/rules/utils/skipParentheses.js

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "typescript";
+//#region src/rules/utils/skipParentheses.ts
+function skipParentheses(node) {
+	while (node.kind === SyntaxKind.ParenthesizedExpression) node = node.expression;
+	return node;
+}
+//#endregion
+export { skipParentheses };
+
+//# sourceMappingURL=skipParentheses.js.map

package/lib/rules/variableDeletions.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports attempting to delete variables with the delete operator.";
     readonly id: "variableDeletions";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noDeleteVar", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noDeleteVar", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=variableDeletions.d.ts.map

package/lib/rules/variableDeletions.js

@@ -1,39 +1,35 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports attempting to delete variables with the delete operator.",
-        id: "variableDeletions",
-        preset: "untyped",
-    },
-    messages: {
-        noDeleteVar: {
-            primary: "Deleting a variable with the delete operator outside of strict mode will silently fail and return false.",
-            secondary: [
-                "The delete operator is only meant to remove properties from objects, not variables.",
-                "Attempting to delete a variable in strict mode will cause a syntax error.",
-                "In non-strict mode, it will silently fail and return false without actually deleting the variable.",
-            ],
-            suggestions: [
-                "Remove the delete statement, or if you need to unset the value, assign undefined instead.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                DeleteExpression: (node) => {
-                    if (node.expression.kind === ts.SyntaxKind.Identifier) {
-                        context.report({
-                            message: "noDeleteVar",
-                            range: {
-                                begin: node.getStart(context.sourceFile),
-                                end: node.getEnd(),
-                            },
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/variableDeletions.ts
+var variableDeletions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports attempting to delete variables with the delete operator.",
+		id: "variableDeletions",
+		presets: ["javascript"]
+	},
+	messages: { noDeleteVar: {
+		primary: "Deleting a variable with the delete operator outside of strict mode will silently fail and return false.",
+		secondary: [
+			"The delete operator is only meant to remove properties from objects, not variables.",
+			"Attempting to delete a variable in strict mode will cause a syntax error.",
+			"In non-strict mode, it will silently fail and return false without actually deleting the variable."
+		],
+		suggestions: ["Remove the delete statement, or if you need to unset the value, assign undefined instead."]
+	} },
+	setup(context) {
+		return { visitors: { DeleteExpression: (node, { sourceFile }) => {
+			if (node.expression.kind === SyntaxKind.Identifier) context.report({
+				message: "noDeleteVar",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.getEnd()
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { variableDeletions_default as default };
+
+//# sourceMappingURL=variableDeletions.js.map

package/lib/rules/voidOperator.d.ts

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

package/lib/rules/voidOperator.js

@@ -1,36 +1,34 @@
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using the void operator.",
-        id: "voidOperator",
-        preset: "stylistic",
-    },
-    messages: {
-        noVoid: {
-            primary: "Prefer an explicit value over using the void operator to produce undefined.",
-            secondary: [
-                "The void operator evaluates an expression and returns undefined, regardless of the expression's value.",
-                "This is often confusing and can be replaced with more explicit code.",
-                "Instead of using void, return or assign undefined directly.",
-            ],
-            suggestions: [
-                "Replace void expressions with undefined or restructure the code to be more explicit.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                VoidExpression: (node) => {
-                    context.report({
-                        message: "noVoid",
-                        range: {
-                            begin: node.getStart(context.sourceFile),
-                            end: node.getEnd(),
-                        },
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/voidOperator.ts
+var voidOperator_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using the void operator.",
+		id: "voidOperator",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { noVoid: {
+		primary: "Prefer an explicit value over using the void operator to produce undefined.",
+		secondary: [
+			"The void operator evaluates an expression and returns undefined, regardless of the expression's value.",
+			"This is often confusing and can be replaced with more explicit code.",
+			"Instead of using void, return or assign undefined directly."
+		],
+		suggestions: ["Replace void expressions with undefined or restructure the code to be more explicit."]
+	} },
+	setup(context) {
+		return { visitors: { VoidExpression: (node, { sourceFile }) => {
+			context.report({
+				message: "noVoid",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.getEnd()
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { voidOperator_default as default };
+
+//# sourceMappingURL=voidOperator.js.map

package/lib/rules/withStatements.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using with statements";
+    readonly id: "withStatements";
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "withStatement", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=withStatements.d.ts.map

package/lib/rules/withStatements.js

@@ -0,0 +1,30 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/withStatements.ts
+var withStatements_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using with statements",
+		id: "withStatements",
+		presets: ["javascript"]
+	},
+	messages: { withStatement: {
+		primary: "`with` statements are deprecated, unreliable, and difficult to reason about.",
+		secondary: ["The with statement is problematic because it adds members of an object to the current scope, making it impossible to tell what a variable inside the block actually refers to.", "If an object doesn't have an expected variable, you'll end up modifying a global instead of the expected property."],
+		suggestions: ["Create a variable with the content of the with expression and access its properties instead."]
+	} },
+	setup(context) {
+		return { visitors: { WithStatement: (node, { sourceFile }) => {
+			context.report({
+				message: "withStatement",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.getStart(sourceFile) + 4
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { withStatements_default as default };
+
+//# sourceMappingURL=withStatements.js.map

package/lib/rules/wrapperObjects.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Flags using `new` with `Boolean`, `Number`, or `String`, which creates wrapper objects instead of primitives.";
+    readonly id: "wrapperObjects";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "wrapperObject", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=wrapperObjects.d.ts.map

package/lib/rules/wrapperObjects.js

@@ -0,0 +1,36 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/wrapperObjects.ts
+const wrapperConstructors = new Set([
+	"Boolean",
+	"Number",
+	"String"
+]);
+var wrapperObjects_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Flags using `new` with `Boolean`, `Number`, or `String`, which creates wrapper objects instead of primitives.",
+		id: "wrapperObjects",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { wrapperObject: {
+		primary: "{{ name }} wrapper objects are rarely intended and can cause unexpected behavior.",
+		secondary: ["Using `new {{ name }}()` creates an object wrapper around a primitive value, not the primitive itself.", "Object wrappers behave differently from primitives in comparisons: `new String('a') !== 'a'`."],
+		suggestions: ["Use `{{ name }}()` without `new` to coerce values to primitives."]
+	} },
+	setup(context) {
+		return { visitors: { NewExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.expression.kind !== ts$1.SyntaxKind.Identifier || !wrapperConstructors.has(node.expression.text) || !isGlobalDeclarationOfName(node.expression, node.expression.text, typeChecker)) return;
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				data: { name: node.expression.text },
+				message: "wrapperObject",
+				range
+			});
+		} } };
+	}
+});
+//#endregion
+export { wrapperObjects_default as default };
+
+//# sourceMappingURL=wrapperObjects.js.map

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@flint.fyi/ts",
-  "version": "0.14.6",
+  "version": "0.18.0",
   "description": "[Experimental] TypeScript language plugin for Flint.",
+  "homepage": "https://www.flint.fyi/rules/ts",
   "repository": {
     "type": "git",
-    "url": "https://github.com/JoshuaKGoldberg/flint",
+    "url": "git+https://github.com/flint-fyi/flint.git",
     "directory": "packages/ts"
   },
   "license": "MIT",
@@ -12,23 +13,38 @@
     "name": "JoshuaKGoldberg",
     "email": "npm@joshuakgoldberg.com"
   },
+  "sideEffects": false,
   "type": "module",
-  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map"
+  ],
   "dependencies": {
-    "@flint.fyi/core": "",
-    "@flint.fyi/rule-tester": "",
-    "@typescript-eslint/project-service": "^8.46.2",
-    "@typescript/vfs": "^1.6.1",
-    "cached-factory": "^0.1.0",
-    "debug-for-file": "^0.2.0",
-    "ts-api-utils": "^2.1.0",
-    "typescript": ">=5.9.3"
+    "@eslint-community/regexpp": "^4.12.2",
+    "regexp-ast-analysis": "^0.7.1",
+    "scslre": "^0.3.0",
+    "ts-api-utils": "^2.4.0",
+    "typescript": "^5.9.3 || ^6.0.0",
+    "zod": "^4.3.6",
+    "@flint.fyi/core": "^0.21.0",
+    "@flint.fyi/utils": "^0.14.1",
+    "@flint.fyi/typescript-language": "^0.18.0"
+  },
+  "devDependencies": {
+    "tsdown": "0.21.0",
+    "vitest": "4.1.0",
+    "@flint.fyi/rule-tester": "^0.16.1"
   },
   "engines": {
     "node": ">=24.0.0"
   },
   "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest --project ts"
   }
 }