@trigen/oxlint-config 9.0.0

package/src/plugin/member-ordering.js

@@ -0,0 +1,191 @@
+const defaultOrder = [
+  'public-static-method',
+  'protected-static-method',
+  'private-static-method',
+  'public-static-field',
+  'protected-static-field',
+  'private-static-field',
+  'public-decorated-field',
+  'protected-decorated-field',
+  'private-decorated-field',
+  'public-instance-field',
+  'protected-instance-field',
+  'private-instance-field',
+  'public-abstract-field',
+  'protected-abstract-field',
+  'signature',
+  'public-constructor',
+  'protected-constructor',
+  'private-constructor',
+  'instance-method'
+]
+
+function getDefaultOptions(context) {
+  return context.options[0]?.default ?? {}
+}
+
+function getMemberTypes(context) {
+  return getDefaultOptions(context).memberTypes ?? defaultOrder
+}
+
+function getAccessibility(member) {
+  return member.accessibility ?? 'public'
+}
+
+function hasDecorators(member) {
+  return (member.decorators?.length ?? 0) > 0
+}
+
+function isAbstract(member) {
+  return member.abstract === true
+}
+
+function isSignature(member) {
+  return member.type.includes('Signature')
+}
+
+function isMethod(member) {
+  return member.type === 'MethodDefinition'
+    || member.type === 'TSAbstractMethodDefinition'
+}
+
+function isField(member) {
+  return member.type === 'PropertyDefinition'
+    || member.type === 'AccessorProperty'
+    || member.type === 'TSAbstractPropertyDefinition'
+}
+
+function getMemberType(member) {
+  const accessibility = getAccessibility(member)
+
+  if (isSignature(member)) {
+    return 'signature'
+  }
+
+  if (member.kind === 'constructor') {
+    return `${accessibility}-constructor`
+  }
+
+  if (isMethod(member)) {
+    if (member.static) {
+      return `${accessibility}-static-method`
+    }
+
+    return 'instance-method'
+  }
+
+  if (isField(member)) {
+    if (isAbstract(member)) {
+      return `${accessibility}-abstract-field`
+    }
+
+    if (hasDecorators(member)) {
+      return `${accessibility}-decorated-field`
+    }
+
+    if (member.static) {
+      return `${accessibility}-static-field`
+    }
+
+    return `${accessibility}-instance-field`
+  }
+
+  return null
+}
+
+function getRank(memberType, memberTypes) {
+  const rank = memberTypes.indexOf(memberType)
+
+  return rank === -1 ? Number.POSITIVE_INFINITY : rank
+}
+
+function getMemberName(member) {
+  if (member.kind === 'constructor') {
+    return 'constructor'
+  }
+
+  const key = member.key
+
+  if (!key) {
+    return member.type
+  }
+
+  if (key.type === 'Identifier' || key.type === 'PrivateIdentifier') {
+    return key.name
+  }
+
+  if (
+    key.type === 'Literal'
+    || key.type === 'StringLiteral'
+    || key.type === 'NumericLiteral'
+  ) {
+    return String(key.value)
+  }
+
+  return member.type
+}
+
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce configured class member ordering.'
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          default: {
+            type: 'object',
+            properties: {
+              order: {
+                enum: ['as-written']
+              },
+              memberTypes: {
+                type: 'array',
+                items: {
+                  type: 'string'
+                }
+              }
+            },
+            additionalProperties: true
+          }
+        },
+        additionalProperties: true
+      }
+    ]
+  },
+  create(context) {
+    const memberTypes = getMemberTypes(context)
+
+    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
+          }
+        }
+      }
+    }
+  }
+}

package/src/plugin/named-import-order.js

