eslint.config.ts

import svelteEslint from 'eslint-plugin-svelte'
import svelteParser from 'svelte-eslint-parser'
import tsESLint, { type ConfigWithExtends } from 'typescript-eslint'

console.log('⚙️  Loading ESLint config...')

const IGNORE_PATTERNS = [
	'.DS_Store',
	'.env',
	'.env.*',
	'.github',
	'.vscode',
	'**/node_modules/**',

	// Blockbench Plugin Template
	'dist/**/*',

	// Ignore files for PNPM, NPM and YARN
	'pnpm-lock.yaml',
	'package-lock.json',
	'yarn.lock',
]

const CUSTOM_RULES: ConfigWithExtends['rules'] = {
	// ESLint
	semi: ['error', 'never'],
	'prefer-const': 'warn',
	'no-fallthrough': 'off',
	'no-mixed-spaces-and-tabs': 'off',
	'no-unreachable': 'warn',
	'@typescript-eslint/no-unused-vars': [
		'warn',
		{
			vars: 'local',
			args: 'after-used',
			argsIgnorePattern: '^_',
			ignoreRestSiblings: true,
		},
	],
	// Svelte
	'svelte/html-quotes': ['warn', { prefer: 'double' }],
	'svelte/block-lang': ['error', { script: ['ts', null], style: null }],
	'svelte/comment-directive': ['error', { reportUnusedDisableDirectives: true }],
	'svelte/valid-compile': ['error', { ignoreWarnings: true }],
	// TypeScript
	'@typescript-eslint/no-explicit-any': 'off',
	'@typescript-eslint/no-floating-promises': ['error', { ignoreVoid: true }],
	'@typescript-eslint/array-type': ['warn', { default: 'array-simple' }],
	'@typescript-eslint/consistent-indexed-object-style': ['warn', 'record'],
	'@typescript-eslint/consistent-generic-constructors': 'warn',
	'@typescript-eslint/no-namespace': 'off',
	'@typescript-eslint/restrict-template-expressions': 'off',
	'@typescript-eslint/no-unsafe-member-access': 'off',
	'@typescript-eslint/no-unsafe-assignment': 'off',
	'@typescript-eslint/ban-ts-comment': 'off',
	'@typescript-eslint/require-await': 'warn',
	'@typescript-eslint/no-unsafe-call': 'off',
	'@typescript-eslint/unbound-method': 'off',
	'@typescript-eslint/no-non-null-assertion': 'off',
	'@typescript-eslint/triple-slash-reference': 'off',
	// Naming conventions
	'@typescript-eslint/naming-convention': [
		'warn',
		{
			// DFU Version imports
			selector: ['import'],
			modifiers: ['default'],
			filter: {
				regex: '(old_)?v[\\d_]+(_pre\\d+|_beta_\\d+)?$',
				match: true,
			},
			custom: {
				match: true,
				regex: '(old_)?v[\\d_]+(_pre\\d+|_beta_\\d+)?$',
			},
			format: null,
		},
		{
			// Version Enums
			selector: ['enumMember'],
			filter: { regex: '^([\\d\\.]+)$', match: true },
			format: null,
		},
		{
			selector: ['import'],
			modifiers: ['default'],
			format: ['camelCase', 'PascalCase', 'UPPER_CASE'],
		},
		{
			selector: 'class',
			format: ['PascalCase'],
		},
		{
			selector: ['classProperty', 'classMethod'],
			format: ['camelCase'],
		},
		{
			selector: ['classProperty', 'classMethod'],
			leadingUnderscore: 'allow',
			format: ['camelCase'],
		},
		{
			selector: ['classProperty', 'classMethod'],
			modifiers: ['private'],
			leadingUnderscore: 'allowDouble',
			trailingUnderscore: 'allowDouble',
			format: ['camelCase'],
		},
		{
			selector: 'typeProperty',
			format: null,
		},
		{
			selector: 'variable',
			modifiers: ['const', 'destructured'],
			format: null,
		},
		{
			selector: 'variable',
			modifiers: ['const', 'global'],
			types: ['function'],
			leadingUnderscore: 'allow',
			format: ['UPPER_CASE', 'camelCase'],
		},
		{
			selector: 'variable',
			modifiers: ['const', 'global'],
			leadingUnderscore: 'allow',
			format: ['UPPER_CASE'],
		},
		{
			selector: 'variable',
			modifiers: ['const', 'exported'],
			format: ['camelCase', 'UPPER_CASE'],
		},
		{
			selector: 'variableLike',
			format: ['camelCase'],
			leadingUnderscore: 'forbid',
		},
		{
			selector: 'interface',
			format: ['PascalCase'],
			leadingUnderscore: 'forbid',
		},
		{ selector: 'typeLike', format: ['PascalCase'] },
		{ selector: 'objectLiteralProperty', format: null },
		{ selector: 'default', format: ['camelCase'], leadingUnderscore: 'forbid' },
		{
			selector: 'parameter',
			modifiers: ['unused'],
			format: ['camelCase'],
			leadingUnderscore: 'allow',
		},
		{
			selector: 'parameter',
			format: ['camelCase'],
		},
		{
			selector: 'enumMember',
			format: ['camelCase', 'PascalCase', 'UPPER_CASE'],
		},
		{
			selector: 'enum',
			format: ['UPPER_CASE'],
		},
	],
}

export default tsESLint.config(
	{
		ignores: IGNORE_PATTERNS,
	},
	...tsESLint.configs.stylisticTypeChecked,
	...svelteEslint.configs['flat/prettier'],
	{
		plugins: {
			'@typescript-eslint': tsESLint.plugin,
			svelte: svelteEslint,
		},
	},
	{
		rules: CUSTOM_RULES,
	},
	{
		languageOptions: {
			parser: tsESLint.parser,
			parserOptions: {
				extraFileExtensions: ['.svelte'],
			},
			globals: {
				browser: true,
				node: true,
			},
		},
	},
	{
		files: ['**/*.svelte'],
		rules: {
			// Causes issues with Svelte and global types
			'no-undef': 'off',
			// Annoying when destructuring props
			'prefer-const': 'off',
			'@typescript-eslint/naming-convention': [
				'warn',
				{
					selector: 'variable',
					modifiers: ['exported'],
					format: ['camelCase'],
				},
				{
					selector: 'variable',
					modifiers: ['const', 'global'],
					format: ['camelCase', 'UPPER_CASE'],
				},
				{
					selector: 'variable',
					modifiers: ['const', 'global', 'destructured'],
					format: ['camelCase', 'UPPER_CASE'],
				},
				{
					selector: 'variable',
					modifiers: ['const', 'global'],
					types: ['function'],
					format: ['camelCase'],
				},
				{
					selector: 'variable',
					format: ['camelCase'],
					leadingUnderscore: 'allow',
				},
			],
		},
		languageOptions: {
			parser: svelteParser,
			parserOptions: {
				parser: tsESLint.parser,
				// svelteConfig: svelteConfig,
				extraFileExtensions: ['.svelte'],
			},
			globals: {
				browser: true,
				node: true,
			},
		},
		settings: {
			ignoreWarnings: ['svelte/a11y-no-onchange', 'a11y-no-onchange'],
		},
	},
	{
		languageOptions: {
			parserOptions: {
				projectService: true,
				tsconfigRootDir: __dirname,
			},
		},
		linterOptions: {
			reportUnusedDisableDirectives: true,
		},
	}
)
console.log(`✅ ESLint config loaded successfully.`)