eslint-plugin-lube 0.3.5 → 0.4.0

package/rules/svelte-naming-convention.js

@@ -11,21 +11,20 @@ module.exports = {
 		messages: {
 			not_match: "Identifier '{{name}}' does not match for svelte's naming conventions."
 		},
-		schema: [
+		schema: [
 			{
 				properties: {
-					fixSameNames: {
-						type: "boolean",
-						default: true
-					}
+					fixSameNames: { type: "boolean", default: true }
 				},
 				type: "object"
-			}
+			}
 		],
 		type: "layout"
 	},
 	create(context) {
-		const fix_same_names = /** @type {boolean} */(context.options[0]?.fixSameNames)/**/ ?? true
+		/** @type {import("../private").RuleOptions["svelte-naming-convention"]} */
+		const option = context.options[0]
+		const fix_same_names = option?.fixSameNames ?? true
 
 		// let name | const name | class name
 		const allow_regex = /^[_$]?[_$]?(?:[\da-z]+(?:_[\da-z]+)*\$?\$?)?$|^[A-Z](?:_?[\dA-Z]+)*$|^(?:[\dA-Z][\da-z]*)+$/
@@ -33,10 +32,10 @@ module.exports = {
 		const fix_regex = /([\da-z]?)([A-Z][\dA-Z]*)/g
 		const camel_case_regex = /^[\da-z]+([A-Z][\da-z]*)*$/
 
-		/** @type {Set<string>} */
-		const reported_declarations = new Set()
 		/** @type {Map<string, import("../private").AstNode[]>} */
 		const pending_usages = new Map()
+		/** @type {Set<string>} */
+		const reported_declarations = new Set()
 		/** @type {Set<import("../private").AstNode>} */
 		const shortand_properties = new Set()
 
@@ -58,42 +57,44 @@ module.exports = {
 				}
 			}
 		}
-
 		/**
 		 * @param {string} _
 		 * @param {string} a
 		 * @param {string} b
 		 * @returns {string}
 		 */
