@st1ggy/linter-config 7.3.0 → 7.4.0

package/src/oxlint/create-config.js

@@ -0,0 +1,40 @@
+import { fileURLToPath } from 'node:url'
+
+const pluginFiles = {
+  'eslint-js': 'eslint-core',
+  'stylistic-js': 'stylistic',
+  'import-x-js': 'import-x',
+  prettier: 'prettier',
+  'unicorn-js': 'unicorn',
+  sonarjs: 'sonarjs',
+  'typescript-js': 'typescript',
+  'react-js': 'react',
+  'react-hooks-js': 'react-hooks',
+  'next-js': 'next',
+  solid: 'solid',
+  svelte: 'svelte',
+  astro: 'astro',
+}
+
+export function createOxlintConfig(bundle) {
+  return {
+    categories: {
+      correctness: 'off',
+      suspicious: 'off',
+      pedantic: 'off',
+      perf: 'off',
+      style: 'off',
+      restriction: 'off',
+      nursery: 'off',
+    },
+    options: { typeAware: true },
+    ignorePatterns: ['**/node_modules/**', '**/.git/**'],
+    plugins: bundle.plugins,
+    settings: bundle.settings,
+    jsPlugins: bundle.jsPlugins.map((name) => ({
+      name,
+      specifier: fileURLToPath(new URL(`plugins/${pluginFiles[name]}.js`, import.meta.url)),
+    })),
+    overrides: bundle.overrides.map(({ files, profile }) => ({ files, ...bundle.profiles[profile] })),
+  }
+}

package/src/oxlint/index.d.ts

@@ -0,0 +1,49 @@
+// Keep Oxlint types in a separate ambient declaration file so existing ESLint
+// consumers do not need to install the optional Oxlint peer.
+declare module '@st1ggy/linter-config/common-ox' {
+  import type { OxlintConfig } from 'oxlint'
+
+  const config: OxlintConfig
+
+  export default config
+}
+
+declare module '@st1ggy/linter-config/react-ox' {
+  import type { OxlintConfig } from 'oxlint'
+
+  const config: OxlintConfig
+
+  export default config
+}
+
+declare module '@st1ggy/linter-config/solid-ox' {
+  import type { OxlintConfig } from 'oxlint'
+
+  const config: OxlintConfig
+
+  export default config
+}
+
+declare module '@st1ggy/linter-config/next-ox' {
+  import type { OxlintConfig } from 'oxlint'
+
+  const config: OxlintConfig
+
+  export default config
+}
+
+declare module '@st1ggy/linter-config/svelte-ox' {
+  import type { OxlintConfig } from 'oxlint'
+
+  const config: OxlintConfig
+
+  export default config
+}
+
+declare module '@st1ggy/linter-config/astro-ox' {
+  import type { OxlintConfig } from 'oxlint'
+
+  const config: OxlintConfig
+
+  export default config
+}

package/src/oxlint/oxlint.config.astro.js

@@ -0,0 +1,4 @@
+import bundle from './configs/config.astro.js'
+import { createOxlintConfig } from './create-config.js'
+
+export default createOxlintConfig(bundle)

package/src/oxlint/oxlint.config.common.js

@@ -0,0 +1,4 @@
+import bundle from './configs/config.common.js'
+import { createOxlintConfig } from './create-config.js'
+
+export default createOxlintConfig(bundle)

package/src/oxlint/oxlint.config.next.js

@@ -0,0 +1,4 @@
+import bundle from './configs/config.next.js'
+import { createOxlintConfig } from './create-config.js'
+
+export default createOxlintConfig(bundle)

package/src/oxlint/oxlint.config.react.js

@@ -0,0 +1,4 @@
+import bundle from './configs/config.react.js'
+import { createOxlintConfig } from './create-config.js'
+
+export default createOxlintConfig(bundle)

package/src/oxlint/oxlint.config.solid.js

@@ -0,0 +1,4 @@
+import bundle from './configs/config.solid.js'
+import { createOxlintConfig } from './create-config.js'
+
+export default createOxlintConfig(bundle)

package/src/oxlint/oxlint.config.svelte.js

@@ -0,0 +1,4 @@
+import bundle from './configs/config.svelte.js'
+import { createOxlintConfig } from './create-config.js'
+
+export default createOxlintConfig(bundle)

