@trigen/oxlint-config 9.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 - present, TrigenSoftware
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# @trigen/oxlint-config
+
+[![NPM version][npm]][npm-url]
+[![Node version][node]][node-url]
+[![Dependencies status][deps]][deps-url]
+[![Install size][size]][size-url]
+[![Build status][build]][build-url]
+
+[npm]: https://img.shields.io/npm/v/%40trigen/oxlint-config.svg
+[npm-url]: https://npmjs.com/package/@trigen/oxlint-config
+
+[node]: https://img.shields.io/node/v/%40trigen/oxlint-config.svg
+[node-url]: https://nodejs.org
+
+[deps]: https://img.shields.io/librariesio/release/npm/@trigen/oxlint-config
+[deps-url]: https://libraries.io/npm/@trigen%2Foxlint-config
+
+[size]: https://packagephobia.com/badge?p=@trigen/oxlint-config
+[size-url]: https://packagephobia.com/result?p=@trigen/oxlint-config
+
+[build]: https://img.shields.io/github/actions/workflow/status/TrigenSoftware/scripts/tests.yml?branch=main
+[build-url]: https://github.com/TrigenSoftware/scripts/actions
+
+Trigen's Oxlint config.
+
+## Install
+
+```bash
+pnpm add -D oxlint @trigen/oxlint-config
+# or
+yarn add -D oxlint @trigen/oxlint-config
+# or
+npm i -D oxlint @trigen/oxlint-config
+```
+
+## Configure
+
+Create `oxlint.config.ts` with next content:
+
+```ts
+import baseConfig from '@trigen/oxlint-config'
+
+export default baseConfig
+```
+
+### Additional configs
+
+There are additional configs for specific language features:
+
+| Config | Description |
+|--------|-------------|
+| @trigen/oxlint-config/commonjs | Rules for CommonJS modules. |
+| @trigen/oxlint-config/module | Rules for ES modules. |
+| @trigen/oxlint-config/bundler | Rules for ES modules with bundler's module resolution. |
+| @trigen/oxlint-config/test | Rules for test files. |
+| @trigen/oxlint-config/react | Rules for React code. |
+| @trigen/oxlint-config/storybook | Rules for Storybook stories. |
+| @trigen/oxlint-config/typescript | Rules for TypeScript code. |
+| @trigen/oxlint-config/typescript-type-checked | Rules for TypeScript code with type checking. |
+
+Example:
+
+```ts
+import baseConfig from '@trigen/oxlint-config'
+import bundlerConfig from '@trigen/oxlint-config/bundler'
+import reactConfig from '@trigen/oxlint-config/react'
+import typescriptConfig from '@trigen/oxlint-config/typescript-type-checked'
+import testConfig from '@trigen/oxlint-config/test'
+import storybookConfig from '@trigen/oxlint-config/storybook'
+
+export default {
+  extends: [
+    baseConfig,
+    bundlerConfig,
+    reactConfig,
+    typescriptConfig,
+    testConfig,
+    storybookConfig
+  ]
+}
+```

package/oxlint.config.ts

@@ -0,0 +1,15 @@
+import moduleConfig from '@trigen/oxlint-config/module'
+import rootConfig from '../../oxlint.config.ts'
+
+export default {
+  ...rootConfig,
+  extends: [
+    rootConfig,
+    moduleConfig
+  ],
+  rules: {
+    'eslint/no-magic-numbers': 'off',
+    'import/no-default-export': 'off',
+    'import/no-anonymous-default-export': 'off'
+  }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@trigen/oxlint-config",
+  "type": "module",
+  "version": "9.0.0",
+  "description": "Trigen's Oxlint config.",
+  "author": "dangreen",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TrigenSoftware/scripts.git",
+    "directory": "packages/oxlint-config"
+  },
+  "bugs": {
+    "url": "https://github.com/TrigenSoftware/scripts/issues"
+  },
+  "keywords": [
+    "oxlint",
+    "oxlint-config"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": "./src/index.js",
+    "./plugin": "./src/plugin/index.js",
+    "./*": "./src/*.js"
+  },
+  "peerDependencies": {
+    "oxlint": ">=1.0.0",
+    "oxlint-tsgolint": ">=0.23.0"
+  },
+  "peerDependenciesMeta": {
+    "oxlint-tsgolint": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@stylistic/eslint-plugin": "^5.5.0"
+  }
+}

package/src/bundler.js

@@ -0,0 +1,27 @@
+/**
+ * Bundler override
+ */
+
+import {
+  commonjsFiles,
+  not
+} from './subconfigs/files.js'
+
+export default {
+  overrides: [
+    {
+      files: not(commonjsFiles),
+      plugins: ['import'],
+      rules: {
+        'import/unambiguous': 'error',
+        'import/no-commonjs': [
+          'error',
+          {
+            allowRequire: false,
+            allowPrimitiveModules: false
+          }
+        ]
+      }
+    }
+  ]
+}

package/src/commonjs.js