-		function fix_callback(_, a, b) {
+		function fix_handler(_, a, b) {
 			return a + (a ? "_" : "") + b.toLowerCase()
 		}
-
 		/**
 		 * @param {import("../private").AstNode & import("estree").Identifier} node
 		 * @returns {void}
 		 */
 		function report(node) {
 			const name = node.name
-			context.report({
-				data: { name },
-				fix(fixer) {
-					if (fixable_name_regex.test(name)) {
-						return fixer.replaceTextRange(
-							node.range,
-							(shortand_properties.has(node) ? node.name + ": " : "")
-								+ node.name.replace(fix_regex, fix_callback)
-						)
-					}
-					return null
-				},
-				messageId: "not_match",
-				node: /** @type {import("estree").Node} */(node)/**/
-			})
+			context.report(
+				{
+					data: { name },
+					fix(fixer) {
+						if (fixable_name_regex.test(name)) {
+							return fixer.replaceTextRange(
+								node.range,
+								(shortand_properties.has(node) ? node.name + ": " : "")
+									+ node.name.replace(fix_regex, fix_handler)
+							)
+						}
+						return null
+					},
+					messageId: "not_match",
+					node: /** @type {import("estree").Node} */(node)/**/
+				}
+			)
 			if (fix_same_names) {
 				const usages = pending_usages.get(name)
 				while (usages?.length) {
-					report(/** @type {import("../private").AstNode & import("estree").Identifier} */(usages.pop())/**/)
+					report(
+						/** @type {import("../private").AstNode & import("estree").Identifier} */(usages.pop())/**/
+					)
 				}
 				reported_declarations.add(name)
 			}
@@ -264,7 +265,10 @@ module.exports = {
 					// var value = { key: value }
 					// var { key: value } = value
 					if (parent.value == node) {
-						if (parent.key.name == parent.value.name) {
+						if (
+							parent.key.type == "Identifier"
+							&& parent.key.name == parent.value.name
+						) {
 							shortand_properties.add(node)
 						}
 						defer(node)

package/test/pretty-imports/ExportNamedDeclaration.js

@@ -10,7 +10,7 @@ exports.module = (valid, invalid) => {
 			export { a, b as c, d } from 'module'
 			export { fff, ggg, hhh, iii, jjj, kkk, lll } from 'module/2'
 			`,
-			options: [{ maxLength: 30 }],
+			options: [ { maxLength: 30 } ],
 			parserOptions: {
 				ecmaVersion: "latest",
 				sourceType: "module"
@@ -21,7 +21,7 @@ exports.module = (valid, invalid) => {
 			var a, b, c
 			export { a, b, c };
 			`,
-			options: [{ semicolon: true }],
+			options: [ { semicolon: true } ],
 			parserOptions: {
 				ecmaVersion: "latest",
 				sourceType: "module"
@@ -49,11 +49,8 @@ exports.module = (valid, invalid) => {
 					column: 7
 				}
 			],
-			options: [
-				{
-					maxLength: 10,
-					semicolon: true
-				}
+			options: [
+				{ maxLength: 10, semicolon: true }
 			],
 			output: `
 
@@ -93,11 +90,8 @@ exports.module = (valid, invalid) => {
 					column: 7
 				}
 			],
-			options: [
-				{
-					indent: "  ",
-					maxLength: 10
-				}
+			options: [
+				{ indent: "  ", maxLength: 10 }
 			],
 			output: `
 

package/test/pretty-imports/ImportDeclaration.js

@@ -10,7 +10,7 @@ exports.module = (valid, invalid) => {
 			import { a, b as c, d } from 'module'
 			import { fff, ggg, hhh, iii, jjj, kkk, lll } from 'module/2'
 			`,
-			options: [{ maxLength: 30 }],
+			options: [ { maxLength: 30 } ],
 			parserOptions: {
 				ecmaVersion: "latest",
 				sourceType: "module"
@@ -23,7 +23,7 @@ import {
 	aaaaa_ccccc,
 	aaaaa_ddddd
 } from "module";`,
-			options: [{ semicolon: true }],
+			options: [ { semicolon: true } ],
 			parserOptions: {
 				ecmaVersion: "latest",
 				sourceType: "module"
@@ -51,11 +51,8 @@ import {
 					column: 7
 				}
 			],
-			options: [
-				{
-					maxLength: 10,
-					semicolon: true
-				}
+			options: [
+				{ maxLength: 10, semicolon: true }
 			],
 			output: `
 
@@ -95,11 +92,8 @@ import {
 					column: 7
 				}
 			],
-			options: [
-				{
-					indent: "  ",
-					maxLength: 10
-				}
+			options: [
+				{ indent: "  ", maxLength: 10 }
 			],
 			output: `
 

package/test/pretty-imports.js

@@ -6,14 +6,15 @@ const valid = []
 /** @type {RuleTester.InvalidTestCase[]} */
 const invalid = []
 
-require("./pretty-imports/ExportNamedDeclaration").module(valid, invalid)
-require("./pretty-imports/ImportDeclaration").module(valid, invalid)
+require(
+	"./pretty-imports/ExportNamedDeclaration"
+).module(valid, invalid)
+require(
+	"./pretty-imports/ImportDeclaration"
+).module(valid, invalid)
 
 new RuleTester().run(
 	"pretty-imports",
 	require("../rules/pretty-imports"),
-	{
-		valid,
-		invalid
-	}
+	{ valid, invalid }
 )

package/test/pretty-jsdoc-casting/case_by_expression.js

@@ -14,31 +14,11 @@ const test_case = (type, value) => ({
 	var value = ((/** @type {E} */(${value})))
 	`,
 	errors: [
-		{
-			line: 2,
-			column: 13,
-			type
-		},
-		{
-			line: 3,
-			column: 13,
-			type
-		},
-		{
-			line: 4,
-			column: 13,
-			type
-		},
-		{
-			line: 7,
-			column: 13,
-			type
-		},
-		{
-			line: 8,
-			column: 13,
-			type
-		}
+		{ line: 2, column: 13, type },
+		{ line: 3, column: 13, type },
+		{ line: 4, column: 13, type },
+		{ line: 7, column: 13, type },
+		{ line: 8, column: 13, type }
 	],
 	output: `
 	var value = /** @type {A} */(${value})/**/
@@ -59,7 +39,10 @@ const test_case = (type, value) => ({
 exports.module = (valid, invalid) => {
 	invalid.push(
 		test_case("ArrayExpression", "[a, b, c]"),
-		test_case("ArrowFunctionExpression", "(a, b) => c"),
+		test_case(
+			"ArrowFunctionExpression",
+			"(a, b) => c"
+		),
 		test_case("AssignmentExpression", "a = b"),
 		{
 			code: `
@@ -116,11 +99,23 @@ exports.module = (valid, invalid) => {
 		test_case("BinaryExpression", "a / b"),
 		test_case("CallExpression", "a(b, c)"),
 		test_case("ChainExpression", "a?.b?.c"),
-		test_case("ClassExpression", "class { b = c }"),
-		test_case("ConditionalExpression", "a ? b : c"),
-		test_case("FunctionExpression", "function(a, b) { return c }"),
+		test_case(
+			"ClassExpression",
+			"class { b = c }"
+		),
+		test_case(
+			"ConditionalExpression",
+			"a ? b : c"
+		),
+		test_case(
+			"FunctionExpression",
+			"function(a, b) { return c }"
+		),
 		test_case("Identifier", "a"),
-		test_case("ImportExpression", "import('a')"),
+		test_case(
+			"ImportExpression",
+			"import('a')"
+		),
 		test_case("Literal", "'a'"),
 		test_case("LogicalExpression", "a ?? b"),
 		test_case("MemberExpression", "a.b"),
@@ -177,9 +172,15 @@ exports.module = (valid, invalid) => {
 			parserOptions: { ecmaVersion: "latest" }
 		},
 		test_case("NewExpression", "new a(b, c)"),
-		test_case("ObjectExpression", "{ a: b, c }"),
+		test_case(
+			"ObjectExpression",
+			"{ a: b, c }"
+		),
 		test_case("SequenceExpression", "a, b, c"),
-		test_case("TaggedTemplateExpression", "a`b${c}`"),
+		test_case(
+			"TaggedTemplateExpression",
+			"a`b${c}`"
+		),
 		test_case("TemplateLiteral", "`a${b}c`"),
 		test_case("ThisExpression", "this"),
 		test_case("UnaryExpression", "!a"),

package/test/pretty-jsdoc-casting/{nested_casting.js → various_situations.js}

@@ -9,9 +9,7 @@ exports.module = (valid, invalid) => {
 				a
 			)`
 		},
-		{
-			code: "a((b - c) / d)"
-		},
+		{ code: "a((b - c) / d)" },
 		{
 			code: "var v = /** @type {{}} */(a)/**/"
 		},
@@ -45,42 +43,22 @@ exports.module = (valid, invalid) => {
 	invalid.push(
 		{
 			code: "var v = /**@type {A}*/(a)/**/",
-			errors: [
-				{
-					column: 8,
-					line: 1
-				}
-			],
+			errors: [ { column: 8, line: 1 } ],
 			output: "var v = /** @type {A} */(a)/**/"
 		},
 		{
 			code: "var v = /** @type {A} */(  /** @type {B} */(/** @type {C} */((a) /* block... */))) // line...",
-			errors: [
-				{
-					column: 8,
-					line: 1
-				}
-			],
+			errors: [ { column: 8, line: 1 } ],
 			output: "var v =   /** @type {A} */(/** @type {B} */(/** @type {C} */((a))/**/)/**/)/**/ /* block... */ // line..."
 		},
 		{
 			code: "var v = { b: /** @type {A} */(a) }",
-			errors: [
-				{
-					column: 13,
-					line: 1
-				}
-			],
+			errors: [ { column: 13, line: 1 } ],
 			output: "var v = { b: /** @type {A} */(a)/**/ }"
 		},
 		{
 			code: "var v = { b: /** @type {A} */(a) }",
-			errors: [
-				{
-					column: 13,
-					line: 1
-				}
-			],
+			errors: [ { column: 13, line: 1 } ],
 			output: "var v = { b: /** @type {A} */(a)/**/ }"
 		},
 		{
@@ -95,7 +73,7 @@ exports.module = (valid, invalid) => {
 				.../** @type {X} */(x)
 			});
 			/** @type {Y} */(y, /** @type {Z} */(z[/** @type {123} */(123)]))`,
-			errors: [...new Array(21).fill({})],
+			errors: [ ...new Array(21).fill({}) ],
 			output: `var v = /** @type {V} */({
 				a: /** @type {A} */([/** @type {B} */(b)/**/, /** @type {C} */(c)/**/, /** @type {D} */(d)/**/])/**/,
 				e: /** @type {F} */(f)/**/(/** @type {G} */(g)/**/, /** @type {E} */(E)/**/, /** @type {I} */(i)/**/),

package/test/pretty-jsdoc-casting.js

@@ -6,14 +6,17 @@ const valid = []
 /** @type {RuleTester.InvalidTestCase[]} */
 const invalid = []
 
-require("./pretty-jsdoc-casting/case_by_expression").module(valid, invalid)
-require("./pretty-jsdoc-casting/nested_casting").module(valid, invalid)
+require(
+	"./pretty-jsdoc-casting/case_by_expression"
+).module(valid, invalid)
+require(
+	"./pretty-jsdoc-casting/various_situations"
+).module(valid, invalid)
 
 new RuleTester().run(
 	"pretty-jsdoc-casting",
-	require("../rules/pretty-jsdoc-casting"),
-	{
-		valid,
-		invalid
-	}
+	require(
+		"../rules/pretty-jsdoc-casting"
+	),
+	{ valid, invalid }
 )