@trigen/oxlint-config 9.0.2 → 9.1.0

package/package.json

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

package/src/module.js

@@ -9,13 +9,14 @@ import {
 } from './subconfigs/files.js'
 
 export default {
+  jsPlugins: ['@trigen/oxlint-config/plugin'],
   overrides: [
     ...bundlerConfig.overrides,
     {
       files: not(commonjsFiles),
       plugins: ['import'],
       rules: {
-        'import/extensions': ['error', 'ignorePackages']
+        'trigen/extensions': ['error', 'ignorePackages']
       }
     }
   ]

package/src/plugin/extensions.js

@@ -0,0 +1,72 @@
+import { posix as path } from 'node:path'
+
+function getOptions(context) {
+  return {
+    ignorePackages: context.options[0] === 'ignorePackages'
+  }
+}
+
+function isPackageImport(source) {
+  return !source.startsWith('.')
+    && !source.startsWith('/')
+}
+
+function hasExtension(source) {
+  const cleanSource = source.split(/[?#]/)[0]
+  const basename = path.basename(cleanSource)
+
+  return path.extname(basename) !== ''
+}
+
+function checkSource(context, options, node) {
+  const source = node.source?.value
+
+  if (typeof source !== 'string') {
+    return
+  }
+
+  if (options.ignorePackages && isPackageImport(source)) {
+    return
+  }
+
+  if (hasExtension(source)) {
+    return
+  }
+
+  context.report({
+    node: node.source,
+    message: `Missing file extension for "${source}".`
+  })
+}
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Require import and export paths to include any file extension.'
+    },
+    schema: [
+      {
+        enum: [
+          'always',
+          'ignorePackages'
+        ]
+      }
+    ]
+  },
+  create(context) {
+    const options = getOptions(context)
+
+    return {
+      ExportAllDeclaration(node) {
+        checkSource(context, options, node)
+      },
+      ExportNamedDeclaration(node) {
+        checkSource(context, options, node)
+      },
+      ImportDeclaration(node) {
+        checkSource(context, options, node)
+      }
+    }
+  }
+}

package/src/plugin/import-order.js

