feedline / eslint.config.js

import path from 'node:path'

import {includeIgnoreFile} from '@eslint/compat'
import js from '@eslint/js'
import json from '@eslint/json'
import restrictedGlobals from 'confusing-browser-globals'
import {defineConfig} from 'eslint/config'
import {importX} from 'eslint-plugin-import-x'
import prettier from 'eslint-plugin-prettier/recommended'
import solid from 'eslint-plugin-solid/configs/typescript'
import globals from 'globals'
import tseslint from 'typescript-eslint'

const gitignore = path.resolve(import.meta.dirname, '.gitignore')

export default defineConfig(
  includeIgnoreFile(gitignore, '.gitignore'),

  // all files by default get shared globals
  {
    name: 'javascript basics',
    files: ['**/*.@(js|jsx|ts|tsx)'],
    extends: [js.configs.recommended],

    languageOptions: {
      globals: {
        ...globals.es2024,
        ...globals['shared-node-browser'],
      },
    },

    rules: {
      // eg, `open` is a global, but probably not really intended that way in our code
      'no-restricted-globals': ['error', ...restrictedGlobals],
      'no-unused-vars': ['warn', {varsIgnorePattern: '(?:^_)'}],
    },
  },

  {
    name: 'typescript basics',
    files: ['**/*.@(ts|tsx)'],
    extends: [tseslint.configs.strictTypeChecked],

    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
    rules: {
      // allow leading underscore for marking unused vars
      '@typescript-eslint/no-unused-vars': ['warn', {varsIgnorePattern: '(?:^_)'}],

      // template literals default to calling toString(), but I mean what I say
      '@typescript-eslint/restrict-template-expressions': 'off',

      // I need to be able to do `while(true)`, come on yall...
      '@typescript-eslint/no-unnecessary-condition': ['warn', {allowConstantLoopConditions: 'always'}],

      // this breaks when I want to use a type parameter to allow type checking inline arguments
      // it's "unnecessary type parameters" or an `as` declaration, which I don't like
      '@typescript-eslint/no-unnecessary-type-parameters': 'off',
      '@typescript-eslint/no-unnecessary-type-constraint': 'off',

      // the breaks Promise.withResolvers<void>(),
      // see https://github.com/typescript-eslint/typescript-eslint/issues/8113
      '@typescript-eslint/no-invalid-void-type': 'off',
    },
  },

  // import organization and validation
  {
    name: 'import rules',
    files: ['**/*.@(js|jsx|ts|tsx)'],
    plugins: {'import-x': importX},
    rules: {
      // no file extensions on imports (TypeScript handles resolution)
      'import-x/extensions': ['error', 'never'],

      // merge duplicate imports from same module
      'import-x/no-duplicates': 'warn',

      // all imports at top of file
      'import-x/first': 'error',

      // blank line after import block
      'import-x/newline-after-import': 'error',

      // prevent importing a module from itself
      'import-x/no-self-import': 'error',

      // consistent import ordering:
      // 1. node builtins (node:fs, etc)
      // 2. external packages (zod, solid-js, etc)
      // 3. internal aliases (#lib, #realm, #feedline, #app, #spec)
      // 4. relative imports
      'import-x/order': [
        'warn',
        {
          groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
          pathGroups: [
            {pattern: '#lib/**', group: 'internal', position: 'before'},
            {pattern: '#realm/**', group: 'internal', position: 'before'},
            {pattern: '#feedline/**', group: 'internal', position: 'before'},
            {pattern: '#app/**', group: 'internal', position: 'before'},
            {pattern: '#spec/**', group: 'internal', position: 'after'},
          ],
          pathGroupsExcludedImportTypes: ['builtin'],
          'newlines-between': 'always',
          alphabetize: {order: 'asc', caseInsensitive: true},
        },
      ],

      // detect circular dependencies (can slow down linting on large codebases)
      // set to warn since cycles in realm/feedline could cause subtle sync bugs
      'import-x/no-cycle': ['warn', {maxDepth: 4}],

      // enforce zod/mini over zod or zod/v4 for bundle size
      'no-restricted-imports': [
        'error',
        {
          paths: [
            {name: 'zod', message: "Use 'zod/mini' instead for smaller bundle size."},
            {name: 'zod/v4', message: "Use 'zod/mini' instead for smaller bundle size."},
          ],
        },
      ],
    },
  },

  {
    name: 'node files',
    files: ['src/server/**/*.@(js|jsx|ts|tsx)', 'src/cmd/**/*.@(js|jsx|ts|tsx)'],
    languageOptions: {
      globals: {
        ...globals.es2024,
        ...globals.node,
      },
    },
  },

  {
    name: 'client files',
    files: ['src/**/client/**/*.@(js|ts)', 'src/feedline/**/*.@(js|ts)', 'src/**/*.@(jsx|tsx)'],
    ...solid,
    languageOptions: {
      globals: {
        ...globals.es2024,
        ...globals.browser,
      },
    },
    rules: {
      // our custom reactive query helpers
      'solid/reactivity': ['warn', {customReactiveFunctions: ['makeSignalQuery', 'makeStoreQuery']}],
    },
  },

  // tests don't have jsdoc requirements, and looser any/null assertion restrictions
  {
    files: ['src/**/*.spec.{js,jsx,ts,tsx}', 'src/spec/**/*.{js,ts,jsx,tsx}'],
    rules: {
      '@typescript-eslint/no-explicit-any': 'off',
      '@typescript-eslint/no-unsafe-assignment': 'off',
      '@typescript-eslint/no-unsafe-argument': 'off',
      '@typescript-eslint/no-unsafe-member-access': 'off',
      '@typescript-eslint/no-unsafe-return': 'off',
      '@typescript-eslint/no-non-null-assertion': 'off',
    },
  },

  // json (with comments in some files)
  {
    files: ['**/*.json'],
    ignores: ['package-lock.json'],

    plugins: {json},
    language: 'json/json',
    extends: [json.configs.recommended],
  },
  {
    files: ['tsconfig.json'],
    language: 'json/jsonc',
  },

  // prettier last, so it can turn everything off
  prettier,
)