@@ -0,0 +1,229 @@
+const defaultOptions = {
+  typeImports: 'none',
+  patterns: []
+}
+
+function getOptions(context) {
+  return {
+    ...defaultOptions,
+    ...context.options[0],
+    patterns: context.options[0]?.patterns ?? []
+  }
+}
+
+function getName(specifier) {
+  const imported = specifier.imported ?? specifier.local
+
+  if (imported.type === 'Identifier') {
+    return imported.name
+  }
+
+  return String(imported.value)
+}
+
+function isTypeSpecifier(node, specifier) {
+  return node.importKind === 'type'
+    || specifier.importKind === 'type'
+}
+
+function getTypeRank(node, specifier, options) {
+  if (options.typeImports === 'first') {
+    return isTypeSpecifier(node, specifier) ? 0 : 1
+  }
+
+  if (options.typeImports === 'last') {
+    return isTypeSpecifier(node, specifier) ? 1 : 0
+  }
+
+  return 0
+}
+
+function getPatternRank(name, patterns) {
+  const rank = patterns.findIndex(pattern => new RegExp(pattern).test(name))
+
+  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 === 'ImportSpecifier')
+    .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 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')) {
+    return ` ${sortedSpecifiers.join(', ')} `
+  }
+
+  const linebreak = getLinebreak(text)
+  const firstSpecifier = items[0].specifier
+  const indent = getLineIndent(text, firstSpecifier.range[0])
+  const closingIndent = getLineIndent(text, node.range[0])
+
+  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 import 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 import specifier order.'
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          typeImports: {
+            enum: [
+              'first',
+              'last',
+              'none'
+            ]
+          },
+          patterns: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          }
+        },
+        additionalProperties: true
+      }
+    ]
+  },
+  create(context) {
+    const options = getOptions(context)
+
+    return {
+      ImportDeclaration(node) {
+        const items = getItems(node, options)
+
+        if (items.length < 2) {
+          return
+        }
+
+        const unorderedPair = getFirstUnorderedPair(items)
+
+        if (!unorderedPair) {
+          return
+        }
+
+        const sourceCode = context.sourceCode
+        const range = getBracesRange(node, items, sourceCode)
+        const fix = range && !hasInnerComments(sourceCode, range)
+          ? fixer => fixer.replaceTextRange(
+            range,
+            getFixedText(node, items, options, sourceCode, range)
+          )
+          : null
+        const [
+          previousItem,
+          item
+        ] = unorderedPair
+
+        context.report({
+          node: item.specifier,
+          message: getMessage(previousItem, item),
+          fix
+        })
+      }
+    }
+  }
+}

package/src/plugin/naming-convention.js

