@cookshack/eslint-config 3.0.0 → 5.0.0

package/plugins/narrowest-scope.js

@@ -121,7 +121,8 @@ function getConditionalContext
   return ''
 }
 
-function nodeContains(node, target) {
+function nodeContains
+(node, target) {
   if (node == target)
     return true
   if (node && typeof node == 'object')
@@ -131,7 +132,8 @@ function nodeContains(node, target) {
   return false
 }
 
-function nodeHas(value, target) {
+function nodeHas
+(value, target) {
   if (value == target)
     return true
   if (Array.isArray(value))
@@ -234,7 +236,8 @@ function isProperAncestor
   return 0
 }
 
-function scopeStart(scope) {
+function scopeStart
+(scope) {
   if (scope.block == null)
     return Infinity
   if (scope.type == 'function' && scope.block.id)
@@ -264,12 +267,11 @@ function buildScopeTree
 (scope, prefix, scopeToNode, astToTree) {
   let node, siblingNum
 
-  node = {
-    scope,
-    prefix,
-    items: [],
-    children: []
-  }
+  node = { scope,
+           prefix,
+           items: [],
+           children: [] }
+
   scopeToNode.set(scope, node)
   if (scope.block && astToTree)
     astToTree.set(scope.block, node)
@@ -402,11 +404,9 @@ function checkScopeNode
         trace(indent, '5', variable.name, 'is too broad')
 
         reported.add(variable)
-        context.report({
-          node: defNode,
-          messageId: 'tooBroad',
-          data: { name: variable.name }
-        })
+        context.report({ node: defNode,
+                         messageId: 'tooBroad',
+                         data: { name: variable.name } })
       }
     }
   }
@@ -452,17 +452,16 @@ function createNarrowestScope
   clearPrintBuffer()
   scopeManager = context.sourceCode.scopeManager
   if (scopeManager)
-    return {
-      'Program:exit'() {
-        let tree, scopeToNode
-
-        scopeToNode = new Map
-        nextVarId = 0
-        tree = buildScopeTree(scopeManager.scopes[0], '1', scopeToNode)
-        checkScopeNode(context, tree, null, scopeToNode)
-        printTree(tree, 0)
-      }
-    }
+    return { 'Program:exit'
+             () {
+               let tree, scopeToNode
+
+               scopeToNode = new Map
+               nextVarId = 0
+               tree = buildScopeTree(scopeManager.scopes[0], '1', scopeToNode)
+               checkScopeNode(context, tree, null, scopeToNode)
+               printTree(tree, 0)
+             } }
 }
 
 export

package/plugins/positive-vibes.js

@@ -1,20 +1,20 @@
 function createPositiveVibes
 (context) {
-  return {
-    UnaryExpression(node) {
-      if (node.operator == '!')
-        context.report({ node,
-                         messageId: 'positiveVibes' })
-    },
-    BinaryExpression(node) {
-      if (node.operator == '!=')
-        context.report({ node,
-                         messageId: 'equality' })
-      else if (node.operator == '!==')
-        context.report({ node,
-                         messageId: 'strictEquality' })
-    }
-  }
+  return { UnaryExpression
+           (node) {
+             if (node.operator == '!')
+               context.report({ node,
+                                messageId: 'positiveVibes' })
+           },
+           BinaryExpression
+           (node) {
+             if (node.operator == '!=')
+               context.report({ node,
+                                messageId: 'equality' })
+             else if (node.operator == '!==')
+               context.report({ node,
+                                messageId: 'strictEquality' })
+           } }
 }
 
 export

package/plugins/use-risky-equal.js

@@ -3,9 +3,11 @@ default { meta: { type: 'problem',
                   docs: { description: 'Enforce use of == instead of ===.' },
                   messages: { risky: 'Use ==.' },
                   schema: [] },
-          create(context) {
-            return { BinaryExpression(node) {
-              if (node.operator == '===')
-                context.report({ node, messageId: 'risky' })
-            } }
+          create
+          (context) {
+            return { BinaryExpression
+                     (node) {
+                       if (node.operator == '===')
+                         context.report({ node, messageId: 'risky' })
+                     } }
           } }

package/plugins/var-decl-block-start.js

@@ -1,5 +1,4 @@
-function
-VariableDeclaration
+function VariableDeclaration
 (context, node) {
   let parent
 
@@ -24,6 +23,7 @@ VariableDeclaration
     }
   }
 }
+
 function create
 (context) {
   return { VariableDeclaration: node => VariableDeclaration(context, node) }

package/test/rules/fn-args-nl.js

@@ -0,0 +1,114 @@
+import { RuleTester } from 'eslint'
+import { plugins } from '../../index.js'
+
+let ruleTester, validCases, invalidCases
+
+ruleTester = new RuleTester()
+validCases = []
+invalidCases = []
+
+function pass
+(code) {
+  validCases.push({ code })
+}
+
+function fail
+(count, code) {
+  let errors
+
+  errors = []
+  while (count > 0) {
+    errors.push({ messageId: 'fnArgsNl' })
+    count--
+  }
+  invalidCases.push({ code, errors })
+}
+
+pass(`function f
+(arg) {
+}`)
+
+pass(`function f
+() {}`)
+
+pass(`function f
+(arg1, arg2) {}`)
+
+pass(`function f
+(
+  arg
+) {}`)
+
+pass(`export default
+function
+() {
+  return 1
+}
+`)
+
+pass(`
+function f
+() {
+  return { f1
+           () {
+             return 1
+           } }
+}
+`)
+
+pass(`
+function f
+() {
+  return {
+    f1
+    () {
+      return 1
+    }
+  }
+}
+`)
+
+pass(`
+  class Marker {
+    constructor
+    (name, num) {
+    }
+    toDOM
+    () {
+    }
+  }
+`)
+
+pass(`
+  area = { get name
+           () {
+             return name
+           },
+           get value
+           () {
+             return value
+           } }
+`)
+
+fail(1, 'function f (arg) {}')
+
+fail(1, 'function f() {}')
+
+fail(1, `function f (arg,
+                     arg2) {
+}`)
+
+fail(1, `function f
+
+(arg) {}`)
+
+fail(1, `function f
+
+
+(arg) {}`)
+
+globalThis.describe('fn-args-nl',
+                    () => ruleTester.run('fn-args-nl',
+                                         plugins.cookshack.rules['fn-args-nl'],
+                                         { valid: validCases,
+                                           invalid: invalidCases }))

package/test/rules/indent-struct.js

@@ -0,0 +1,198 @@
+import { RuleTester } from 'eslint'
+import { plugins } from '../../index.js'
+
+let ruleTester, validCases, invalidCases
+
+ruleTester = new RuleTester()
+validCases = []
+invalidCases = []
+
+function pass
+(code) {
+  validCases.push({ code })
+}
+
+function fail
+(count, code) {
+  let errors
+
+  if (code == undefined) {
+    code = count
+    count = 1
+  }
+  errors = []
+  while (count > 0) {
+    errors.push({ messageId: 'indentStruct' })
+    count--
+  }
+  invalidCases.push({ code, errors })
+}
+
+pass('let x = { a: 1, b: 2 }')
+
+pass(`
+let x = {
+          a: 1,
+          b: 2
+        }`)
+
+pass(`
+let x = { a: 1,
+          b: 2 }`)
+
+pass(`
+let x = {
+          a
+          () {}
+        }`)
+
+pass(`
+let x = {
+          a
+          () {},
+          b
+          () {}
+        }`)
+
+pass(`
+function f
+() {
+  return { a: 1,
+           b: 2 }
+}`)
+
+pass(`
+function f1
+() {
+  return { f1
+           () {
+             return 1
+           },
+           b: 2 }
+}`)
+
+pass(`
+function f2
+() {
+  return { a: 1,
+           f2
+           () {
+             return 2
+           } }
+}`)
+
+pass(`
+let x = { a: 1,
+          b: 2 }  
+`)
+
+pass(`
+let x = { a: 1,
+          b: 2 } /*stuff  {, } */
+`)
+
+pass(`
+let x = { a: 1,
+          b: 2 }   /*stuff*/
+`)
+
+pass(`
+let x = { a: { a: 1,
+               b: 2 } }
+`)
+
+pass(`
+let x = { a: { a: 1,
+               b: 2 } }   ; function f(){ return 1}
+`)
+
+pass(`function create
+(context) {
+  return { VariableDeclaration
+           (node) {
+             if (node.kind == 'const' || node.kind == 'var')
+               context.report({ node, messageId: 'useLet' })
+           } }
+}`)
+
+pass(`function two
+() {
+  return { 'Program:exit'
+           () {
+             // do
+           } }
+}`)
+
+pass(`
+let x = { get a
+          () {
+            return 1
+          },
+          get b
+          () {
+            return 2
+          } }`)
+
+pass(`
+let x = { async f
+          () {
+            return 1
+          },
+          async g
+          () {
+            return 2
+          } }`)
+
+fail(2, `
+let x = {
+  a: 1,
+  b: 2
+}`)
+
+fail(1, `
+let x = {
+          a: 1,
+           b: 2
+        }`)
+
+fail(1, `
+let x = { a: 1,
+         b: 2 }`)
+
+fail(1, `
+let x = { a: 1,
+  b: 2 }`)
+
+fail(1, `
+let x = { a: 1,
+b: 2 }`)
+
+fail(2, `
+let x = { a: 1,
+  b: 2,
+  c: 3 }`)
+
+fail(1, `
+let aHasArgsOnNextLine = { a
+  () {} }`)
+
+fail(1, `
+let x = { a: 1,
+          b: 2}
+`)
+
+fail(1, `
+let x = { a: 1,
+          b: 2  }
+`)
+
+fail(1, `
+let x = { a: { a: 1,
+               b: 2  } }
+`)
+
+globalThis.describe('indent-struct',
+                    () => ruleTester.run('indent-struct',
+                                         plugins.cookshack.rules['indent-struct'],
+                                         { valid: validCases,
+                                           invalid: invalidCases }))

package/test/rules/init-before-use.js

@@ -23,7 +23,8 @@ function tree
   return ''
 }
 
-function _pass(tc) {
+function _pass
+(tc) {
   let messages
 
   messages = linter.verify(tc.code, config)
@@ -31,7 +32,8 @@ function _pass(tc) {
     throw new Error('unexpected errors: ' + JSON.stringify(messages, null, 2) + '\n' + tree())
 }
 
-function _fail(tc) {
+function _fail
+(tc) {
   let messages
 
   messages = linter.verify(tc.code, config)
@@ -40,7 +42,8 @@ function _fail(tc) {
   throw new Error('expected ' + tc.errors.length + ' errors, got ' + messages.length + '\n' + JSON.stringify(messages, null, 2) + '\n' + tree())
 }
 
-function fail(message, code) {
+function fail
+(message, code) {
   let errors
 
   if (Array.isArray(message))
@@ -51,7 +54,8 @@ function fail(message, code) {
   invalidCases.push({ code, errors })
 }
 
-function pass(code) {
+function pass
+(code) {
   validCases.push({ code })
 }
 

package/test/rules/narrowest-scope.js

@@ -13,16 +13,19 @@ config = [ { languageOptions: { ecmaVersion: 2025,
              plugins,
              rules: { 'cookshack/narrowest-scope': 'error' } } ]
 
-function pass(code, expected) {
+function pass
+(code, expected) {
   validCases.push({ code, expected })
 }
 
-function patch(expected, output) {
+function patch
+(expected, output) {
   return diffLines(expected.trim(), output.trim()).flatMap(p => p.value.split('\n').filter(l => l).map(l => ({ ...p, line: l })))
     .map(p => (p.removed ? '- ' : p.added ? '+ ' : '  ') + p.line).join('\n')
 }
 
-function _pass(tc) {
+function _pass
+(tc) {
   let messages, output
 
   messages = linter.verify(tc.code, config)
@@ -34,7 +37,8 @@ function _pass(tc) {
   throw new Error('output mismatch:\n' + patch(tc.expected, output))
 }
 
-function _fail(tc) {
+function _fail
+(tc) {
   let messages, output
 
   messages = linter.verify(tc.code, config)
@@ -47,7 +51,8 @@ function _fail(tc) {
   throw new Error('expected ' + tc.errors.length + ' errors, got ' + messages.length + '\n' + JSON.stringify(messages, null, 2))
 }
 
-function fail(count, code, expected) {
+function fail
+(count, code, expected) {
   let errors
 
   errors = []

package/test/rules/no-shadow.js

@@ -0,0 +1,42 @@
+import { RuleTester } from 'eslint'
+import { Linter } from 'eslint'
+
+let ruleTester, validCases, invalidCases, rule
+
+rule = new Linter({ configType: 'eslintrc' }).getRules().get('no-shadow')
+ruleTester = new RuleTester()
+validCases = []
+invalidCases = []
+
+function pass
+(code) {
+  validCases.push({ code, options: [ { builtinGlobals: true } ] })
+}
+
+function fail
+(messageId, code) {
+  invalidCases.push({ code,
+                      options: [ { builtinGlobals: true } ],
+                      errors: [ { messageId } ] })
+}
+
+pass('var a = 3; function b() { var c = 10; }')
+pass('let x = 1; { let y = 2; }')
+pass('function a() { let x = 1 } function b() { let x = 2 }')
+pass('var a = 1; if (x) { var a = 2; }')
+
+fail('noShadow', 'var a = 3; function b() { var a = 10; }')
+fail('noShadow', 'let x = 1; { let x = 2; }')
+fail('noShadow', 'let a = 1; function foo(a) { return a }')
+fail('noShadow', 'function f(x) { function g() { let x = 2; } }')
+fail('noShadow', 'const a = 1; function foo() { const a = 2; }')
+fail('noShadow', 'let a = 1; if (x) { let a = 2; }')
+
+fail('noShadowGlobal', 'function foo() { let Object = 1; }')
+fail('noShadowGlobal', 'function foo() { let Array = []; }')
+
+globalThis.describe('no-shadow',
+                    () => ruleTester.run('no-shadow',
+                                         rule,
+                                         { valid: validCases,
+                                           invalid: invalidCases }))