package/src/oxlint/plugins/astro.js

@@ -0,0 +1,41 @@
+import astro, { rules as astroRules } from 'eslint-plugin-astro'
+import { readFileSync } from 'node:fs'
+
+// Only the six script-only rules are enabled. The native linter still parses
+// the JavaScript; this adapter neither creates a TS Program nor parses templates.
+function frontmatterContext(context) {
+  const filename = context.physicalFilename ?? context.filename
+  const source = readFileSync(filename, 'utf8')
+  const frontmatter = /^\u{FEFF}?---[^\S\n]*\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(source)?.[1]
+
+  if (frontmatter === undefined || frontmatter.trim() !== context.sourceCode.text.trim()) {
+    return null
+  }
+
+  const sourceCode = Object.create(context.sourceCode)
+  const wrapped = Object.create(context)
+
+  Object.defineProperty(sourceCode, 'parserServices', {
+    value: { ...context.sourceCode.parserServices, isAstro: true },
+  })
+  Object.defineProperty(wrapped, 'sourceCode', { value: sourceCode, configurable: true })
+
+  return wrapped
+}
+
+export default {
+  ...astro,
+  rules: Object.fromEntries(
+    Object.entries(astroRules).map(([name, rule]) => [
+      name,
+      {
+        ...rule,
+        create(context) {
+          const wrapped = frontmatterContext(context)
+
+          return wrapped ? rule.create(wrapped) : {}
+        },
+      },
+    ]),
+  ),
+}

package/src/oxlint/plugins/eslint-core.js

@@ -0,0 +1,5 @@
+/* eslint-disable sonarjs/deprecation -- Only rule definitions are reused; Oxlint executes them without ESLint. */
+
+import { builtinRules } from 'eslint/use-at-your-own-risk'
+
+export default { rules: Object.fromEntries(builtinRules) }

package/src/oxlint/plugins/fresh-source-code.js

@@ -0,0 +1,30 @@
+// Some plugins key file-level caches by SourceCode identity. Give each rule
+// invocation a fresh identity while preserving the native SourceCode methods.
+export function withFreshSourceCode(plugin) {
+  return {
+    ...plugin,
+    rules: Object.fromEntries(
+      Object.entries(plugin.rules).map(([name, rule]) => [
+        name,
+        {
+          ...rule,
+          create(context) {
+            const sourceCode = new Proxy(context.sourceCode, {
+              get(target, property) {
+                return Reflect.get(target, property, target)
+              },
+            })
+            const wrapped = Object.create(context)
+
+            Object.defineProperties(wrapped, {
+              sourceCode: { value: sourceCode, configurable: true },
+              getSourceCode: { value: () => sourceCode, configurable: true },
+            })
+
+            return rule.create(wrapped)
+          },
+        },
+      ]),
+    ),
+  }
+}

package/src/oxlint/plugins/import-x.js

@@ -0,0 +1,38 @@
+import importPlugin, { rules as importRules } from 'eslint-plugin-import-x'
+
+function scopedContext(context) {
+  const scopes = context.settings['st1ggy/import-scopes'] ?? []
+  const selected = scopes.findLast((scope) => context.filename.endsWith(`.${scope.extension}`))
+
+  if (!selected) {
+    return context
+  }
+
+  const defaults = context.settings['st1ggy/import-defaults'] ?? {}
+  const settings = { ...context.settings }
+
+  for (const [name, value] of Object.entries(selected.settings)) {
+    if (JSON.stringify(settings[name]) === JSON.stringify(defaults[name])) {
+      settings[name] = value
+    }
+  }
+
+  const wrapped = Object.create(context)
+
+  Object.defineProperty(wrapped, 'settings', { value: settings, configurable: true })
+
+  return wrapped
+}
+
+export default {
+  ...importPlugin,
+  rules: Object.fromEntries(
+    Object.entries(importRules).map(([name, rule]) => [
+      name,
+      {
+        ...rule,
+        create: (context) => rule.create(scopedContext(context)),
+      },
+    ]),
+  ),
+}

package/src/oxlint/plugins/next.js

@@ -0,0 +1 @@
+export { default } from '@next/eslint-plugin-next'

package/src/oxlint/plugins/prettier.js

@@ -0,0 +1 @@
+export { default } from 'eslint-plugin-prettier'

