@cookshack/eslint-config 3.0.0 → 5.0.0

package/dist/index.cjs

@@ -15,7 +15,7 @@ function print
   printBuffer.push(args.join(' '));
 }
 
-function trace$1
+function trace$2
 (...args) {
 }
 
@@ -124,7 +124,8 @@ function getConditionalContext
   return ''
 }
 
-function nodeContains(node, target) {
+function nodeContains
+(node, target) {
   if (node == target)
     return true
   if (node && typeof node == 'object')
@@ -134,7 +135,8 @@ function nodeContains(node, target) {
   return false
 }
 
-function nodeHas(value, target) {
+function nodeHas
+(value, target) {
   if (value == target)
     return true
   if (Array.isArray(value))
@@ -198,7 +200,8 @@ function mayBeReadBeforeAnyWrite
   }
 }
 
-function scopeStart(scope) {
+function scopeStart
+(scope) {
   if (scope.block == null)
     return Infinity
   if (scope.type == 'function' && scope.block.id)
@@ -226,12 +229,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);
@@ -333,38 +335,36 @@ function checkScopeNode
 
       defScope = getDefinitionScope(variable);
       defNodePrefix = scopeToNode.get(defScope)?.prefix ?? '?';
-      trace$1(indent, '1 found decl scope of', variable.name + ':', defNodePrefix + ' ' + defScope.type.toUpperCase());
+      trace$2(indent, '1 found decl scope of', variable.name + ':', defNodePrefix + ' ' + defScope.type.toUpperCase());
 
       narrowestScope = getNarrowestScope(variable);
       if (narrowestScope) {
         let narrowestPrefix;
 
         narrowestPrefix = scopeToNode.get(narrowestScope)?.prefix ?? '?';
-        trace$1(indent, '2 found narrowest scope of', variable.name + ':', narrowestPrefix + ' ' + narrowestScope?.type.toUpperCase());
+        trace$2(indent, '2 found narrowest scope of', variable.name + ':', narrowestPrefix + ' ' + narrowestScope?.type.toUpperCase());
 
         markConditionalRefs(variable, scopeToNode, narrowestScope);
 
         if (defScope == narrowestScope)
           continue
-        trace$1(indent, '3', variable.name, 'could be moved to a narrower scope');
+        trace$2(indent, '3', variable.name, 'could be moved to a narrower scope');
 
         if (defScope.type == 'for') {
-          trace$1(indent, '4 exception:', variable.name, 'is in a for loop header');
+          trace$2(indent, '4 exception:', variable.name, 'is in a for loop header');
           continue
         }
         if (mayBeReadBeforeAnyWrite(variable, scopeToNode, narrowestScope)) {
-          trace$1(indent, '4 exception:', variable.name, 'mayBeReadBeforeAnyWrite');
+          trace$2(indent, '4 exception:', variable.name, 'mayBeReadBeforeAnyWrite');
           continue
         }
 
-        trace$1(indent, '5', variable.name, 'is too broad');
+        trace$2(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 } });
       }
     }
   }
@@ -409,17 +409,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);
+             } }
 }
 
 var narrowestScopePlugin = { meta: { type: 'suggestion',
@@ -430,21 +429,21 @@ var narrowestScopePlugin = { meta: { type: 'suggestion',
 
 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' });
+           } }
 }
 
 var positiveVibesPlugin = { meta: { type: 'problem',
@@ -459,57 +458,60 @@ var useRiskyEqualPlugin = { 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' });
+                     } }
           } };
 
-function create$2
+function create$4
 (context) {
-  return { VariableDeclaration(node) {
-    if (node.kind == 'const' || node.kind == 'var')
-      context.report({ node, messageId: 'useLet' });
-  } }
+  return { VariableDeclaration
+           (node) {
+             if (node.kind == 'const' || node.kind == 'var')
+               context.report({ node, messageId: 'useLet' });
+           } }
 }
 
 var alwaysLetPlugin = { meta: { type: 'problem',
                   docs: { description: 'Enforce use of let instead of const or var.' },
                   messages: { useLet: 'Use let.' },
                   schema: [] },
-          create: create$2 };
+          create: create$4 };
 
-let ostIdCounter, ost;
+let ostIdCounter, $lastOst;
 
 ostIdCounter = 0;
-ost = 0;
+$lastOst = 0;
 
-function trace
+function trace$1
 (...args) {
 }
 