@@ -0,0 +1,13 @@
+/**
+ * CommonJS override
+ */
+
+import moduleConfig from './module.js'
+import { moduleFiles } from './subconfigs/files.js'
+
+export default {
+  overrides: moduleConfig.overrides.map(override => ({
+    ...override,
+    files: moduleFiles
+  }))
+}

package/src/index.js

@@ -0,0 +1,19 @@
+/**
+ * Combine all basic configs
+ */
+
+import basicConfig from './subconfigs/basic.js'
+import importConfig from './subconfigs/import.js'
+import baseStylisticConfig from './subconfigs/base.stylistic.js'
+import jsdocConfig from './subconfigs/jsdoc.js'
+import configsConfig from './subconfigs/configs.js'
+
+export default {
+  extends: [
+    basicConfig,
+    importConfig,
+    baseStylisticConfig,
+    jsdocConfig,
+    configsConfig
+  ]
+}

package/src/module.js

@@ -0,0 +1,22 @@
+/**
+ * ESM override
+ */
+
+import bundlerConfig from './bundler.js'
+import {
+  commonjsFiles,
+  not
+} from './subconfigs/files.js'
+
+export default {
+  overrides: [
+    ...bundlerConfig.overrides,
+    {
+      files: not(commonjsFiles),
+      plugins: ['import'],
+      rules: {
+        'import/extensions': ['error', 'ignorePackages']
+      }
+    }
+  ]
+}

package/src/plugin/import-order.js

