chore: add eslint for unused imports (#242)

* chore: add eslint for unused imports check

- adds eslint with typescript and svelte plugins
- configures pre-commit hook to run eslint
- focuses on catching unused vars/imports
- ignores build output directories
- found 51 unused vars across the codebase

* fix: add svelte runes and crypto to eslint globals

* fix: resolve all eslint unused variable errors

- fixed catch blocks to use _ prefix for unused error params
- fixed interface type signatures with _ prefix for unused callback params
- removed unused variables (albumId, isOwnProfile)
- disabled base no-unused-vars rule in favor of @typescript-eslint version
- configured @typescript-eslint/no-unused-vars to:
- ignore args/vars with ^_ pattern
- skip caught error checking (caughtErrors: none)

all 24 eslint errors now fixed - lint passes cleanly

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[e-mail]>

---------

Co-authored-by: Claude <[e-mail]>

.pre-commit-config.yaml

···
         files: ^frontend/
         pass_filenames: false
 
+      - id: eslint
+        name: eslint
+        entry: bash -c 'cd frontend && bun run lint'
+        language: system
+        files: ^frontend/.*\.(ts|svelte)$
+        pass_filenames: false
+
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v6.0.0
     hooks:

frontend/eslint.config.js

···
+import js from '@eslint/js';
+import tsParser from '@typescript-eslint/parser';
+import tsPlugin from '@typescript-eslint/eslint-plugin';
+import sveltePlugin from 'eslint-plugin-svelte';
+import svelteParser from 'svelte-eslint-parser';
+
+export default [
+	{
+		ignores: [
+			'.svelte-kit/**',
+			'.vercel/**',
+			'build/**',
+			'node_modules/**',
+			'dist/**',
+			'**/*.config.js'
+		]
+	},
+	js.configs.recommended,
+	{
+		files: ['**/*.ts', '**/*.svelte'],
+		languageOptions: {
+			parser: tsParser,
+			parserOptions: {
+				project: './tsconfig.json',
+				extraFileExtensions: ['.svelte']
+			},
+			globals: {
+				// browser globals
+				window: 'readonly',
+				document: 'readonly',
+				console: 'readonly',
+				fetch: 'readonly',
+				localStorage: 'readonly',
+				sessionStorage: 'readonly',
+				setTimeout: 'readonly',
+				clearTimeout: 'readonly',
+				alert: 'readonly',
+				confirm: 'readonly',
+				navigator: 'readonly',
+				location: 'readonly',
+				history: 'readonly',
+				crypto: 'readonly',
+				// svelte 5 runes
+				$state: 'readonly',
+				$derived: 'readonly',
+				$effect: 'readonly',
+				$props: 'readonly',
+				$bindable: 'readonly',
+				$inspect: 'readonly'
+			}
+		},
+		plugins: {
+			'@typescript-eslint': tsPlugin
+		},
+		rules: {
+			'no-unused-vars': 'off',
+			'@typescript-eslint/no-unused-vars': [
+				'error',
+				{
+					argsIgnorePattern: '^_',
+					varsIgnorePattern: '^_',
+					caughtErrors: 'none'
+				}
+			]
+		}
+	},
+	{
+		files: ['**/*.svelte'],
+		languageOptions: {
+			parser: svelteParser,
+			parserOptions: {
+				parser: tsParser
+			}
+		},
+		plugins: {
+			svelte: sveltePlugin
+		},
+		rules: {
+			...sveltePlugin.configs.recommended.rules
+		}
+	}
+];

frontend/package.json

···
 		"preview": "vite preview",
 		"prepare": "svelte-kit sync || echo ''",
 		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch"
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"lint": "eslint ."
 	},
 	"devDependencies": {
 		"@sveltejs/adapter-auto": "^7.0.0",
···
 		"@sveltejs/adapter-static": "^3.0.10",
 		"@sveltejs/kit": "^2.43.2",
 		"@sveltejs/vite-plugin-svelte": "^6.2.0",
+		"@typescript-eslint/eslint-plugin": "^8.46.4",
+		"@typescript-eslint/parser": "^8.46.4",
+		"eslint": "^9.39.1",
+		"eslint-plugin-svelte": "^3.13.0",
 		"svelte": "^5.39.5",
 		"svelte-check": "^4.3.2",
 		"typescript": "^5.9.2",

frontend/src/lib/components/BrokenTracks.svelte

···
 			});
 
 			if (response.ok) {
-				const data = await response.json();
+				await response.json();
 				toast.success(`restored record for ${trackTitle}`);
 				// remove from broken tracks list
 				brokenTracks = brokenTracks.filter(t => t.id !== trackId);

frontend/src/lib/components/HandleSearch.svelte

···
 
 	interface Props {
 		selected: FeaturedArtist[];
-		onAdd: (artist: FeaturedArtist) => void;
-		onRemove: (did: string) => void;
+		onAdd: (_artist: FeaturedArtist) => void;
+		onRemove: (_did: string) => void;
 		maxFeatures?: number;
 		disabled?: boolean;
 	}
···
 				results = data.results;
 				showResults = true;
 			}
-		} catch (e) {
-			console.error('search failed:', e);
+		} catch (_e) {
+			console.error('search failed:', _e);
 		} finally {
 			searching = false;
 		}

frontend/src/lib/components/LikeButton.svelte

···
 		initialLiked?: boolean;
 		disabled?: boolean;
 		disabledReason?: string;
-		onLikeChange?: (liked: boolean) => void;
+		onLikeChange?: (_liked: boolean) => void;
 	}
 
 	let { trackId, trackTitle, initialLiked = false, disabled = false, disabledReason, onLikeChange }: Props = $props();
