@trigen/oxlint-config 9.2.3 → 10.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@trigen/oxlint-config",
   "type": "module",
-  "version": "9.2.3",
+  "version": "10.0.0",
   "description": "Trigen's Oxlint config.",
   "author": "dangreen",
   "license": "MIT",

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,6 +1,8 @@
 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'
 import namedImportOrderRule from './named-import-order.js'
 import namingConventionRule from './naming-convention.js'
 import typeImportStyleRule from './type-import-style.js'
@@ -11,8 +13,10 @@ export default {
   },
   rules: {
     'extensions': extensionsRule,
+    'func-style': funcStyleRule,
     'import-order': importOrderRule,
     'member-ordering': memberOrderingRule,
+    'named-export-order': namedExportOrderRule,
     'named-import-order': namedImportOrderRule,
     'naming-convention': namingConventionRule,
     'type-import-style': typeImportStyleRule

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/named-export-order.js

@@ -0,0 +1,249 @@
+const defaultOptions = {
+  typeExports: 'none',
+  patterns: []
+}
+
+function getOptions(context) {
+  return {
+    ...defaultOptions,
+    ...context.options[0],
+    patterns: context.options[0]?.patterns ?? []
+  }
+}
+
+function getName(specifier) {
+  const exported = specifier.exported ?? specifier.local
+
+  if (exported.type === 'Identifier') {
+    return exported.name
+  }
+
+  return String(exported.value)
+}
+
+function isTypeSpecifier(node, specifier) {
+  return node.exportKind === 'type'
+    || specifier.exportKind === 'type'
+}
+
+function getTypeRank(node, specifier, options) {
+  if (options.typeExports === 'first') {
+    return isTypeSpecifier(node, specifier) ? 0 : 1
+  }
+
+  if (options.typeExports === 'last') {
+    return isTypeSpecifier(node, specifier) ? 1 : 0
+  }
+
+  return 0
+}
+
+function getPatternRank(name, patterns) {
+  const normalizedName = name.replace(/^\$+|\$+$/g, '')
+  const rank = patterns.findIndex(pattern => new RegExp(pattern).test(
+    normalizedName
+  ))
+
+  return rank === -1 ? Number.POSITIVE_INFINITY : rank
+}
+
+function getRank(node, specifier, options) {
+  const name = getName(specifier)
+
+  return {
+    name,
+    typeRank: getTypeRank(node, specifier, options),
+    patternRank: getPatternRank(name, options.patterns)
+  }
+}
+
+function compareRanks(left, right) {
+  return left.typeRank - right.typeRank
+    || left.patternRank - right.patternRank
+}
+
+function getItems(node, options) {
+  return node.specifiers
+    .filter(specifier => specifier.type === 'ExportSpecifier')
+    .map((specifier, index) => ({
+      index,
+      specifier,
+      rank: getRank(node, specifier, options)
+    }))
+}
+
+function compareItems(left, right) {
+  return compareRanks(left.rank, right.rank)
+    || left.index - right.index
+}
+
+function getFirstUnorderedPair(items) {
+  for (let index = 1; index < items.length; index++) {
+    const previousItem = items[index - 1]
+    const item = items[index]
+
+    if (compareItems(previousItem, item) > 0) {
+      return [
+        previousItem,
+        item
+      ]
+    }
+  }
+
+  return null
+}
+
+function getLinebreak(text) {
+  return text.includes('\r\n') ? '\r\n' : '\n'
+}
+
+function getLineIndent(text, index) {
+  const lineStart = text.lastIndexOf('\n', index - 1) + 1
+  const indentMatch = /^[ \t]*/.exec(text.slice(lineStart, index))
+
+  return indentMatch[0]
+}
+
+function getBracesRange(node, items, sourceCode) {
+  const text = sourceCode.text
+  const firstSpecifier = items[0].specifier
+  const lastSpecifier = items.at(-1).specifier
+  const openingBrace = text.lastIndexOf('{', firstSpecifier.range[0])
+  const closingBrace = text.indexOf('}', lastSpecifier.range[1])
+  const searchEnd = node.source?.range?.[0] ?? node.range[1]
+
+  if (
+    openingBrace < node.range[0]
+    || closingBrace === -1
+    || closingBrace > searchEnd
+  ) {
+    return null
+  }
+
+  return [
+    openingBrace + 1,
+    closingBrace
+  ]
+}
+
+function hasInnerComments(sourceCode, range) {
+  return sourceCode.getAllComments().some(comment => comment.range[0] > range[0]
+    && comment.range[1] < range[1])
+}
+
+function shouldBeMultiline(sourceCode, range, items) {
+  return items.length > 1
+    && !sourceCode.text.slice(range[0], range[1]).includes('\n')
+}
+
+function getFixedText(node, items, options, sourceCode, range) {
+  const text = sourceCode.text
+  const content = text.slice(range[0], range[1])
+  const sortedSpecifiers = [...items]
+    .sort(compareItems)
+    .map(({ specifier }) => sourceCode.getText(specifier))
+
+  if (!content.includes('\n') && items.length < 2) {
+    return ` ${sortedSpecifiers.join(', ')} `
+  }
+
+  const linebreak = getLinebreak(text)
+  const firstSpecifier = items[0].specifier
+  const closingIndent = getLineIndent(text, node.range[0])
+  const indent = content.includes('\n')
+    ? getLineIndent(text, firstSpecifier.range[0])
+    : `${closingIndent}  `
+
+  return `${linebreak}${indent}${sortedSpecifiers.join(`,${linebreak}${indent}`)}${linebreak}${closingIndent}`
+}
+
+function getMessage(left, right) {
+  if (left.rank.typeRank !== right.rank.typeRank) {
+    return `Expected ${right.rank.name} to come before ${left.rank.name} because of export kind.`
+  }
+
+  if (left.rank.patternRank !== right.rank.patternRank) {
+    return `Expected ${right.rank.name} to come before ${left.rank.name} because of naming pattern.`
+  }
+
+  return `Expected ${right.rank.name} to come before ${left.rank.name}.`
+}
+
+export default {
+  meta: {
+    type: 'layout',
+    fixable: 'code',
+    docs: {
+      description: 'Enforce named export specifier order.'
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          typeExports: {
+            enum: [
+              'first',
+              'last',
+              'none'
+            ]
+          },
+          patterns: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          }
+        },
+        additionalProperties: true
+      }
+    ]
+  },
+  create(context) {
+    const options = getOptions(context)
+
+    return {
+      ExportNamedDeclaration(node) {
+        const items = getItems(node, options)
+
+        if (items.length < 2) {
+          return
+        }
+
+        const unorderedPair = getFirstUnorderedPair(items)
+        const sourceCode = context.sourceCode
+        const range = getBracesRange(node, items, sourceCode)
+        const invalidMultiline = range && shouldBeMultiline(
+          sourceCode,
+          range,
+          items
+        )
+
+        if (!unorderedPair && !invalidMultiline) {
+          return
+        }
+
+        const fix = range && !hasInnerComments(sourceCode, range)
+          ? fixer => fixer.replaceTextRange(
+            range,
+            getFixedText(node, items, options, sourceCode, range)
+          )
+          : null
+        const [
+          previousItem,
+          item
+        ] = unorderedPair ?? [
+          items[0],
+          items[1]
+        ]
+
+        context.report({
+          node: item.specifier,
+          message: unorderedPair
+            ? getMessage(previousItem, item)
+            : 'Expected named exports to be multiline.',
+          fix
+        })
+      }
+    }
+  }
+}

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/import.js

@@ -78,6 +78,17 @@ export default {
           '^[a-z][a-zA-Z0-9]*$'
         ]
       }
+    ],
+    'trigen/named-export-order': [
+      'error',
+      {
+        typeExports: 'first',
+        patterns: [
+          '^[A-Z][A-Z0-9_]*$',
+          '^[A-Z][a-zA-Z0-9]*$',
+          '^[a-z][a-zA-Z0-9]*$'
+        ]
+      }
     ]
   }
 }

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'
               ]
             }
           }

package/src/test.js

@@ -23,6 +23,7 @@ export default {
         'typescript/no-unsafe-call': 'off',
         'typescript/no-unsafe-argument': 'off',
         'typescript/no-explicit-any': 'off',
+        'typescript/await-thenable': 'off',
         'typescript/no-floating-promises': 'off',
         'trigen/import-order': 'off',
         'eslint/prefer-destructuring': 'off',