eslint.config.js

import eslint from '@eslint/js'
import tseslint from 'typescript-eslint'
import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended'

export default tseslint.config(
  eslint.configs.recommended,
  tseslint.configs.recommendedTypeChecked,
  tseslint.configs.strictTypeChecked,
  tseslint.configs.stylisticTypeChecked,
  eslintPluginPrettierRecommended,
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname
      }
    },
    linterOptions: {
      reportUnusedDisableDirectives: 'error'
    }
  },
  {
    ignores: [
      'node_modules',
      'dist',
      'coverage',
      '*.md',
      'docs',
      'bin',
      '*.lock',
      'eslint.config.js',
      '**/.bunup-dts-*',
      '**/*.d.ts',
      '**/tsconfig.tsbuildinfo',
      '**/bun.lockb',
      'packages/site/.astro/**',
      '**/.astro/**',
      '**/.netlify/**',
      '**/public/**',
      '**/.ladle/**',
      '**/__tests__/fixtures/dist/**',
      '**/__tests__/fixtures/*.ts',
      '**/*.generated.ts',
      'apps/expo/**'
    ]
  },
  {
    rules: {
      '@typescript-eslint/no-misused-spread': 'off',
      '@typescript-eslint/no-explicit-any': 'error',
      '@typescript-eslint/restrict-template-expressions': 'off',
      '@typescript-eslint/no-unused-vars': [
        'error',
        {
          argsIgnorePattern: '^_',
          varsIgnorePattern: '^_',
          caughtErrorsIgnorePattern: '^_'
        }
      ],
      '@typescript-eslint/naming-convention': [
        'error',
        {
          selector: 'interface',
          format: ['PascalCase']
        },
        {
          selector: 'typeAlias',
          format: ['PascalCase']
        },
        {
          selector: 'enum',
          format: ['PascalCase']
        },
        {
          selector: 'enumMember',
          format: ['UPPER_CASE']
        }
      ],
      '@typescript-eslint/explicit-function-return-type': [
        'error',
        {
          allowExpressions: true,
          allowTypedFunctionExpressions: true,
          allowHigherOrderFunctions: true
        }
      ],
      '@typescript-eslint/explicit-member-accessibility': [
        'error',
        {
          accessibility: 'explicit',
          overrides: {
            accessors: 'no-public',
            constructors: 'no-public',
            methods: 'explicit',
            properties: 'explicit',
            parameterProperties: 'explicit'
          }
        }
      ],
      '@typescript-eslint/prefer-readonly': 'error',
      '@typescript-eslint/prefer-readonly-parameter-types': 'off',
      '@typescript-eslint/consistent-type-imports': [
        'error',
        {
          prefer: 'type-imports',
          fixStyle: 'separate-type-imports'
        }
      ],
      '@typescript-eslint/consistent-type-exports': 'error',
      // Note: consistent-type-assertions intentionally omitted - policy is to prefer type guards
      // The dangerous `as unknown as T` pattern is banned by no-restricted-syntax below

      // Code quality and best practices
      'func-names': ['error', 'as-needed'],
      'no-restricted-exports': 'error',
      'no-console': ['warn', { allow: ['warn', 'error'] }],
      'no-debugger': 'error',
      'no-alert': 'error',
      'prefer-const': 'error',
      'no-var': 'error',
      'object-shorthand': 'error',
      'prefer-arrow-callback': 'error',
      'sort-imports': [
        'error',
        {
          ignoreCase: false,
          ignoreDeclarationSort: true,
          ignoreMemberSort: false,
          memberSyntaxSortOrder: ['none', 'all', 'multiple', 'single'],
          allowSeparatedGroups: true
        }
      ],
      'no-eval': 'error',
      'no-implied-eval': 'error',
      'no-new-func': 'error',
      'no-script-url': 'error',
      'no-await-in-loop': 'warn',
      'prefer-object-spread': 'error',
      'no-restricted-syntax': [
        'error',
        {
          selector: 'TSAsExpression > TSUnknownKeyword',
          message: 'Avoid `as unknown as T` pattern. Use type guards instead.'
        },
        {
          selector: 'VariableDeclaration[kind="let"]',
          message: 'Use `const` instead of `let`. Prefer immutable bindings.'
        }
      ],
      'no-restricted-imports': [
        'error',
        {
          patterns: [
            {
              group: ['*/src/lib/*', '*/src/internal/*', '*/src/roll/*'],
              message:
                'Import from the package public API instead (e.g. @randsum/roller, not internal paths).'
            }
          ]
        }
      ]
    }
  },
  {
    // Override for .mjs files (Node.js config files)
    files: ['**/*.mjs'],
    languageOptions: {
      globals: {
        process: 'readonly',
        __dirname: 'readonly',
        __filename: 'readonly',
        Buffer: 'readonly',
        global: 'readonly',
        console: 'readonly',
        module: 'readonly',
        require: 'readonly',
        exports: 'readonly'
      }
    }
  },
  {
    // Override for test files and test-utils package
    // ESLint's type-aware rules can't resolve types from workspace packages properly
    // Internal path imports are allowed in tests to enable unit testing of internals
    files: ['**/__tests__/**/*.ts', '**/test-utils/**/*.ts'],
    rules: {
      '@typescript-eslint/no-unsafe-assignment': 'off',
      '@typescript-eslint/no-unsafe-call': 'off',
      '@typescript-eslint/no-unsafe-member-access': 'off',
      '@typescript-eslint/no-unsafe-argument': 'off',
      '@typescript-eslint/no-unsafe-return': 'off',
      '@typescript-eslint/no-unnecessary-condition': 'off',
      '@typescript-eslint/no-non-null-assertion': 'off',
      'no-restricted-imports': 'off'
    }
  },
  {
    // Override for build scripts — internal imports, sequential IO, and console output are expected
    files: ['**/build.ts'],
    rules: {
      'no-restricted-imports': 'off',
      'no-await-in-loop': 'off',
      'no-console': 'off'
    }
  },
  {
    // Tokenize isolation: the @randsum/roller/tokenize subpath must bundle only
    // modifier schemas (*Schema), never modifier behaviors (*Modifier). The
    // tokenize import graph is reachable through packages/roller/src/notation/**
    // plus tokenize.ts itself. Banning *Modifier imports within that subtree
    // protects ESM tree-shaking. See packages/roller/CLAUDE.md "Tokenize
    // Isolation Invariant" and docs/adr/ADR-007-modifier-co-location.md.
    files: [
      // Duplicated patterns so the override applies whether ESLint is invoked
      // from the monorepo root (`bun run lint`) or from inside packages/roller
      // (`bun run --filter @randsum/roller lint`, which cds into the package).
      'packages/roller/src/notation/**/*.ts',
      'packages/roller/src/tokenize.ts',
      'src/notation/**/*.ts',
      'src/tokenize.ts'
    ],
    rules: {
      'no-restricted-imports': [
        'error',
        {
          patterns: [
            {
              group: ['**/modifiers/*', '**/modifiers'],
              importNamePattern: 'Modifier$',
              message:
                'Tokenize-reachable files must not import *Modifier (behavior) symbols — only *Schema exports. Importing a behavior here breaks tree-shaking and inflates dist/tokenize.js. See packages/roller/CLAUDE.md "Tokenize Isolation Invariant".'
            }
          ]
        }
      ]
    }
  }
)