···
 					toast.info(`unliked ${trackTitle}`);
 				}
 			}
-		} catch (e) {
+		} catch {
 			// revert on error
 			liked = previousState;
 			toast.error('failed to update like');

frontend/src/lib/components/TrackActionsMenu.svelte

···
 				}
 			}
 			closeMenu();
-		} catch (e) {
+		} catch {
 			// revert on error
 			liked = previousState;
 			toast.error('failed to update like');

frontend/src/lib/components/TrackItem.svelte

···
 	interface Props {
 		track: Track;
 		isPlaying?: boolean;
-		onPlay: (track: Track) => void;
+		onPlay: (_track: Track) => void;
 		isAuthenticated?: boolean;
 		hideAlbum?: boolean;
 	}

frontend/src/lib/uploader.svelte.ts

···
 }
 
 interface UploadProgressCallback {
-	onProgress?: (loaded: number, total: number) => void;
-	onSuccess?: (uploadId: string) => void;
-	onError?: (error: string) => void;
+	onProgress?: (_loaded: number, _total: number) => void;
+	onSuccess?: (_uploadId: string) => void;
+	onError?: (_error: string) => void;
 }
 
 // global upload manager using Svelte 5 runes
···
 						this.activeUploads.delete(taskId);
 						toast.error('lost connection to server');
 					};
-				} catch (e) {
+				} catch {
 					toast.dismiss(toastId);
-					const errorMsg = 'failed to parse server response';
-					toast.error(errorMsg);
+					toast.error('failed to parse server response');
 					if (callbacks?.onError) {
-						callbacks.onError(errorMsg);
+						callbacks.onError('failed to parse server response');
 					}
 				}
 			} else {

frontend/src/routes/portal/+page.svelte

···
 
 	// upload form fields
 	let title = '';
-	let albumId: string | null = null;
 	let albumTitle = '';
 	let file: File | null = null;
 	let imageFile: File | null = null;
···
 					auth.setSessionId(data.session_id);
 					await auth.initialize();
 				}
-			} catch (e) {
-				console.error('failed to exchange token:', e);
+			} catch (_e) {
+				console.error('failed to exchange token:', _e);
 			}
 
 			// remove exchange_token from URL
···
 			await loadMyTracks();
 			await loadArtistProfile();
 			await loadMyAlbums();
-		} catch (e) {
-			console.error('error loading portal data:', e);
+		} catch (_e) {
+			console.error('error loading portal data:', _e);
 			error = 'failed to load portal data';
 		} finally {
 			loading = false;
···
 				const data = await response.json();
 				tracks = data.tracks;
 			}
-		} catch (e) {
-			console.error('failed to load tracks:', e);
+		} catch (_e) {
+			console.error('failed to load tracks:', _e);
 		} finally {
 			loadingTracks = false;
 		}
···
 				bio = artist.bio || '';
 				avatarUrl = artist.avatar_url || '';
 			}
-		} catch (e) {
-			console.error('failed to load artist profile:', e);
+		} catch (_e) {
+			console.error('failed to load artist profile:', _e);
 		}
 	}
 
···
 				const data = await response.json();
 				albums = data.albums;
 			}
-		} catch (e) {
-			console.error('failed to load albums:', e);
+		} catch (_e) {
+			console.error('failed to load albums:', _e);
 		} finally {
 			loadingAlbums = false;
 		}
···
 				const data = await response.json();
 				toast.error(data.detail || 'failed to upload cover');
 			}
-		} catch (e) {
-			console.error('failed to upload album cover:', e);
+		} catch (_e) {
+			console.error('failed to upload album cover:', _e);
 			toast.error('failed to upload cover art');
 		}
 	}
···
 					file = null;
 					return;
 				}
-			} catch (e) {
-				console.error('failed to validate file size:', e);
+			} catch (_e) {
+				console.error('failed to validate file size:', _e);
 				// continue anyway - server will validate
 			}
 
···
 					imageFile = null;
 					return;
 				}
-			} catch (e) {
-				console.error('failed to validate image size:', e);
+			} catch (_e) {
+				console.error('failed to validate image size:', _e);
 				// continue anyway - server will validate
 			}
 

frontend/src/routes/profile/setup/+page.svelte

···
 					auth.setSessionId(data.session_id);
 					await auth.initialize();
 				}
-			} catch (e) {
-				console.error('failed to exchange token:', e);
+			} catch (_e) {
+				console.error('failed to exchange token:', _e);
 			}
 
 			// remove exchange_token from URL
···
 
 			// try to fetch avatar from bluesky
 			await fetchAvatar();
-		} catch (e) {
+		} catch {
 			auth.clearSession();
 			window.location.href = '/login';
 		} finally {
···
 				window.location.href = '/portal';
 				return;
 			}
-		} catch (e) {
+		} catch {
 			// profile doesn't exist, which is expected
 		} finally {
 			fetchingAvatar = false;

frontend/src/routes/u/[handle]/+page.svelte

···
 	let analytics: Analytics | null = $state(null);
 	let analyticsLoading = $state(false);
 
-	function checkIsOwnProfile(): boolean {
-		return auth.user !== null && artist !== null && auth.user.did === artist.did;
-	}
-	let isOwnProfile = $derived(checkIsOwnProfile());
 
 	async function handleLogout() {
 		await auth.logout();
···
 			if (response.ok) {
 				analytics = await response.json();
 			}
-		} catch (e) {
-			console.error('failed to load analytics:', e);
+		} catch (_e) {
+			console.error('failed to load analytics:', _e);
 		} finally {
 			// ensure loading state shows for at least minDisplayTime
 			const elapsed = Date.now() - startTime;