-function createInitBeforeUse(context) {
+function createInitBeforeUse
+(context) {
   let scopeManager;
 
   scopeManager = context.sourceCode.scopeManager;
   if (scopeManager)
-    return {
-      'Program:exit'() {
-        let scopeToNode, astToTree, astToOst;
-        scopeToNode = new Map;
-        astToTree = new Map;
-        astToOst = new Map;
-        buildScopeTree(scopeManager.scopes[0], '1', scopeToNode, astToTree);
+    return { 'Program:exit'
+             () {
+               let scopeToNode, astToTree, astToOst;
+               scopeToNode = new Map;
+               astToTree = new Map;
+               astToOst = new Map;
+               buildScopeTree(scopeManager.scopes[0], '1', scopeToNode, astToTree);
 
-        ostIdCounter = 0;
-        ost = processAst(context.sourceCode.ast, null, astToTree, astToOst, '', new Set());
+               ostIdCounter = 0;
+               $lastOst = processAst(context.sourceCode.ast, null, astToTree, astToOst, '', new Set());
 
-        ostAnnotate(ost, astToOst, context);
+               ostAnnotate($lastOst, astToOst, context);
 
-        ostCheck(ost, context);
-      }
-    }
+               ostCheck($lastOst, context);
+             } }
 }
 
 function isRegularDeclaration
@@ -522,7 +524,8 @@ function isRegularDeclaration
   return 0
 }
 
