eslint-plugin-lube 0.6.0 → 0.7.0

package/src/rules/prefer-type-tag.js

@@ -0,0 +1,165 @@
+const const_regex = /@type\s*\{\s*const\s*\}/
+const directive_regex = /^\s*(?:eslint-disable-next-line\b|@ts-(?:expect-error|ignore)\b)/
+const line_terminator_regex = /\r\n|[\n\r\p{Zl}\p{Zp}]/u
+const space_regex = /^\s*$/
+const statement_lists = new Set(
+	[
+		"BlockStatement",
+		"Program",
+		"StaticBlock",
+		"SwitchCase",
+		"TSModuleBlock"
+	]
+)
+const type_regex = /^\*[^]*@type\s*\{[^]*\}/
+const typescript_file_regex = /\.[cm]?tsx?$/
+/** @type {import("eslint").Rule.RuleModule} */
+export default {
+	create(context) {
+		/** @type {import("../../private.js").TypeServices | undefined} */
+		const services = context.sourceCode.parserServices
+		const program = services?.program
+		if (!services || !program || typescript_file_regex.test(context.filename)) {
+			return {}
+		}
+		const checker = program.getTypeChecker()
+		const source_code = context.sourceCode
+		const text = source_code.text
+		/**
+		 * @param {number} position
+		 * @returns {number}
+		 */
+		function line_start_of(position) {
+			let start = position
+			while (start > 0 && !line_terminator_regex.test(text.charAt(start - 1))) {
+				start--
+			}
+			return start
+		}
+		/**
+		 * @param {import("estree").Comment} comment
+		 * @returns {boolean}
+		 */
+		function starts_line(comment) {
+			const start = /** @type {import("eslint").AST.Range} */(comment.range)/**/[0]
+			return space_regex.test(
+				text.slice(line_start_of(start), start)
+			)
+		}
+		return {
+			VariableDeclaration(node) {
+				const [ declarator, other ] = node.declarations
+				const value = declarator?.init
+				const statement = node.parent.type == "ExportNamedDeclaration" ? node.parent : node
+				if (!declarator || !value || other || !statement_lists.has(statement.parent.type)) {
+					return
+				}
+				const open = source_code.getTokenBefore(value)
+				const close = source_code.getTokenAfter(value)
+				const assign = open && source_code.getTokenBefore(open)
+				if (open?.value != "(" || close?.value != ")" || assign?.value != "=") {
+					return
+				}
+				const comment = source_code.getCommentsBefore(open).at(-1)
+				const comment_range = comment?.range
+				if (
+					!comment
+					|| !comment_range
+					|| comment.type != "Block"
+					|| !type_regex.test(comment.value)
+					|| const_regex.test(comment.value)
+					|| !space_regex.test(
+						text.slice(comment_range[1], open.range[0])
+					)
+				) {
+					return
+				}
+				const declaration = services.esTreeNodeToTSNodeMap.get(declarator)
+				const cast = /** @type {import("typescript").ParenthesizedExpression | undefined} */(declaration?.initializer)/**/
+				if (!cast?.expression) {
+					return
+				}
+				const leading = source_code.getCommentsBefore(statement)
+				const jsdoc = leading.filter(
+					item => item.type == "Block" && item.value.startsWith("*")
+				)
+				if (jsdoc.some(
+					item => type_regex.test(item.value)
+				)) {
+					return
+				}
+				const type = checker.getTypeAtLocation(cast)
+				const value_type = checker.getTypeAtLocation(cast.expression)
+				if (
+					!checker.isTypeAssignableTo(value_type, type)
+					|| type.isUnion() && !checker.isTypeAssignableTo(type, value_type)
+				) {
+					return
+				}
+				const tag = text.slice(
+					comment_range[0],
+					comment_range[1]
+				)
+				let start = /** @type {import("eslint").AST.Range} */(statement.range)/**/[0]
+				for (let i = leading.length - 1; i >= 0; i--) {
+					const item = /** @type {import("estree").Comment} */(leading[i])/**/
+					if (!starts_line(item) || !directive_regex.test(item.value)) {
+						break
+					}
+					start = /** @type {import("eslint").AST.Range} */(item.range)/**/[0]
+				}
+				const end = text.startsWith("/**/", close.range[1]) ? close.range[1] + 4 : close.range[1]
+				const data = {
+					tag,
+					value: checker.typeToString(value_type)
+				}
+				const loc = {
+					end: source_code.getLocFromIndex(end),
+					start: source_code.getLocFromIndex(comment_range[0])
+				}
+				if (jsdoc.length) {
+					context.report(
+						{ data, loc, messageId: "merge" }
+					)
+					return
+				}
+				const indent = text.slice(line_start_of(start), start)
+				const eol = text.match(line_terminator_regex)?.[0] ?? "\n"
+				const inner = text.slice(open.range[1], close.range[0])
+				context.report(
+					{
+						data,
+						fix(fixer) {
+							return [
+								fixer.insertTextBeforeRange(
+									[ start, start ],
+									space_regex.test(indent) ? tag + eol + indent : tag + " "
+								),
+								fixer.replaceTextRange(
+									[ comment_range[0], end ],
+									value.type == "SequenceExpression" ? `(${inner})` : inner
+								)
+							]
+						},
+						loc,
+						messageId: "tag"
+					}
+				)
+			}
+		}
+	},
+	meta: {
+		docs: {
+			description: "Enforces a JSDoc type tag on a declaration instead of a type cast of its value, wherever the value is assignable to the type.",
+			recommended: false,
+			url: "https://github.com/artxe/lube-series/blob/master/packages/eslint-plugin-lube/docs/prefer-type-tag.md"
+		},
+		fixable: "code",
+		messages: {
+			merge: "Type the declaration with `{{tag}}` instead of casting its value, since its type `{{value}}` is assignable to it; it is not fixed automatically because the declaration already has a JSDoc comment, so add the type to it by hand",
+			tag: "Write `{{tag}}` in front of the declaration instead of casting its value, since its type `{{value}}` is assignable to it"
+		},
+		schema: [],
+		type: "suggestion"
+	}
+}