@@ -161,11 +161,13 @@ function getOptions(context) {
 }
 
 function getImportItems(imports, options) {
-  return imports.map((node, index) => ({
-    index,
-    node,
-    rank: getRank(node, options)
-  }))
+  return imports
+    .filter(node => node.specifiers.length > 0)
+    .map((node, index) => ({
+      index,
+      node,
+      rank: getRank(node, options)
+    }))
 }
 
 function compareImportItems(left, right) {
@@ -189,23 +191,36 @@ function getFirstUnorderedPair(items) {
   return null
 }
 
-function hasInvalidNewlines(items, options) {
+function hasBlankLineBetween(sourceCode, left, right) {
+  return sourceCode.text
+    .slice(left.node.range[1], right.node.range[0])
+    .split(/\r?\n/)
+    .slice(1, -1)
+    .some(line => line.trim() === '')
+}
+
+function getInvalidNewlinePair(sourceCode, items, options) {
   if (options['newlines-between'] === 'ignore') {
-    return false
+    return null
   }
 
-  return items.some((item, index) => {
-    if (index === 0) {
-      return false
-    }
-
+  for (let index = 1; index < items.length; index++) {
     const previousItem = items[index - 1]
-    const hasEmptyLine = item.node.loc.start.line - previousItem.node.loc.end.line > 1
+    const item = items[index]
+    const hasBlankLine = hasBlankLineBetween(sourceCode, previousItem, item)
+    const invalid = options['newlines-between'] === 'never'
+      ? hasBlankLine
+      : !hasBlankLine
 
-    return options['newlines-between'] === 'never'
-      ? hasEmptyLine
-      : !hasEmptyLine
-  })
+    if (invalid) {
+      return [
+        previousItem,
+        item
+      ]
+    }
+  }
+
+  return null
 }
 
 function hasInnerComments(sourceCode, items) {
@@ -216,13 +231,20 @@ function hasInnerComments(sourceCode, items) {
     && comment.range[1] < lastNode.range[1])
 }
 
-function hasSideEffectImports(items) {
-  return items.some(({ node }) => node.specifiers.length === 0)
+function canFix(sourceCode, items) {
+  return !hasInnerComments(sourceCode, items)
 }
 
-function canFix(sourceCode, items) {
-  return !hasSideEffectImports(items)
-    && !hasInnerComments(sourceCode, items)
+function hasSkippedImportsBetween(imports, items) {
+  const itemNodes = new Set(items.map(({ node }) => node))
+  const [
+    start,
+    end
+  ] = getImportBlockRange(items)
+
+  return imports.some(node => !itemNodes.has(node)
+    && node.range[0] > start
+    && node.range[1] < end)
 }
 
 function getFixedImportText(sourceCode, items, options) {
@@ -316,21 +338,30 @@ export default {
 
         imports.push(node)
       },
-      'Program:exit'(node) {
+      'Program:exit'() {
         if (imports.length < 2) {
           return
         }
 
         const sourceCode = context.sourceCode
         const items = getImportItems(imports, options)
+
+        if (items.length < 2) {
+          return
+        }
+
+        const hasSkippedImports = hasSkippedImportsBetween(imports, items)
         const unorderedPair = getFirstUnorderedPair(items)
-        const invalidNewlines = hasInvalidNewlines(items, options)
+        const invalidNewlinePair = hasSkippedImports
+          ? null
+          : getInvalidNewlinePair(sourceCode, items, options)
 
-        if (!unorderedPair && !invalidNewlines) {
+        if (!unorderedPair && !invalidNewlinePair) {
           return
         }
 
         const fix = canFix(sourceCode, items)
+          && !hasSkippedImports
           ? fixer => fixer.replaceTextRange(
             getImportBlockRange(items),
             getFixedImportText(sourceCode, items, options)
@@ -339,13 +370,10 @@ export default {
         const [
           previousItem,
           item
-        ] = unorderedPair ?? [
-          items[0],
-          items[1]
-        ]
+        ] = unorderedPair ?? invalidNewlinePair
 
         context.report({
-          node,
+          node: item.node,
           message: unorderedPair
             ? getMessage(previousItem.rank, item.rank)
             : 'Import declarations have invalid empty lines.',

package/src/plugin/index.js

@@ -1,16 +1,20 @@
+import extensionsRule from './extensions.js'
 import importOrderRule from './import-order.js'
 import memberOrderingRule from './member-ordering.js'
 import namedImportOrderRule from './named-import-order.js'
 import namingConventionRule from './naming-convention.js'
+import typeImportStyleRule from './type-import-style.js'
 
 export default {
   meta: {
-    name: '@trigen/oxlint-config/plugin'
+    name: 'trigen'
   },
   rules: {
+    'extensions': extensionsRule,
     'import-order': importOrderRule,
     'member-ordering': memberOrderingRule,
     'named-import-order': namedImportOrderRule,
-    'naming-convention': namingConventionRule
+    'naming-convention': namingConventionRule,
+    'type-import-style': typeImportStyleRule
   }
 }

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

@@ -39,7 +39,10 @@ function getTypeRank(node, specifier, options) {
 }
 
 function getPatternRank(name, patterns) {
-  const rank = patterns.findIndex(pattern => new RegExp(pattern).test(name))
+  const normalizedName = name.replace(/^\$+|\$+$/g, '')
+  const rank = patterns.findIndex(pattern => new RegExp(pattern).test(
+    normalizedName
+  ))
 
   return rank === -1 ? Number.POSITIVE_INFINITY : rank
 }

package/src/plugin/naming-convention.js

@@ -33,11 +33,21 @@ function getSelectorOptions(options, selector, modifiers = []) {
 }
 
 function getNormalizedName(name, option) {
+  let normalizedName = name
+
   if (option.leadingUnderscore === 'allow') {
-    return name.replace(/^_+/, '')
+    normalizedName = normalizedName.replace(/^_+/, '')
+  }
+
+  if (option.leadingDollar === 'allow') {
+    normalizedName = normalizedName.replace(/^\$+/, '')
+  }
+
+  if (option.trailingDollar === 'allow') {
+    normalizedName = normalizedName.replace(/\$+$/, '')
   }
 
-  return name
+  return normalizedName
 }
 
 function matchesFormat(name, format) {
@@ -194,6 +204,12 @@ export default {
           leadingUnderscore: {
             type: 'string'
           },
+          leadingDollar: {
+            type: 'string'
+          },
+          trailingDollar: {
+            type: 'string'
+          },
           modifiers: {
             type: 'array',
             items: {

package/src/plugin/type-import-style.js

@@ -0,0 +1,166 @@
+function shouldConvert(node) {
+  return node.importKind !== 'type'
+    && !hasImportAttributes(node)
+    && node.specifiers.length > 0
+    && node.specifiers.every(specifier => specifier.type === 'ImportSpecifier'
+      && specifier.importKind === 'type')
+}
+
+function isNamedImport(node) {
+  return node.specifiers.length > 0
+    && node.specifiers.every(specifier => specifier.type === 'ImportSpecifier')
+}
+
+function isTypeImport(node) {
+  return node.importKind === 'type'
+    || (
+      isNamedImport(node)
+      && node.specifiers.every(specifier => specifier.importKind === 'type')
+    )
+}
+
+function hasImportAttributes(node) {
+  return (node.attributes?.length ?? 0) > 0
+    || (node.assertions?.length ?? 0) > 0
+}
+
+function hasCommentsBetween(sourceCode, left, right) {
+  return sourceCode.getAllComments().some(comment => comment.range[0] > left.range[1]
+    && comment.range[1] < right.range[0])
+}
+
+function getLocalName(specifier) {
+  return specifier.local?.name ?? null
+}
+
+function hasOverlappingLocalNames(left, right) {
+  const leftNames = new Set(left.specifiers.map(getLocalName))
+
+  return right.specifiers.some(specifier => leftNames.has(getLocalName(specifier)))
+}
+
+function canMerge(sourceCode, typeNode, valueNode) {
+  return typeNode.source.value === valueNode.source.value
+    && isTypeImport(typeNode)
+    && isNamedImport(typeNode)
+    && isNamedImport(valueNode)
+    && !isTypeImport(valueNode)
+    && !hasImportAttributes(typeNode)
+    && !hasImportAttributes(valueNode)
+    && !hasOverlappingLocalNames(typeNode, valueNode)
+    && !hasCommentsBetween(sourceCode, typeNode, valueNode)
+}
+
+function getMergePair(imports, sourceCode) {
+  for (let index = 1; index < imports.length; index++) {
+    const previousImport = imports[index - 1]
+    const importNode = imports[index]
+
+    if (canMerge(sourceCode, previousImport, importNode)) {
+      return [
+        previousImport,
+        importNode
+      ]
+    }
+  }
+
+  return null
+}
+
+function getConvertNode(imports) {
+  return imports.find(shouldConvert)
+}
+
+function getTypeSpecifierText(specifier, sourceCode) {
+  const text = sourceCode.getText(specifier)
+
+  return text.startsWith('type ')
+    ? text
+    : `type ${text}`
+}
+
+function getMergedText(typeNode, valueNode, sourceCode) {
+  const typeSpecifiers = typeNode.specifiers.map(specifier => getTypeSpecifierText(
+    specifier,
+    sourceCode
+  ))
+  const valueSpecifiers = valueNode.specifiers.map(specifier => sourceCode.getText(
+    specifier
+  ))
+  const source = sourceCode.getText(valueNode.source)
+
+  return `import { ${[
+    ...typeSpecifiers,
+    ...valueSpecifiers
+  ].join(', ')} } from ${source}`
+}
+
+function getFixedText(node, sourceCode) {
+  return sourceCode.getText(node)
+    .replace(/^import\b/, 'import type')
+    .replace(/([,{]\s*)type\s+/g, '$1')
+}
+
+export default {
+  meta: {
+    type: 'layout',
+    fixable: 'code',
+    docs: {
+      description: 'Prefer import type and merge duplicate type/value imports.'
+    },
+    schema: []
+  },
+  create(context) {
+    const sourceCode = context.sourceCode
+    const imports = []
+
+    return {
+      ImportDeclaration(node) {
+        if (typeof node.source.value !== 'string') {
+          return
+        }
+
+        imports.push(node)
+      },
+      'Program:exit'() {
+        const mergePair = getMergePair(imports, sourceCode)
+
+        if (mergePair) {
+          const [
+            typeNode,
+            valueNode
+          ] = mergePair
+
+          context.report({
+            node: valueNode.source,
+            message: 'Merge type and value imports from the same source.',
+            fix: fixer => fixer.replaceTextRange(
+              [
+                typeNode.range[0],
+                valueNode.range[1]
+              ],
+              getMergedText(typeNode, valueNode, sourceCode)
+            )
+          })
+
+          return
+        }
+
+        const convertNode = getConvertNode(imports)
+
+        if (!convertNode) {
+          return
+        }
+
+        context.report({
+          node: convertNode.source,
+          message: 'Use import type when all named imports are type imports.',
+          fix: fixer => fixer.replaceTextRange(
+            convertNode.range,
+            getFixedText(convertNode, sourceCode)
+          )
+        })
+      }
+    }
+  }
+}

package/src/storybook.js

@@ -8,6 +8,11 @@ export default {
   overrides: [
     {
       files: storiesFiles,
+      plugins: [
+        'import',
+        'react',
+        'typescript'
+      ],
       rules: {
         'eslint/max-classes-per-file': 'off',
         'eslint/no-magic-numbers': 'off',

package/src/subconfigs/basic.js

@@ -3,6 +3,7 @@
  */
 
 export default {
+  jsPlugins: ['@trigen/oxlint-config/plugin'],
   rules: {
     'eslint/constructor-super': 'error',
     'eslint/for-direction': 'error',
@@ -160,7 +161,12 @@ export default {
     'eslint/no-useless-call': 'error',
     'eslint/no-useless-concat': 'error',
     'eslint/no-useless-return': 'error',
-    'eslint/no-void': 'error',
+    'eslint/no-void': [
+      'error',
+      {
+        allowAsStatement: true
+      }
+    ],
     'eslint/prefer-promise-reject-errors': 'error',
     'eslint/prefer-regex-literals': 'error',
     'eslint/preserve-caught-error': 'error',
@@ -237,6 +243,73 @@ export default {
     'eslint/no-unneeded-ternary': 'error',
     'eslint/operator-assignment': ['error', 'always'],
     'eslint/prefer-object-spread': 'error',
-    'eslint/unicode-bom': 'error'
+    'eslint/unicode-bom': 'error',
+    'trigen/naming-convention': [
+      'error',
+      {
+        selector: 'default',
+        format: [
+          'camelCase',
+          'PascalCase',
+          'UPPER_CASE'
+        ],
+        leadingDollar: 'allow',
+        trailingDollar: 'allow'
+      },
+      {
+        selector: 'variable',
+        format: [
+          'camelCase',
+          'UPPER_CASE',
+          'PascalCase'
+        ],
+        leadingDollar: 'allow',
+        trailingDollar: 'allow'
+      },
+      {
+        selector: 'function',
+        format: ['camelCase', 'PascalCase'],
+        leadingDollar: 'allow',
+        trailingDollar: 'allow'
+      },
+      {
+        selector: 'parameter',
+        format: ['camelCase', 'PascalCase'],
+        leadingUnderscore: 'allow',
+        leadingDollar: 'allow',
+        trailingDollar: 'allow'
+      },
+      {
+        selector: 'typeLike',
+        format: ['PascalCase'],
+        trailingDollar: 'allow'
+      },
+      {
+        selector: 'interface',
+        format: ['PascalCase'],
+        trailingDollar: 'allow'
+      },
+      {
+        selector: 'enumMember',
+        format: ['PascalCase'],
+        trailingDollar: 'allow'
+      },
+      {
+        selector: 'classProperty',
+        format: [
+          'camelCase',
+          'UPPER_CASE',
+          'PascalCase'
+        ],
+        modifiers: ['static'],
+        leadingDollar: 'allow',
+        trailingDollar: 'allow'
+      },
+      {
+        selector: ['objectLiteralProperty', 'objectLiteralMethod'],
+        format: null,
+        modifiers: ['requiresQuotes']
+      }
+    ]
   }
 }

package/src/subconfigs/configs.js

@@ -8,6 +8,7 @@ export default {
   overrides: [
     {
       files: configFiles,
+      plugins: ['import'],
       rules: {
         'import/no-default-export': 'off',
         'import/no-anonymous-default-export': 'off'

package/src/subconfigs/import.js

@@ -4,12 +4,7 @@
 
 export default {
   plugins: ['import'],
-  jsPlugins: [
-    {
-      name: 'trigen',
-      specifier: '@trigen/oxlint-config/plugin'
-    }
-  ],
+  jsPlugins: ['@trigen/oxlint-config/plugin'],
   rules: {
     'import/no-absolute-path': 'error',
     'import/no-dynamic-require': 'error',

package/src/subconfigs/jsdoc.js

@@ -32,6 +32,7 @@ export default {
   overrides: [
     {
       files: tsFiles,
+      plugins: ['jsdoc'],
       rules: {
         'jsdoc/require-param': 'off',
         'jsdoc/require-yields-type': 'off'

package/src/subconfigs/react.js

@@ -11,6 +11,7 @@ export default {
   overrides: [
     {
       files: jsxFiles,
+      plugins: ['jsdoc'],
       rules: {
         'jsdoc/require-param': 'off',
         'jsdoc/require-returns': 'off'

package/src/subconfigs/react.stylistic.js

@@ -19,7 +19,14 @@ export default {
         'stylistic-js/jsx-child-element-spacing': 'error',
         'stylistic-js/jsx-closing-bracket-location': 'error',
         'stylistic-js/jsx-closing-tag-location': 'error',
-        'react/jsx-curly-brace-presence': ['error', 'never'],
+        'react/jsx-curly-brace-presence': [
+          'error',
+          {
+            children: 'never',
+            propElementValues: 'always',
+            props: 'never'
+          }
+        ],
         'stylistic-js/jsx-curly-newline': 'error',
         'stylistic-js/jsx-curly-spacing': 'error',
         'stylistic-js/jsx-equals-spacing': 'error',

package/src/subconfigs/typescript-type-checked.js

@@ -53,7 +53,6 @@ export default {
         'typescript/no-unnecessary-qualifier': 'error',
         'typescript/no-unnecessary-template-expression': 'error',
         'typescript/no-unnecessary-type-arguments': 'error',
-        'typescript/consistent-type-imports': 'error',
         'typescript/prefer-includes': 'error',
         'typescript/prefer-nullish-coalescing': 'off',
         'typescript/prefer-optional-chain': 'error',

package/src/subconfigs/typescript.js

@@ -12,12 +12,7 @@ export default {
     {
       files: tsFiles,
       plugins: ['typescript'],
-      jsPlugins: [
-        {
-          name: 'trigen',
-          specifier: '@trigen/oxlint-config/plugin'
-        }
-      ],
+      jsPlugins: ['@trigen/oxlint-config/plugin'],
       rules: {
         // Recommended
         'typescript/ban-ts-comment': [
@@ -73,13 +68,21 @@ export default {
             fixMixedExportsWithInlineTypeSpecifier: true
           }
         ],
+        'typescript/consistent-type-imports': 'error',
         'typescript/explicit-module-boundary-types': 'off',
         'typescript/no-dynamic-delete': 'error',
         'typescript/no-extraneous-class': 'error',
-        'typescript/no-invalid-void-type': 'error',
+        'typescript/no-invalid-void-type': [
+          'error',
+          {
+            allowAsThisParameter: true,
+            allowInGenericTypeArguments: true
+          }
+        ],
         'typescript/prefer-for-of': 'error',
         'typescript/prefer-function-type': 'error',
         'typescript/unified-signatures': 'error',
+        'trigen/type-import-style': 'error',
         'trigen/member-ordering': [
           'error',
           {
@@ -108,65 +111,12 @@ export default {
               ]
             }
           }
-        ],
-        'trigen/naming-convention': [
-          'error',
-          {
-            selector: 'default',
-            format: [
-              'camelCase',
-              'PascalCase',
-              'UPPER_CASE'
-            ]
-          },
-          {
-            selector: 'variable',
-            format: [
-              'camelCase',
-              'UPPER_CASE',
-              'PascalCase'
-            ]
-          },
-          {
-            selector: 'function',
-            format: ['camelCase', 'PascalCase']
-          },
-          {
-            selector: 'parameter',
-            format: ['camelCase', 'PascalCase'],
-            leadingUnderscore: 'allow'
-          },
-          {
-            selector: 'typeLike',
-            format: ['PascalCase']
-          },
-          {
-            selector: 'interface',
-            format: ['PascalCase']
-          },
-          {
-            selector: 'enumMember',
-            format: ['PascalCase']
-          },
-          {
-            selector: 'classProperty',
-            format: [
-              'camelCase',
-              'UPPER_CASE',
-              'PascalCase'
-            ],
-            modifiers: ['static']
-          },
-          {
-            selector: ['objectLiteralProperty', 'objectLiteralMethod'],
-            format: null,
-            modifiers: ['requiresQuotes']
-          }
         ]
       }
     },
     {
       files: dtsFiles,
+      plugins: ['import'],
       rules: {
         'import/unambiguous': 'off'
       }

package/src/test.js

@@ -11,6 +11,8 @@ export default {
       env: {
         vitest: true
       },
+      plugins: ['typescript'],
+      jsPlugins: ['@trigen/oxlint-config/plugin'],
       rules: {
         'eslint/max-classes-per-file': 'off',
         'eslint/no-magic-numbers': 'off',
@@ -25,7 +27,10 @@ export default {
         'trigen/import-order': 'off',
         'eslint/prefer-destructuring': 'off',
         'eslint/no-loop-func': 'off',
-        'typescript/no-misused-promises': 'off'
+        'typescript/no-misused-promises': 'off',
+        'eslint/no-use-before-define': 'off',
+        'eslint/no-useless-assignment': 'off',
+        'eslint/no-empty-function': 'off'
 
         // Unsupported by Oxlint
         // 'eslint/camelcase': 'off',