-function processAst(astNode, parentOst, astToTree, astToOst, indent, visited) {
+function processAst
+(astNode, parentOst, astToTree, astToOst, indent, visited) {
   if (astNode) {
     let treeNode, scopeName, lets, reads, writes, ost, children;
 
@@ -535,7 +538,7 @@ function processAst(astNode, parentOst, astToTree, astToOst, indent, visited) {
     scopeName = treeNode?.scope ? `${treeNode.scope.type}` : 'no-scope';
     if (treeNode?.scope?.block?.id?.name)
       scopeName += `(${treeNode.scope.block.id.name})`;
-    trace(`${indent}${astNode.type}`);
+    trace$1(`${indent}${astNode.type}`);
 
     lets = [];
     reads = [];
@@ -548,31 +551,29 @@ function processAst(astNode, parentOst, astToTree, astToOst, indent, visited) {
         scopeCreator = treeNode?.scope?.block;
         if (scopeCreator && astNode == scopeCreator) {
           lets.push({ item });
-          trace(`${indent}  | LET ${item.name}:${item.varId}`);
+          trace$1(`${indent}  | LET ${item.name}:${item.varId}`);
         }
       }
       else if (item.ref)
         if (astNode == item.ref.identifier)
           if (item.type == 'READ') {
             reads.push({ item });
-            trace(`${indent}  | READ ${item.name}:${item.varId}`);
+            trace$1(`${indent}  | READ ${item.name}:${item.varId}`);
           }
           else if (item.type == 'WRITE') {
             writes.push({ item });
-            trace(`${indent}  | WRITE ${item.name}:${item.varId}`);
+            trace$1(`${indent}  | WRITE ${item.name}:${item.varId}`);
           }
 
-    ost = {
-      id: ostIdCounter++,
-      astNode,
-      treeNode,
-      scopeItems: treeNode?.items ?? [],
-      lets,
-      reads,
-      writes,
-      children: [],
-      fnDefOst: null
-    };
+    ost = { id: ostIdCounter++,
+            astNode,
+            treeNode,
+            scopeItems: treeNode?.items ?? [],
+            lets,
+            reads,
+            writes,
+            children: [],
+            fnDefOst: null };
 
     astToOst.set(astNode, ost);
 
@@ -658,7 +659,8 @@ function processAst(astNode, parentOst, astToTree, astToOst, indent, visited) {
   }
 }
 
-function ostAnnotate(ost, astToOst, context) {
+function ostAnnotate
+(ost, astToOst, context) {
   if (ost) {
     for (let letInfo of ost.lets) {
       let writeOst;
@@ -669,11 +671,9 @@ function ostAnnotate(ost, astToOst, context) {
         continue
       if (letInfo.item.defType == 'ImportBinding')
         continue
-      context.report({
-        node: letInfo.item.identifier,
-        messageId: 'mustInit',
-        data: { name: letInfo.item.name }
-      });
+      context.report({ node: letInfo.item.identifier,
+                       messageId: 'mustInit',
+                       data: { name: letInfo.item.name } });
     }
 
     if (ost.astNode.type == 'CallExpression' && ost.astNode.callee?.type == 'Identifier')
@@ -704,7 +704,8 @@ function ostAnnotate(ost, astToOst, context) {
   }
 }
 
-function findFirstWrite(ost, letInfo) {
+function findFirstWrite
+(ost, letInfo) {
   if (ost.astNode.type == 'FunctionDeclaration' || ost.astNode.type == 'ArrowFunctionExpression' || ost.astNode.type == 'FunctionExpression')
     for (let child of ost.children)
       if (child.astNode.type == 'BlockStatement')
@@ -712,7 +713,8 @@ function findFirstWrite(ost, letInfo) {
   return findFirstWriteInSubtree(ost, letInfo)
 }
 
-function findFirstWriteInSubtree(ost, letInfo) {
+function findFirstWriteInSubtree
+(ost, letInfo) {
   if (ost) {
     if (ost.astNode.type == 'FunctionDeclaration' || ost.astNode.type == 'ArrowFunctionExpression' || ost.astNode.type == 'FunctionExpression')
       return null
@@ -737,7 +739,8 @@ function findFirstWriteInSubtree(ost, letInfo) {
   return null
 }
 
-function ostCheck(ost, context) {
+function ostCheck
+(ost, context) {
   if (ost) {
     for (let letInfo of ost.lets)
       if (letInfo.firstWrite)
@@ -748,7 +751,8 @@ function ostCheck(ost, context) {
   }
 }
 
-function walk2Start(node, letInfo, context) {
+function walk2Start
+(node, letInfo, context) {
   if (node.astNode.type == 'FunctionDeclaration')
     for (let child of node.children)
       if (child.astNode.type == 'BlockStatement')
@@ -756,7 +760,8 @@ function walk2Start(node, letInfo, context) {
   return walk2(node, letInfo, context, new Set())
 }
 
-function walk2(node, letInfo, context, visited) {
+function walk2
+(node, letInfo, context, visited) {
   if (node) {
     if (node.astNode.type == 'FunctionDeclaration' || node.astNode.type == 'ArrowFunctionExpression' || node.astNode.type == 'FunctionExpression')
       return false
@@ -764,11 +769,9 @@ function walk2(node, letInfo, context, visited) {
     if (node == letInfo.firstWrite) {
       for (let readInfo of node.reads)
         if (readInfo.item.ref.resolved == letInfo.item.variable) {
-          context.report({
-            node: readInfo.item.ref.identifier,
-            messageId: 'initBeforeUse',
-            data: { name: letInfo.item.name }
-          });
+          context.report({ node: readInfo.item.ref.identifier,
+                           messageId: 'initBeforeUse',
+                           data: { name: letInfo.item.name } });
         }
       return true
     }
@@ -794,11 +797,9 @@ function walk2(node, letInfo, context, visited) {
 
     for (let readInfo of node.reads)
       if (readInfo.item.ref.resolved == letInfo.item.variable) {
-        context.report({
-          node: readInfo.item.ref.identifier,
-          messageId: 'initBeforeUse',
-          data: { name: letInfo.item.name }
-        });
+        context.report({ node: readInfo.item.ref.identifier,
+                         messageId: 'initBeforeUse',
+                         data: { name: letInfo.item.name } });
       }
 
     for (let child of node.children)
@@ -809,19 +810,14 @@ function walk2(node, letInfo, context, visited) {
   return false
 }
 
-var initBeforeUsePlugin = {
-  meta: {
-    type: 'problem',
-    docs: { description: 'Warn when a variable is used before being explicitly initialized.' },
-    messages: { initBeforeUse: "'{{name}}' used before initialization.",
-                mustInit: "'{{name}}' must be initialized." },
-    schema: []
-  },
-  create: createInitBeforeUse
-};
+var initBeforeUsePlugin = { meta: { type: 'problem',
+                         docs: { description: 'Warn when a variable is used before being explicitly initialized.' },
+                         messages: { initBeforeUse: "'{{name}}' used before initialization.",
+                                     mustInit: "'{{name}}' must be initialized." },
+                         schema: [] },
+                 create: createInitBeforeUse };
 
-function
-VariableDeclaration
+function VariableDeclaration
 (context, node) {
   let parent;
 
@@ -846,7 +842,8 @@ VariableDeclaration
     }
   }
 }
-function create$1
+
+function create$3
 (context) {
   return { VariableDeclaration: node => VariableDeclaration(context, node) }
 }
@@ -855,10 +852,9 @@ var varDeclBlockStartPlugin = { meta: { type: 'suggestion',
                   docs: { description: 'Require variable declarations to be at the start of the block.' },
                   messages: { varDeclBlockStart: 'VarDecl must be at start of block.' },
                   schema: [] },
-          create: create$1 };
+          create: create$3 };
 
-function
-FunctionDeclaration
+function FunctionDeclaration
 (context, node) {
   let parent;
 
@@ -884,7 +880,7 @@ FunctionDeclaration
   }
 }
 
-function create
+function create$2
 (context) {
   return { FunctionDeclaration: node => FunctionDeclaration(context, node) }
 }
@@ -893,7 +889,162 @@ var fnDeclBlockStartPlugin = { meta: { type: 'suggestion',
                   docs: { description: 'Require function declarations to be at the start of the block.' },
                   messages: { fnDeclBlockStart: 'FnDecl must be the start the block (after VarDecls).' },
                   schema: [] },
-          create };
+          create: create$2 };
+
+function FnArgsNl
+(node, context) {
+  let nameLine, parenLine, nameEnd, i, newlines, parent;
+
+  parent = node.parent;
+
+  if (parent?.type == 'Property' && (parent.method || parent.kind == 'get' || parent.kind == 'set')) {
+    nameLine = parent.key.loc.start.line;
+    nameEnd = parent.key.range[1];
+  }
+  else if (parent?.type == 'MethodDefinition') {
+    nameLine = parent.key.loc.start.line;
+    nameEnd = parent.key.range[1];
+  }
+  else {
+    nameLine = node.loc.start.line;
+    nameEnd = node.range[0];
+  }
+
+  i = nameEnd;
+  newlines = 0;
+  while (i < context.sourceCode.text.length) {
+    if (context.sourceCode.text[i] == '(')
+      break
+    if (context.sourceCode.text[i] == '\n')
+      newlines++;
+    i++;
+  }
+
+  parenLine = nameLine + newlines;
+
+  if (parenLine - nameLine == 1)
+    return
+  context.report({ node, messageId: 'fnArgsNl' });
+}
+
+function create$1
+(context) {
+  return { FunctionDeclaration: node => FnArgsNl(node, context),
+           FunctionExpression: node => FnArgsNl(node, context) }
+}
+
+var fnArgsNlPlugin = { meta: { type: 'suggestion',
+                         docs: { description: 'Require function args on the line immediately after the function name.' },
+                         messages: { fnArgsNl: 'Fn args must be on the line immediately after the function name.' },
+                         schema: [] },
+                 create: create$1 };
+
+function trace
+(...args) {
+}
+
+function unit
+(context) {
+  return context.options[0] ?? 2
+}
+
+function checkObjectExpressionProperties
+(properties, node, context) {
+  let firstProp, sourceCode, lastProp, lastPropEnd, closingBrace, firstPropLine, firstPropCol, afterLastProp, closingLine, lastPropValueEndLine;
+
+  sourceCode = context.sourceCode.text;
+  firstProp = properties[0];
+  lastProp = properties[properties.length - 1];
+  firstPropLine = firstProp.loc.start.line;
+  firstPropCol = firstProp.loc.start.column;
+  lastPropEnd = lastProp.range[1];
+  closingBrace = sourceCode.indexOf('}', lastPropEnd);
+  closingLine = sourceCode.slice(0, closingBrace).split('\n').length;
+  afterLastProp = sourceCode.slice(lastPropEnd, closingBrace);
+  lastPropValueEndLine = sourceCode.slice(0, lastPropEnd).split('\n').length;
+  trace('CHECK POINT 1: is single-line? firstPropLine=%d, braceLine=%d, closingLine=%d', firstPropLine, node.loc.start.line, closingLine);
+  if (firstPropLine == node.loc.start.line && closingLine == firstPropLine)
+    return
+  trace('CHECK POINT 2: is firstPropLine (%d) != braceLine (%d)?', firstPropLine, node.loc.start.line);
+  if (firstPropLine == node.loc.start.line) ;
+  else if (firstPropCol == node.loc.start.column + unit(context)) ;
+  else {
+    context.report({ node: firstProp, messageId: 'indentStruct' });
+  }
+  for (let i = 1; i < properties.length; i++) {
+    let prop;
+
+    prop = properties[i];
+    if (prop.loc.start.column == firstPropCol) ;
+    else {
+      context.report({ node: prop, messageId: 'indentStruct' });
+    }
+  }
+  if (closingLine > lastPropValueEndLine) {
+    let braceCol, closingCol;
+
+    braceCol = node.loc.start.column;
+    closingCol = node.loc.end.column - 1;
+    if (closingCol == braceCol) ;
+    else {
+      context.report({ node, messageId: 'indentStruct' });
+    }
+  }
+  if (closingLine == lastPropValueEndLine) {
+    if (afterLastProp == ' ') ;
+    else {
+      context.report({ node, messageId: 'indentStruct' });
+    }
+  }
+  for (let prop of properties)
+    if (prop.method) {
+      let keyLine, keyEnd, i, newlines, parenLine;
+
+      keyLine = prop.key.loc.start.line;
+      keyEnd = prop.key.range[1];
+      i = keyEnd;
+      newlines = 0;
+
+      while (i < sourceCode.length) {
+        if (sourceCode[i] == '(')
+          break
+        if (sourceCode[i] == '\n')
+          newlines++;
+        i++;
+      }
+      parenLine = keyLine + newlines;
+      if (parenLine > keyLine) {
+        let parenCol;
+
+        parenCol = i - sourceCode.lastIndexOf('\n', i);
+        if (prop.value.type == 'FunctionExpression' && prop.value.async) ;
+        else if (parenCol - 1 == prop.key.loc.start.column) ;
+        else {
+          context.report({ node: prop, messageId: 'indentStruct' });
+        }
+      }
+    }
+}
+
+function checkObjectExpression
+(node, context) {
+  let properties;
+
+  properties = node.properties;
+  if (properties.length)
+    checkObjectExpressionProperties(properties, node, context);
+}
+
+function create
+(context) {
+  return { ObjectExpression: node => checkObjectExpression(node, context) }
+}
+
+var indentStructPlugin = { meta: { type: 'suggestion',
+                         docs: { description: 'Struct alignment rules.' },
+                         messages: { indentStruct: 'Indent structure' },
+                         schema: [] },
+                 create };
 
 exports.rules = void 0; exports.languageOptions = void 0; exports.plugins = void 0;
 
@@ -903,75 +1054,69 @@ exports.plugins = { 'cookshack': { rules: { 'positive-vibes': positiveVibesPlugi
                                     'always-let': alwaysLetPlugin,
                                     'init-before-use': initBeforeUsePlugin,
                                     'var-decl-block-start': varDeclBlockStartPlugin,
-                                    'fn-decl-block-start': fnDeclBlockStartPlugin } } };
-
-exports.rules = {
-  'array-bracket-newline': [ 'error', 'never' ],
-  'array-bracket-spacing': [ 'error', 'always' ],
-  'arrow-parens': [ 'error', 'as-needed' ],
-  'brace-style': [ 'error', 'stroustrup' ],
-  'comma-dangle': 'error',
-  'curly': [ 'error', 'multi' ],
-  'eol-last': [ 'error', 'always' ],
-  'function-paren-newline': [ 'error', 'never' ],
-  'indent': [ 'error', 2, { ArrayExpression: 'first',
-                            CallExpression: { arguments: 'first' },
-                            //flatTernaryExpressions: true,
-                            //offsetTernaryExpressions: true,
-                            // ternary, because overhangs strangely (eg multiline in array def)
-                            'ignoredNodes': [ 'ConditionalExpression' ],
-                            FunctionDeclaration: { parameters: 'first', body: 1 },
-                            FunctionExpression: { parameters: 'first', body: 1 },
-                            ImportDeclaration: 'first',
-                            ObjectExpression: 'first',
-                            offsetTernaryExpressions: true,
-                            VariableDeclarator: 'first' } ],
-  'init-declarations': [ 'error', 'never', { 'ignoreForLoopInit': true } ],
-  'keyword-spacing': [ 'error', { before: true, after: true } ],
-  'linebreak-style': [ 'error', 'unix' ],
-  'padding-line-between-statements': [ 'error',
-                                       { blankLine: 'always', prev: 'let', next: '*' },
-                                       { blankLine: 'never', prev: 'let', next: 'let' } ],
-  'no-case-declarations': 'error',
-  'no-global-assign': 'error',
-  'cookshack/positive-vibes': 'error',
-  'cookshack/narrowest-scope': 'error',
-  'cookshack/use-risky-equal': 'error',
-  'cookshack/always-let': 'error',
-  // using the implicit inititialization to undefined fits better
-  //'cookshack/init-before-use': 'error',
-  'cookshack/var-decl-block-start': 'error',
-  'cookshack/fn-decl-block-start': 'error',
-  'no-mixed-operators': 'error',
-  'no-multi-spaces': 'error',
-  'no-multiple-empty-lines': [ 'error', { max: 1, maxEOF: 0 } ],
-  'no-negated-condition': 'error',
-  'no-redeclare': 'error',
-  'no-sequences': 'error',
-  'no-sparse-arrays': 'error',
-  'no-tabs': 'error',
-  'no-trailing-spaces': 'error',
-  'no-undef': 'error',
-  'no-unsafe-negation': 'error',
-  'no-unused-vars': 'error',
-  'no-var': 'error',
-  'object-curly-spacing': [ 'error', 'always' ],
-  'object-shorthand': [ 'error', 'always' ],
-  quotes: [ 'error', 'single', { avoidEscape: true } ],
-  semi: [ 'error', 'never' ]
-  //'vars-on-top': [ 'error' ], // want version for let
-  //'newline-before-function-paren': ['error', 'always'],
-};
-
-exports.languageOptions = {
-  globals: {
-    ...globals.node
-  },
-  parserOptions: {
-    ecmaVersion: 2025,
-    sourceType: 'module'
-  }
-};
+                                    'fn-decl-block-start': fnDeclBlockStartPlugin,
+                                    'fn-args-nl': fnArgsNlPlugin,
+                                    'indent-struct': indentStructPlugin } } };
+
+exports.rules = { 'array-bracket-newline': [ 'error', 'never' ],
+          'array-bracket-spacing': [ 'error', 'always' ],
+          'arrow-parens': [ 'error', 'as-needed' ],
+          'brace-style': [ 'error', 'stroustrup' ],
+          'comma-dangle': 'error',
+          'curly': [ 'error', 'multi' ],
+          'eol-last': [ 'error', 'always' ],
+          'function-paren-newline': [ 'error', 'never' ],
+          'indent': [ 'error', 2, { ArrayExpression: 'first',
+                                    CallExpression: { arguments: 'first' },
+                                    //flatTernaryExpressions: true,
+                                    //offsetTernaryExpressions: true,
+                                    // ternary, because overhangs strangely (eg multiline in array def)
+                                    'ignoredNodes': [ 'ConditionalExpression', 'ObjectExpression *' ],
+                                    FunctionDeclaration: { parameters: 'first', body: 1 },
+                                    FunctionExpression: { parameters: 'first', body: 1 },
+                                    ImportDeclaration: 'first',
+                                    offsetTernaryExpressions: true,
+                                    VariableDeclarator: 'first' } ],
+          'init-declarations': [ 'error', 'never', { 'ignoreForLoopInit': true } ],
+          'keyword-spacing': [ 'error', { before: true, after: true } ],
+          'linebreak-style': [ 'error', 'unix' ],
+          'padding-line-between-statements': [ 'error',
+                                               { blankLine: 'always', prev: 'let', next: '*' },
+                                               { blankLine: 'never', prev: 'let', next: 'let' } ],
+          'no-case-declarations': 'error',
+          'no-global-assign': 'error',
+          'cookshack/positive-vibes': 'error',
+          'cookshack/narrowest-scope': 'error',
+          'cookshack/use-risky-equal': 'error',
+          'cookshack/always-let': 'error',
+          // using the implicit inititialization to undefined fits better
+          //'cookshack/init-before-use': 'error',
+          'cookshack/var-decl-block-start': 'error',
+          'cookshack/fn-decl-block-start': 'error',
+          'cookshack/fn-args-nl': 'error',
+          'cookshack/indent-struct': 'error',
+          'no-mixed-operators': 'error',
+          'no-multi-spaces': 'error',
+          'no-multiple-empty-lines': [ 'error', { max: 1, maxEOF: 0 } ],
+          'no-negated-condition': 'error',
+          'no-redeclare': 'error',
+          'no-sequences': 'error',
+          'no-shadow': [ 'error', { builtinGlobals: true } ],
+          'no-sparse-arrays': 'error',
+          'no-tabs': 'error',
+          'no-trailing-spaces': 'error',
+          'no-undef': 'error',
+          'no-unsafe-negation': 'error',
+          'no-unused-vars': 'error',
+          'no-var': 'error',
+          'object-curly-spacing': [ 'error', 'always' ],
+          'object-shorthand': [ 'error', 'always' ],
+          quotes: [ 'error', 'single', { avoidEscape: true } ],
+          semi: [ 'error', 'never' ] };
+
+exports.languageOptions = { globals: { ...globals.node },
+                    parserOptions: { ecmaVersion: 2025,
+                                     sourceType: 'module' } };
 
 var index = [ { ignores: [ 'TAGS.mjs' ] },
           { languageOptions: exports.languageOptions,