package/src/rules/pretty-imports.js

@@ -45,12 +45,16 @@ export default {
 			)
 			const first = specifiers[0]
 			const last = specifiers[specifiers.length - 1]
-			if (first?.type != specifier_type || !last || source_code.getCommentsInside(node).length) return
+			if (first?.type != specifier_type || !last || source_code.getCommentsInside(node).length) {
+				return
+			}
 			const tokens = source_code.getTokens(node)
 			const open_index = tokens.findIndex(
 				token => token.range[0] == first.range[0]
 			) - 1
-			if (tokens[open_index]?.value != "{") return
+			if (tokens[open_index]?.value != "{") {
+				return
+			}
 			const head = tokens.slice(0, open_index)
 				.map(token => token.value)
 				.join(" ")
@@ -94,9 +98,13 @@ export default {
 					: `${head} ${names}`
 			) + tail + (keeps_semicolon ? ";" : "")
 			const current = get_text(node.range[0], end)
-			if (corrected_text == current) return
+			if (corrected_text == current) {
+				return
+			}
 			const same_structure = to_structure(current) == to_structure(corrected_text)
-			if (!fix_indent && same_structure) return
+			if (!fix_indent && same_structure) {
+				return
+			}
 			context.report(
 				{
 					data: {
@@ -127,18 +135,22 @@ export default {
 		/** @type {import("../../private.js").RuleListener} */
 		const listener = {
 			ExportNamedDeclaration: node => {
-				if (check_exports) verify(
+				if (check_exports) {
+					verify(
 					/** @type {import("../../private.js").AstNode & import("estree").ExportNamedDeclaration} */(node)/**/,
-					"ExportSpecifier",
-					"export"
-				)
+						"ExportSpecifier",
+						"export"
+					)
+				}
 			},
 			ImportDeclaration: node => {
-				if (check_imports) verify(
+				if (check_imports) {
+					verify(
 					/** @type {import("../../private.js").AstNode & import("estree").ImportDeclaration} */(node)/**/,
-					"ImportSpecifier",
-					"import"
-				)
+						"ImportSpecifier",
+						"import"
+					)
+				}
 			}
 		}
 		return /** @type {import("eslint").Rule.RuleListener} */(/** @type {unknown} */(listener))/**/

package/src/rules/pretty-jsdoc-casting.js

@@ -8,7 +8,9 @@ const marker_regex = /\/\*\*\//g
 /** @type {import("eslint").Rule.RuleModule} */
 export default {
 	create(context) {
-		if (typescript_file_regex.test(context.filename)) return {}
+		if (typescript_file_regex.test(context.filename)) {
+			return {}
+		}
 		const source_code = context.sourceCode
 		const source = create_source_text(source_code)
 		const text = source.text
@@ -35,9 +37,13 @@ export default {
 		 */
 		function is_arguments(position) {
 			const node = /** @type {import("../../private.js").AstNode | null} */(/** @type {unknown} */(source_code.getNodeByRangeIndex(position)))/**/
-			if (!node) return false
+			if (!node) {
+				return false
+			}
 			const type = node.type
-			if (type != "CallExpression" && type != "ImportExpression" && type != "NewExpression") return false
+			if (type != "CallExpression" && type != "ImportExpression" && type != "NewExpression") {
+				return false
+			}
 			const before = type == "ImportExpression"
 				? source_code.getFirstToken(
 					/** @type {import("estree").Node} */(node)/**/
@@ -57,7 +63,9 @@ export default {
 		 */
 		function push(node) {
 			const range = node.range[0] + " " + node.range[1]
-			if (node_ranges.has(range)) return
+			if (node_ranges.has(range)) {
+				return
+			}
 			node_ranges.add(range)
 			expressions.push(node)
 		}
@@ -71,17 +79,27 @@ export default {
 			let position = start
 			let result = ""
 			for (const [ removed_start, removed_end ] of removed) {
-				if (removed_end <= start || removed_start >= end) continue
-				if (source.crosses_edit(removed_start) || source.crosses_edit(removed_end)) return null
+				if (removed_end <= start || removed_start >= end) {
+					continue
+				}
+				if (source.crosses_edit(removed_start) || source.crosses_edit(removed_end)) {
+					return null
+				}
 				let chunk_end = removed_start
 				if (text[removed_start] == ")") {
-					while (chunk_end > position && is_space(text.charCodeAt(chunk_end - 1))) chunk_end--
-					if (source.comment_by_end.get(chunk_end)?.type == "Line") chunk_end = removed_start
+					while (chunk_end > position && is_space(text.charCodeAt(chunk_end - 1))) {
+						chunk_end--
+					}
+					if (source.comment_by_end.get(chunk_end)?.type == "Line") {
+						chunk_end = removed_start
+					}
 				}
 				result += source.render(position, chunk_end)
 				position = removed_end
 				if (text[removed_start] == "(") {
-					while (position < end && is_space(text.charCodeAt(position))) position++
+					while (position < end && is_space(text.charCodeAt(position))) {
+						position++
+					}
 				}
 			}
 			return result + source.render(position, end)
@@ -93,7 +111,9 @@ export default {
 		function verify(node) {
 			const node_start = node.range[0]
 			const before = source.skip_left(node_start, 0)
-			if (!before || text[before - 1] != "(" || is_arguments(before - 1)) return
+			if (!before || text[before - 1] != "(" || is_arguments(before - 1)) {
+				return
+			}
 			/** @type {import("../../private.js").CastingLevel[]} */
 			const levels = []
 			/** @type {[number, number][]} */
@@ -110,27 +130,39 @@ export default {
 						continue
 					}
 					const comment = source.comment_by_end.get(left)
-					if (!comment) break
+					if (!comment) {
+						break
+					}
 					const level = levels[levels.length - 1]
 					const type = comment.type == "Block" && type_regex.test(comment.value)
 						? get_type_comment(comment)
 						: void 0
 					if (type && level && level.type == null) {
 						let comment_end = comment.range[1]
-						while (comment_end < level.open && is_space(text.charCodeAt(comment_end))) comment_end++
+						while (comment_end < level.open && is_space(text.charCodeAt(comment_end))) {
+							comment_end++
+						}
 						level.type = type
 						removed.push(
 							[ comment.range[0], comment_end ]
 						)
-					} else if (type) has_inner_type_comment = true
+					} else if (type) {
+						has_inner_type_comment = true
+					}
 					left = comment.range[0]
 				}
-				if (!left || text[left - 1] != "(" || is_arguments(left - 1)) break
+				if (!left || text[left - 1] != "(" || is_arguments(left - 1)) {
+					break
+				}
 				const close = source.skip_right(right, text.length)
 				right = close
-				if (text[close] != ")") break
+				if (text[close] != ")") {
+					break
+				}
 				if (has_inner_type_comment) {
-					if (levels.length) return
+					if (levels.length) {
+						return
+					}
 					content_end = close
 					content_start = left
 					has_inner_type_comment = false
@@ -149,16 +181,21 @@ export default {
 			}
 			const outer = levels[levels.length - 1]
 			const first = levels[0]
-			if (!outer || !first) return
+			if (!outer || !first) {
+				return
+			}
 			const restores_outer = outer.type == null
 			for (const level of levels) {
-				if (level == outer && restores_outer) removed.push(
-					[ level.close + 1, level.close_end ]
-				)
-				else removed.push(
-					[ level.open, level.open + 1 ],
-					[ level.close, level.close_end ]
-				)
+				if (level == outer && restores_outer) {
+					removed.push(
+						[ level.close + 1, level.close_end ]
+					)
+				} else {
+					removed.push(
+						[ level.open, level.open + 1 ],
+						[ level.close, level.close_end ]
+					)
+				}
 			}
 			removed.sort((a, b) => a[0] - b[0])
 			if (content_end + 4 <= first.close && source.render(content_end, content_end + 4) == "/**/") {
@@ -171,12 +208,16 @@ export default {
 			if (unwrapped_outer) {
 				let type_comments = 0
 				for (const level of unwrapped) {
-					if (level != unwrapped_outer && level.type != null) type_comments++
+					if (level != unwrapped_outer && level.type != null) {
+						type_comments++
+					}
 				}
 				if (source.count_comments(
 					unwrapped_outer.open,
 					content_start
-				) > type_comments) return
+				) > type_comments) {
+					return
+				}
 			}
 			const boundaries = [
 				left,
@@ -184,7 +225,9 @@ export default {
 				content_end,
 				right
 			]
-			if (boundaries.some(source.crosses_edit)) return
+			if (boundaries.some(source.crosses_edit)) {
+				return
+			}
 			let corrected_text = source.render(content_start, content_end)
 			for (const [ index, level ] of unwrapped.entries()) {
 				corrected_text = level.type
@@ -202,10 +245,14 @@ export default {
 					&& restricted_regex.test(
 						text.slice(Math.max(0, left - 7), left)
 					)
-			) return
+			) {
+				return
+			}
 			corrected_text = prefix + corrected_text + suffix
 			const current = source.render(left, right)
-			if (current == corrected_text) return
+			if (current == corrected_text) {
+				return
+			}
 			const message_id = current.replace(marker_regex, "") == corrected_text.replace(marker_regex, "")
 				? "marker"
 				: "format"