@@ -0,0 +1,357 @@
+import { builtinModules } from 'node:module'
+
+const builtinModuleNames = new Set(
+  builtinModules.flatMap(moduleName => [
+    moduleName,
+    moduleName.replace(/^node:/, '')
+  ])
+)
+const defaultGroups = [
+  'builtin',
+  'external',
+  'internal',
+  'parent',
+  'sibling',
+  'index'
+]
+const defaultOptions = {
+  'groups': defaultGroups,
+  'pathGroups': [],
+  'newlines-between': 'ignore',
+  'typeImports': 'none'
+}
+
+function isBuiltin(source) {
+  return source.startsWith('node:')
+    || builtinModuleNames.has(source.split('/')[0])
+}
+
+function isExternal(source) {
+  return !source.startsWith('.')
+    && !source.startsWith('/')
+    && !source.startsWith('~')
+    && !source.startsWith('#')
+    && !source.startsWith('@/')
+}
+
+function isIndex(source) {
+  return source === '.'
+    || source === './'
+    || source === './index'
+    || source.startsWith('./index.')
+}
+
+function getGroup(source) {
+  if (isBuiltin(source)) {
+    return 'builtin'
+  }
+
+  if (isExternal(source)) {
+    return 'external'
+  }
+
+  if (source.startsWith('../')) {
+    return 'parent'
+  }
+
+  if (isIndex(source)) {
+    return 'index'
+  }
+
+  if (source.startsWith('./')) {
+    return 'sibling'
+  }
+
+  return 'internal'
+}
+
+function matchesPathGroup(source, pattern) {
+  if (pattern === '~/**') {
+    return source.startsWith('~/')
+  }
+
+  if (pattern === '#*/**') {
+    return /^#[^/]+\/.+/.test(source)
+  }
+
+  if (pattern === '@/**') {
+    return source.startsWith('@/') || source === '@'
+  }
+
+  return false
+}
+
+function getPathGroup(source, pathGroups) {
+  return pathGroups.find(({ pattern }) => matchesPathGroup(source, pattern))
+}
+
+function isTypeImport(node) {
+  return node.importKind === 'type'
+    || (
+      node.specifiers.length > 0
+      && node.specifiers.every(specifier => specifier.importKind === 'type')
+    )
+}
+
+function getTypeRank(node, options) {
+  if (options.typeImports === 'first') {
+    return isTypeImport(node) ? 0 : 1
+  }
+
+  if (options.typeImports === 'last') {
+    return isTypeImport(node) ? 1 : 0
+  }
+
+  return 0
+}
+
+function getImportKind(node) {
+  return isTypeImport(node) ? 'type' : 'value'
+}
+
+function getRank(node, options) {
+  const source = node.source.value
+  const pathGroup = getPathGroup(source, options.pathGroups)
+  const group = pathGroup?.group ?? getGroup(source)
+  const groupIndex = options.groups.indexOf(group)
+  const positionRank = pathGroup?.position === 'before'
+    ? 0
+    : pathGroup?.position === 'after'
+      ? 2
+      : 1
+
+  return {
+    group,
+    groupIndex: groupIndex === -1 ? Number.POSITIVE_INFINITY : groupIndex,
+    positionRank,
+    importKind: getImportKind(node),
+    typeRank: getTypeRank(node, options)
+  }
+}
+
+function compareRanks(left, right) {
+  return left.groupIndex - right.groupIndex
+    || left.positionRank - right.positionRank
+    || left.typeRank - right.typeRank
+}
+
+function getLinebreak(text) {
+  return text.includes('\r\n') ? '\r\n' : '\n'
+}
+
+function getMessage(left, right) {
+  if (
+    left.groupIndex === right.groupIndex
+    && left.positionRank === right.positionRank
+    && left.typeRank !== right.typeRank
+  ) {
+    return `Expected ${right.importKind} import to come before ${left.importKind} import.`
+  }
+
+  return `Expected ${right.group} import to come before ${left.group} import.`
+}
+
+function getOptions(context) {
+  return {
+    ...defaultOptions,
+    ...context.options[0],
+    groups: context.options[0]?.groups ?? defaultGroups,
+    pathGroups: context.options[0]?.pathGroups ?? []
+  }
+}
+
+function getImportItems(imports, options) {
+  return imports.map((node, index) => ({
+    index,
+    node,
+    rank: getRank(node, options)
+  }))
+}
+
+function compareImportItems(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 (compareRanks(previousItem.rank, item.rank) > 0) {
+      return [
+        previousItem,
+        item
+      ]
+    }
+  }
+
+  return null
+}
+
+function hasInvalidNewlines(items, options) {
+  if (options['newlines-between'] === 'ignore') {
+    return false
+  }
+
+  return items.some((item, index) => {
+    if (index === 0) {
+      return false
+    }
+
+    const previousItem = items[index - 1]
+    const hasEmptyLine = item.node.loc.start.line - previousItem.node.loc.end.line > 1
+
+    return options['newlines-between'] === 'never'
+      ? hasEmptyLine
+      : !hasEmptyLine
+  })
+}
+
+function hasInnerComments(sourceCode, items) {
+  const firstNode = items[0].node
+  const lastNode = items.at(-1).node
+
+  return sourceCode.getAllComments().some(comment => comment.range[0] > firstNode.range[0]
+    && comment.range[1] < lastNode.range[1])
+}
+
+function hasSideEffectImports(items) {
+  return items.some(({ node }) => node.specifiers.length === 0)
+}
+
+function canFix(sourceCode, items) {
+  return !hasSideEffectImports(items)
+    && !hasInnerComments(sourceCode, items)
+}
+
+function getFixedImportText(sourceCode, items, options) {
+  const linebreak = getLinebreak(sourceCode.text)
+  const separator = options['newlines-between'] === 'always'
+    ? `${linebreak}${linebreak}`
+    : linebreak
+
+  return [...items]
+    .sort(compareImportItems)
+    .map(({ node }) => sourceCode.getText(node))
+    .join(separator)
+}
+
+function getImportBlockRange(items) {
+  return [
+    items[0].node.range[0],
+    items.at(-1).node.range[1]
+  ]
+}
+
+export default {
+  meta: {
+    type: 'layout',
+    fixable: 'code',
+    docs: {
+      description: 'Enforce import order by configured groups.'
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          'groups': {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          },
+          'pathGroups': {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                pattern: {
+                  type: 'string'
+                },
+                group: {
+                  type: 'string'
+                },
+                position: {
+                  enum: [
+                    'before',
+                    'after'
+                  ]
+                }
+              },
+              required: ['pattern', 'group'],
+              additionalProperties: true
+            }
+          },
+          'newlines-between': {
+            enum: [
+              'ignore',
+              'always',
+              'never'
+            ]
+          },
+          'typeImports': {
+            enum: [
+              'first',
+              'last',
+              'none'
+            ]
+          }
+        },
+        additionalProperties: true
+      }
+    ]
+  },
+  create(context) {
+    const options = getOptions(context)
+    const imports = []
+
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value
+
+        if (typeof source !== 'string') {
+          return
+        }
+
+        imports.push(node)
+      },
+      'Program:exit'(node) {
+        if (imports.length < 2) {
+          return
+        }
+
+        const sourceCode = context.sourceCode
+        const items = getImportItems(imports, options)
+        const unorderedPair = getFirstUnorderedPair(items)
+        const invalidNewlines = hasInvalidNewlines(items, options)
+
+        if (!unorderedPair && !invalidNewlines) {
+          return
+        }
+
+        const fix = canFix(sourceCode, items)
+          ? fixer => fixer.replaceTextRange(
+            getImportBlockRange(items),
+            getFixedImportText(sourceCode, items, options)
+          )
+          : null
+        const [
+          previousItem,
+          item
+        ] = unorderedPair ?? [
+          items[0],
+          items[1]
+        ]
+
+        context.report({
+          node,
+          message: unorderedPair
+            ? getMessage(previousItem.rank, item.rank)
+            : 'Import declarations have invalid empty lines.',
+          fix
+        })
+      }
+    }
+  }
+}

package/src/plugin/index.js

@@ -0,0 +1,16 @@
+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'
+
+export default {
+  meta: {
+    name: '@trigen/oxlint-config/plugin'
+  },
+  rules: {
+    'import-order': importOrderRule,
+    'member-ordering': memberOrderingRule,
+    'named-import-order': namedImportOrderRule,
+    'naming-convention': namingConventionRule
+  }
+}