@trigen/oxlint-config 9.3.0 → 10.1.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@trigen/oxlint-config",
   "type": "module",
-  "version": "9.3.0",
+  "version": "10.1.1",
   "description": "Trigen's Oxlint config.",
   "author": "dangreen",
   "license": "MIT",
@@ -23,7 +23,8 @@
   "exports": {
     ".": "./src/index.js",
     "./plugin": "./src/plugin/index.js",
-    "./*": "./src/*.js"
+    "./*": "./src/*.js",
+    "./package.json": "./package.json"
   },
   "peerDependencies": {
     "oxlint": ">=1.0.0",

package/src/plugin/func-style.js

@@ -0,0 +1,154 @@
+function isFunctionExpression(node) {
+  return node?.type === 'ArrowFunctionExpression'
+    || node?.type === 'FunctionExpression'
+}
+
+function pushComputedKeys(stack, classBody) {
+  classBody.body.forEach((member) => {
+    if (member.computed) {
+      stack.push(member.key)
+    }
+  })
+}
+
+function pushChildren(stack, node) {
+  Object.entries(node).forEach(([key, value]) => {
+    if (key === 'parent' || typeof value !== 'object' || value === null) {
+      return
+    }
+
+    if (Array.isArray(value)) {
+      value.forEach(item => stack.push(item))
+    } else {
+      stack.push(value)
+    }
+  })
+}
+
+/**
+ * Check if a function references `this`, `arguments` or `new.target` from its own scope,
+ * so it can't be converted to an arrow function.
+ * @param {object} functionNode
+ * @returns {boolean} Whether the function uses its own bindings.
+ */
+function usesFunctionBindings(functionNode) {
+  const stack = [...functionNode.params, functionNode.body]
+
+  while (stack.length > 0) {
+    const node = stack.pop()
+
+    if (!node || typeof node.type !== 'string') {
+      continue
+    }
+
+    switch (node.type) {
+      case 'ThisExpression':
+        return true
+      case 'MetaProperty':
+        if (node.meta.name === 'new') {
+          return true
+        }
+
+        continue
+      case 'Identifier':
+        if (node.name === 'arguments') {
+          return true
+        }
+
+        continue
+      // nested regular functions and class members rebind `this` and `arguments`
+      case 'FunctionDeclaration':
+      case 'FunctionExpression':
+        continue
+      case 'ClassBody':
+        pushComputedKeys(stack, node)
+        continue
+      case 'MemberExpression':
+        stack.push(node.object)
+
+        if (node.computed) {
+          stack.push(node.property)
+        }
+
+        continue
+      case 'Property':
+      case 'PropertyDefinition':
+      case 'MethodDefinition':
+        if (node.computed) {
+          stack.push(node.key)
+        }
+
+        stack.push(node.value)
+        continue
+      default:
+        pushChildren(stack, node)
+    }
+  }
+
+  return false
+}
+
+function checkDeclarator(context, declarator) {
+  if (
+    isFunctionExpression(declarator.init)
+    && declarator.id.type === 'Identifier'
+    && !declarator.id.typeAnnotation
+  ) {
+    context.report({
+      node: declarator.id,
+      message: 'Use a function declaration instead of assigning a function to a constant at the top level.'
+    })
+  }
+}
+
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce function declarations at the top level and arrow functions assigned to constants inside functions.'
+    },
+    schema: []
+  },
+  create(context) {
+    let depth = 0
+
+    return {
+      FunctionDeclaration(node) {
+        if (depth > 0 && !node.generator && !usesFunctionBindings(node)) {
+          context.report({
+            node: node.id ?? node,
+            message: 'Use an arrow function assigned to a constant instead of a nested function declaration.'
+          })
+        }
+
+        depth++
+      },
+      'FunctionDeclaration:exit'() {
+        depth--
+      },
+      FunctionExpression() {
+        depth++
+      },
+      'FunctionExpression:exit'() {
+        depth--
+      },
+      ArrowFunctionExpression() {
+        depth++
+      },
+      'ArrowFunctionExpression:exit'() {
+        depth--
+      },
+      StaticBlock() {
+        depth++
+      },
+      'StaticBlock:exit'() {
+        depth--
+      },
+      VariableDeclaration(node) {
+        if (depth === 0 && node.kind === 'const') {
+          node.declarations.forEach(declarator => checkDeclarator(context, declarator))
+        }
+      }
+    }
+  }
+}

package/src/plugin/index.js

@@ -1,4 +1,5 @@
 import extensionsRule from './extensions.js'
+import funcStyleRule from './func-style.js'
 import importOrderRule from './import-order.js'
 import memberOrderingRule from './member-ordering.js'
 import namedExportOrderRule from './named-export-order.js'