@@ -0,0 +1,300 @@
+const formatPatterns = {
+  camelCase: /^[a-z][a-zA-Z0-9]*$/,
+  PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
+  UPPER_CASE: /^[A-Z][A-Z0-9_]*$/
+}
+
+function toArray(value) {
+  return Array.isArray(value) ? value : [value]
+}
+
+function getSelectorOptions(options, selector, modifiers = []) {
+  return options
+    .filter((option) => {
+      const selectors = toArray(option.selector)
+      const optionModifiers = option.modifiers ?? []
+
+      return (
+        selectors.includes(selector)
+        || selectors.includes('default')
+      )
+        && optionModifiers.every(modifier => modifiers.includes(modifier))
+    })
+    .sort((left, right) => {
+      const leftSelectors = toArray(left.selector)
+      const rightSelectors = toArray(right.selector)
+      const leftScore = leftSelectors.includes(selector) ? 1 : 0
+      const rightScore = rightSelectors.includes(selector) ? 1 : 0
+
+      return leftScore - rightScore
+        || (left.modifiers?.length ?? 0) - (right.modifiers?.length ?? 0)
+    })
+    .at(-1)
+}
+
+function getNormalizedName(name, option) {
+  if (option.leadingUnderscore === 'allow') {
+    return name.replace(/^_+/, '')
+  }
+
+  return name
+}
+
+function matchesFormat(name, format) {
+  return formatPatterns[format]?.test(name) ?? true
+}
+
+function getExpectedFormats(format) {
+  return format.join(', ')
+}
+
+function isValidName(name, option) {
+  if (option?.format === null) {
+    return true
+  }
+
+  if (!option?.format) {
+    return true
+  }
+
+  const normalizedName = getNormalizedName(name, option)
+
+  return normalizedName === ''
+    || option.format.some(format => matchesFormat(normalizedName, format))
+}
+
+function getKeyName(key) {
+  if (!key) {
+    return null
+  }
+
+  if (key.type === 'Identifier' || key.type === 'PrivateIdentifier') {
+    return key.name
+  }
+
+  if (
+    key.type === 'Literal'
+    || key.type === 'StringLiteral'
+    || key.type === 'NumericLiteral'
+  ) {
+    return String(key.value)
+  }
+
+  return null
+}
+
+function isIdentifierName(name) {
+  return /^[A-Za-z_$][\w$]*$/.test(name)
+}
+
+function requiresQuotes(node) {
+  if (node.computed) {
+    return false
+  }
+
+  const name = getKeyName(node.key)
+
+  return name !== null && !isIdentifierName(name)
+}
+
+function getPropertyModifiers(node) {
+  const modifiers = []
+
+  if (node.static) {
+    modifiers.push('static')
+  }
+
+  if (requiresQuotes(node)) {
+    modifiers.push('requiresQuotes')
+  }
+
+  return modifiers
+}
+
+function getIdentifierNames(pattern) {
+  if (!pattern) {
+    return []
+  }
+
+  if (pattern.type === 'Identifier') {
+    return [
+      {
+        name: pattern.name,
+        node: pattern
+      }
+    ]
+  }
+
+  if (pattern.type === 'RestElement') {
+    return getIdentifierNames(pattern.argument)
+  }
+
+  if (pattern.type === 'AssignmentPattern') {
+    return getIdentifierNames(pattern.left)
+  }
+
+  if (pattern.type === 'ArrayPattern') {
+    return pattern.elements.flatMap(getIdentifierNames)
+  }
+
+  if (pattern.type === 'ObjectPattern') {
+    return pattern.properties.flatMap(property => (
+      property.type === 'Property'
+        ? getIdentifierNames(property.value)
+        : getIdentifierNames(property.argument)
+    ))
+  }
+
+  return []
+}
+
+function getParameterNode(parameter) {
+  return parameter.type === 'TSParameterProperty'
+    ? parameter.parameter
+    : parameter
+}
+
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce configured naming conventions.'
+    },
+    schema: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          selector: {
+            anyOf: [
+              {
+                type: 'string'
+              },
+              {
+                type: 'array',
+                items: {
+                  type: 'string'
+                }
+              }
+            ]
+          },
+          format: {
+            anyOf: [
+              {
+                type: 'array',
+                items: {
+                  type: 'string'
+                }
+              },
+              {
+                type: 'null'
+              }
+            ]
+          },
+          leadingUnderscore: {
+            type: 'string'
+          },
+          modifiers: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          }
+        },
+        required: ['selector'],
+        additionalProperties: true
+      }
+    }
+  },
+  create(context) {
+    const options = context.options
+
+    function check(name, node, selector, modifiers = []) {
+      const option = getSelectorOptions(options, selector, modifiers)
+
+      if (!option || isValidName(name, option)) {
+        return
+      }
+
+      context.report({
+        node,
+        message: `Name "${name}" must match one of these formats: ${getExpectedFormats(option.format)}.`
+      })
+    }
+
+    function checkPattern(pattern, selector) {
+      for (const item of getIdentifierNames(pattern)) {
+        check(item.name, item.node, selector)
+      }
+    }
+
+    function checkProperty(node, selector) {
+      const name = getKeyName(node.key)
+
+      if (name === null) {
+        return
+      }
+
+      check(name, node.key, selector, getPropertyModifiers(node))
+    }
+
+    return {
+      VariableDeclarator(node) {
+        checkPattern(node.id, 'variable')
+      },
+      FunctionDeclaration(node) {
+        if (node.id) {
+          check(node.id.name, node.id, 'function')
+        }
+
+        for (const parameter of node.params) {
+          checkPattern(getParameterNode(parameter), 'parameter')
+        }
+      },
+      FunctionExpression(node) {
+        if (node.id) {
+          check(node.id.name, node.id, 'function')
+        }
+
+        for (const parameter of node.params) {
+          checkPattern(getParameterNode(parameter), 'parameter')
+        }
+      },
+      ArrowFunctionExpression(node) {
+        for (const parameter of node.params) {
+          checkPattern(getParameterNode(parameter), 'parameter')
+        }
+      },
+      ClassDeclaration(node) {
+        if (node.id) {
+          check(node.id.name, node.id, 'typeLike')
+        }
+      },
+      TSTypeAliasDeclaration(node) {
+        check(node.id.name, node.id, 'typeLike')
+      },
+      TSInterfaceDeclaration(node) {
+        check(node.id.name, node.id, 'interface')
+      },
+      TSEnumDeclaration(node) {
+        check(node.id.name, node.id, 'typeLike')
+      },
+      TSEnumMember(node) {
+        const name = getKeyName(node.id)
+
+        if (name !== null) {
+          check(name, node.id, 'enumMember')
+        }
+      },
+      PropertyDefinition(node) {
+        checkProperty(node, 'classProperty')
+      },
+      MethodDefinition(node) {
+        checkProperty(node, 'classProperty')
+      },
+      Property(node) {
+        checkProperty(node, 'objectLiteralProperty')
+      }
+    }
+  }
+}