package/src/oxlint/plugins/react-hooks.js

@@ -0,0 +1 @@
+export { default } from 'eslint-plugin-react-hooks'

package/src/oxlint/plugins/react.js

@@ -0,0 +1 @@
+export { default } from 'eslint-plugin-react'

package/src/oxlint/plugins/solid.js

@@ -0,0 +1 @@
+export { default } from 'eslint-plugin-solid'

package/src/oxlint/plugins/sonarjs.js

@@ -0,0 +1,5 @@
+import sonarjs from 'eslint-plugin-sonarjs'
+
+import { withFreshSourceCode } from './fresh-source-code.js'
+
+export default withFreshSourceCode(sonarjs)

package/src/oxlint/plugins/stylistic.js

@@ -0,0 +1 @@
+export { default } from '@stylistic/eslint-plugin'

package/src/oxlint/plugins/svelte.js

@@ -0,0 +1,42 @@
+import svelte from 'eslint-plugin-svelte'
+
+const innerDeclarations = svelte.rules['no-inner-declarations']
+
+// The source preset treats Svelte scripts as strict modules. Oxlint's extracted
+// import-free chunks use script scope. Preserve the original rule's strictness
+// without modifying the native AST or scope objects used by other rules.
+export default {
+  ...svelte,
+  rules: {
+    ...svelte.rules,
+    'no-inner-declarations': {
+      ...innerDeclarations,
+      create(context) {
+        const sourceCode = Object.create(context.sourceCode)
+
+        Object.defineProperty(sourceCode, 'getScope', {
+          value(node) {
+            const scope = context.sourceCode.getScope(node)
+
+            if (!scope.upper) {
+              return scope
+            }
+
+            const upper = Object.create(scope.upper)
+            const wrapped = Object.create(scope)
+
+            Object.defineProperty(upper, 'isStrict', { value: true })
+            Object.defineProperty(wrapped, 'upper', { value: upper })
+
+            return wrapped
+          },
+        })
+        const wrapped = Object.create(context)
+
+        Object.defineProperty(wrapped, 'sourceCode', { value: sourceCode, configurable: true })
+
+        return innerDeclarations.create(wrapped)
+      },
+    },
+  },
+}

package/src/oxlint/plugins/typescript.js

@@ -0,0 +1 @@
+export { plugin as default } from 'typescript-eslint'

package/src/oxlint/plugins/unicorn.js

@@ -0,0 +1,5 @@
+import unicorn from 'eslint-plugin-unicorn'
+
+import { withFreshSourceCode } from './fresh-source-code.js'
+
+export default withFreshSourceCode(unicorn)

package/src/oxlint/stacks.js

@@ -0,0 +1,11 @@
+export const OX_VERSIONS = { oxlint: '1.86.0', 'oxlint-tsgolint': '7.0.2003' }
+
+// Only integrations actually used by the corresponding generated bundle.
+export const OX_FRAMEWORK_PACKAGES = {
+  common: [],
+  react: ['eslint-plugin-react', 'eslint-plugin-react-hooks'],
+  solid: ['eslint-plugin-solid'],
+  next: ['@next/eslint-plugin-next', 'eslint-plugin-react', 'eslint-plugin-react-hooks'],
+  svelte: ['eslint-plugin-svelte', 'prettier-plugin-svelte'],
+  astro: ['eslint-plugin-astro', 'prettier-plugin-astro'],
+}

package/scripts/solid-config.test.mjs