@@ -12,6 +13,7 @@ export default {
   },
   rules: {
     'extensions': extensionsRule,
+    'func-style': funcStyleRule,
     'import-order': importOrderRule,
     'member-ordering': memberOrderingRule,
     'named-export-order': namedExportOrderRule,

package/src/plugin/member-ordering.js

@@ -13,11 +13,15 @@ const defaultOrder = [
   'private-instance-field',
   'public-abstract-field',
   'protected-abstract-field',
+  'field',
   'signature',
+  'call-signature',
   'public-constructor',
   'protected-constructor',
   'private-constructor',
-  'instance-method'
+  'constructor',
+  'instance-method',
+  'method'
 ]
 
 function getDefaultOptions(context) {
@@ -93,10 +97,43 @@ function getMemberType(member) {
   return null
 }
 
-function getRank(memberType, memberTypes) {
-  const rank = memberTypes.indexOf(memberType)
+function getClassMemberTypes(member) {
+  const memberType = getMemberType(member)
 
-  return rank === -1 ? Number.POSITIVE_INFINITY : rank
+  return memberType === null ? null : [memberType]
+}
+
+function getSignatureMemberTypes(member) {
+  switch (member.type) {
+    case 'TSPropertySignature':
+      return member.readonly
+        ? ['readonly-field', 'field']
+        : ['field']
+    case 'TSMethodSignature':
+      return ['method']
+    case 'TSIndexSignature':
+      return member.readonly
+        ? ['readonly-signature', 'signature']
+        : ['signature']
+    case 'TSConstructSignatureDeclaration':
+      return ['constructor']
+    case 'TSCallSignatureDeclaration':
+      return ['call-signature']
+    default:
+      return null
+  }
+}
+
+function getRank(candidateTypes, memberTypes) {
+  for (const candidateType of candidateTypes) {
+    const rank = memberTypes.indexOf(candidateType)
+
+    if (rank !== -1) {
+      return rank
+    }
+  }
+
+  return -1
 }
 
 function getMemberName(member) {
@@ -125,11 +162,43 @@ function getMemberName(member) {
   return member.type
 }
 
+function checkMembers(context, memberTypes, members, getCandidateTypes) {
+  let previousMember = null
+
+  for (const member of members) {
+    const candidateTypes = getCandidateTypes(member)
+
+    if (candidateTypes === null) {
+      continue
+    }
+
+    const rank = getRank(candidateTypes, memberTypes)
+
+    if (rank === -1) {
+      continue
+    }
+
+    if (previousMember && previousMember.rank > rank) {
+      context.report({
+        node: member,
+        message: `Member "${getMemberName(member)}" should be declared before "${getMemberName(previousMember.node)}".`
+      })
+
+      return
+    }
+
+    previousMember = {
+      node: member,
+      rank
+    }
+  }
+}
+
 export default {
   meta: {
     type: 'suggestion',
     docs: {
-      description: 'Enforce configured class member ordering.'
+      description: 'Enforce configured class, interface and type literal member ordering.'
     },
     schema: [
       {
@@ -160,31 +229,13 @@ export default {
 
     return {
       ClassBody(node) {
-        let previousMember = null
-
-        for (const member of node.body) {
-          const memberType = getMemberType(member)
-
-          if (memberType === null) {
-            continue
-          }
-
-          const rank = getRank(memberType, memberTypes)
-
-          if (previousMember && previousMember.rank > rank) {
-            context.report({
-              node: member,
-              message: `Member "${getMemberName(member)}" should be declared before "${getMemberName(previousMember.node)}".`
-            })
-
-            return
-          }
-
-          previousMember = {
-            node: member,
-            rank
-          }
-        }
+        checkMembers(context, memberTypes, node.body, getClassMemberTypes)
+      },
+      TSInterfaceBody(node) {
+        checkMembers(context, memberTypes, node.body, getSignatureMemberTypes)
+      },
+      TSTypeLiteral(node) {
+        checkMembers(context, memberTypes, node.members, getSignatureMemberTypes)
       }
     }
   }

package/src/plugin/naming-convention.js

@@ -224,8 +224,7 @@ export default {
   },
   create(context) {
     const options = context.options
-
-    function check(name, node, selector, modifiers = []) {
+    const check = (name, node, selector, modifiers = []) => {
       const option = getSelectorOptions(options, selector, modifiers)
 
       if (!option || isValidName(name, option)) {
@@ -237,14 +236,12 @@ export default {
         message: `Name "${name}" must match one of these formats: ${getExpectedFormats(option.format)}.`
       })
     }
-
-    function checkPattern(pattern, selector) {
+    const checkPattern = (pattern, selector) => {
       for (const item of getIdentifierNames(pattern)) {
         check(item.name, item.node, selector)
       }
     }
-
-    function checkProperty(node, selector) {
+    const checkProperty = (node, selector) => {
       const name = getKeyName(node.key)
 
       if (name === null) {

package/src/subconfigs/basic.js

@@ -223,13 +223,6 @@ export default {
     'eslint/prefer-template': 'error',
     'eslint/symbol-description': 'error',
     'eslint/func-names': 'error',
-    'eslint/func-style': [
-      'error',
-      'declaration',
-      {
-        allowArrowFunctions: true
-      }
-    ],
     'eslint/max-nested-callbacks': ['error', 4],
     'eslint/max-params': ['error', 6],
     'eslint/new-cap': [
@@ -245,6 +238,7 @@ export default {
     'eslint/operator-assignment': ['error', 'always'],
     'eslint/prefer-object-spread': 'error',
     'eslint/unicode-bom': 'error',
+    'trigen/func-style': 'error',
     'trigen/naming-convention': [
       'error',
       {

package/src/subconfigs/typescript.js

@@ -103,11 +103,15 @@ export default {
                 'private-instance-field',
                 'public-abstract-field',
                 'protected-abstract-field',
+                'field',
                 'signature',
+                'call-signature',
                 'public-constructor',
                 'protected-constructor',
                 'private-constructor',
-                'instance-method'
+                'constructor',
+                'instance-method',
+                'method'
               ]
             }
           }