@@ -1,134 +0,0 @@
-/* eslint-disable unicorn/no-incorrect-template-string-interpolation -- Fixtures contain literal JSX expressions. */
-
-import { ESLint } from 'eslint'
-import assert from 'node:assert/strict'
-import { mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import path from 'node:path'
-import test from 'node:test'
-
-import solidConfig from '@st1ggy/linter-config/eslint-solid'
-
-import prettierConfig from '../src/prettier/prettier.config.common.js'
-
-import { resolveStackKey, run, stackPackages } from './linter-init-core.mjs'
-
-function createProject(context) {
-  const prefix = path.join(tmpdir(), 'linter-solid-')
-  const directory = realpathSync(mkdtempSync(prefix))
-
-  context.after(() => rmSync(directory, { recursive: true, force: true }))
-  writeFileSync(
-    path.join(directory, 'tsconfig.json'),
-    JSON.stringify({ compilerOptions: { allowJs: true, jsx: 'preserve', noEmit: true }, include: ['*.jsx', '*.tsx'] }),
-  )
-  writeFileSync(path.join(directory, '.prettierrc.json'), JSON.stringify(prettierConfig))
-
-  return directory
-}
-
-async function lintSource(context, extension, source) {
-  const directory = createProject(context)
-  const filePath = path.join(directory, `component.${extension}`)
-
-  writeFileSync(filePath, source)
-  const eslint = new ESLint({
-    cwd: directory,
-    overrideConfigFile: true,
-    overrideConfig: [...solidConfig, { languageOptions: { parserOptions: { tsconfigRootDir: directory } } }],
-  })
-  const [result] = await eslint.lintFiles([filePath])
-
-  assert.equal(result.fatalErrorCount, 0, JSON.stringify(result.messages))
-
-  return result.messages
-}
-
-test('Solid preset is available through both public exports', async () => {
-  const { eslintSolid } = await import('@st1ggy/linter-config')
-
-  assert.equal(eslintSolid, solidConfig)
-})
-
-for (const extension of ['jsx', 'tsx']) {
-  const annotation = extension === 'tsx' ? ': { name: string }' : ''
-
-  test(`Solid preset accepts reactive props in ${extension}`, async (context) => {
-    const messages = await lintSource(
-      context,
-      extension,
-      `export const Greeting = (props${annotation}) => <p>{props.name}</p>\n`,
-    )
-
-    assert.deepEqual(messages, [])
-  })
-
-  test(`Solid preset reports destructured props in ${extension}`, async (context) => {
-    const messages = await lintSource(
-      context,
-      extension,
-      `export const Greeting = ({ name }${annotation}) => <p>{name}</p>\n`,
-    )
-
-    assert.ok(messages.some((message) => message.ruleId === 'solid/no-destructure' && message.severity === 2))
-  })
-
-  test(`Solid preset reports lost reactivity in ${extension}`, async (context) => {
-    const messages = await lintSource(
-      context,
-      extension,
-      `export const Greeting = (props${annotation}) => {
-  const name = props.name
-
-  return <p>{name}</p>
-}
-`,
-    )
-
-    assert.ok(messages.some((message) => message.ruleId === 'solid/reactivity' && message.severity === 1))
-  })
-
-  test(`Solid preset recognizes components used in ${extension}`, async (context) => {
-    const messages = await lintSource(
-      context,
-      extension,
-      'const Greeting = () => <p>Hello</p>\n\nexport const App = () => <Greeting />\n',
-    )
-
-    assert.deepEqual(messages, [])
-  })
-}
-
-test('Solid stack generates wrappers, preserves them on init and replaces them on migrate', (context) => {
-  const directory = createProject(context)
-  const expected = {
-    'eslint.config.js': "export { default } from '@st1ggy/linter-config/eslint-solid';\n",
-    'prettier.config.js': "export { default } from '@st1ggy/linter-config/prettier-common';\n",
-    'stylelint.config.js': "export { default } from '@st1ggy/linter-config/stylelint-scss';\n",
-  }
-
-  run('init', directory, 'solid', { quiet: true })
-
-  for (const [file, content] of Object.entries(expected)) {
-    assert.equal(readFileSync(path.join(directory, file), 'utf8'), content)
-    writeFileSync(path.join(directory, file), '// existing config\n')
-  }
-
-  run('init', directory, 'solid', { quiet: true })
-
-  for (const file of Object.keys(expected)) {
-    assert.equal(readFileSync(path.join(directory, file), 'utf8'), '// existing config\n')
-  }
-
-  run('migrate', directory, 'solid', { quiet: true })
-
-  for (const [file, content] of Object.entries(expected)) {
-    assert.equal(readFileSync(path.join(directory, file), 'utf8'), content)
-  }
-})
-
-test('Solid stack selects its integration plugin and rejects conflicting flags', () => {
-  assert.equal(resolveStackKey({ solid: true }), 'solid')
-  assert.deepEqual(stackPackages('solid'), ['@st1ggy/linter-config', 'eslint-plugin-solid'])
-  assert.throws(() => resolveStackKey({ solid: true, react: true }), /Pick at most one stack flag/)
-})