chore: enable `noUnusedLocals` in `tsconfig` (#603)

.oxfmtrc.json

···
 {
-  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "$schema": "https://unpkg.com/oxfmt/configuration_schema.json",
   "semi": false,
   "singleQuote": true,
   "arrowParens": "avoid",

.oxlintrc.json

···
 {
-  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "$schema": "https://unpkg.com/oxlint/configuration_schema.json",
   "plugins": ["unicorn", "typescript", "oxc", "vue", "vitest"],
   "categories": {
     "correctness": "error",

app/components/ClaimPackageModal.vue

···
 
     // Auto-approve and execute
     await approveOperation(operation.id)
-    const result = await executeOperations()
+    await executeOperations()
 
     // Refresh state and check if operation completed successfully
     await refreshState()

app/components/ConnectorModal.vue

···
   disconnect()
 }
 
-function copyCommand() {
-  let command = executeNpmxConnectorCommand.value
-  if (portInput.value !== '31415') {
-    command += ` --port ${portInput.value}`
-  }
-  copy(command)
-}
+// function copyCommand() {
+//   let command = executeNpmxConnectorCommand.value
+//   if (portInput.value !== '31415') {
+//     command += ` --port ${portInput.value}`
+//   }
+//   copy(command)
+// }
 
-const selectedPM = useSelectedPackageManager()
+// const selectedPM = useSelectedPackageManager()
 
-const executeNpmxConnectorCommand = computed(() => {
-  return getExecuteCommand({
-    packageName: 'npmx-connector',
-    packageManager: selectedPM.value,
-  })
-})
+// const executeNpmxConnectorCommand = computed(() => {
+//   return getExecuteCommand({
+//     packageName: 'npmx-connector',
+//     packageManager: selectedPM.value,
+//   })
+// })
 
 // Reset form when modal opens
 watch(open, isOpen => {

app/components/PackageDownloadAnalytics.vue

···
 <script setup lang="ts">
-import { ref, computed, shallowRef, watch } from 'vue'
 import type { VueUiXyDatasetItem } from 'vue-data-ui'
 import { VueUiXy } from 'vue-data-ui/vue-ui-xy'
 import { useDebounceFn, useElementSize } from '@vueuse/core'

app/components/PackageWeeklyDownloadStats.vue

···
 <script setup lang="ts">
-import { ref, computed, onMounted, watch } from 'vue'
 import { VueUiSparkline } from 'vue-data-ui/vue-ui-sparkline'
 import { useCssVariables } from '../composables/useColors'
 import { OKLCH_NEUTRAL_FALLBACK, lightenOklch } from '../utils/colors'

app/components/PaginationControls.vue

···
 
 // When 'all' is selected, there's only 1 page with everything
 const isShowingAll = computed(() => pageSize.value === 'all')
-const effectivePageSize = computed(() => (isShowingAll.value ? props.totalItems : pageSize.value))
 const totalPages = computed(() =>
   isShowingAll.value ? 1 : Math.ceil(props.totalItems / (pageSize.value as number)),
 )

app/components/VersionSelector.vue

···
 import { compare } from 'semver'
 import {
   buildVersionToTagsMap,
-  parseVersion,
   getPrereleaseChannel,
   getVersionGroupKey,
   getVersionGroupLabel,
···
         @keydown="handleListboxKeydown"
       >
         <!-- Version groups -->
-        <div v-for="(group, groupIndex) in versionGroups" :key="group.id">
+        <div v-for="group in versionGroups" :key="group.id">
           <!-- Group header (primary version) -->
           <div
             :id="`version-${group.primaryVersion.version}`"
···
             v-if="group.isExpanded && group.versions.length > 1"
             class="ms-6 border-is border-border"
           >
-            <template v-for="(v, vIndex) in group.versions.slice(1)" :key="v.version">
+            <template v-for="v in group.versions.slice(1)" :key="v.version">
               <NuxtLink
                 :id="`version-${v.version}`"
                 :to="getVersionUrl(v.version)"

app/components/compare/FacetSelector.vue

···
 import type { ComparisonFacet } from '#shared/types'
 import { FACET_INFO, FACETS_BY_CATEGORY, CATEGORY_ORDER } from '#shared/types/comparison'
 
-const {
-  isFacetSelected,
-  toggleFacet,
-  selectCategory,
-  deselectCategory,
-  selectAll,
-  deselectAll,
-  isAllSelected,
-  isNoneSelected,
-} = useFacetSelection()
+const { isFacetSelected, toggleFacet, selectCategory, deselectCategory } = useFacetSelection()
 
 // Enrich facets with their info for rendering
 const facetsByCategory = computed(() => {

app/pages/@[org].vue

···
   clearFilter(chip)
 }
 
-// Handle sort change from table
-function handleSortChange(option: SortOption) {
-  setSort(option)
-}
-
 const activeTab = shallowRef<'members' | 'teams'>('members')
 
 // Canonical URL for this org page

app/pages/compare.vue

···
 <script setup lang="ts">
-import { FACET_INFO, type ComparisonFacet } from '#shared/types/comparison'
+import { FACET_INFO } from '#shared/types/comparison'
 import { useRouteQuery } from '@vueuse/router'
 
 definePageMeta({

app/pages/search.vue

···
 <script setup lang="ts">
-import type { FilterChip, SortOption } from '#shared/types/preferences'
+import type { FilterChip } from '#shared/types/preferences'
 import { onKeyDown } from '@vueuse/core'
 import { debounce } from 'perfect-debounce'
 import { isValidNewPackageName, checkPackageExists } from '~/utils/package-name'
···
 
 // The actual search query (from URL, used for API calls)
 const query = computed(() => (route.query.q as string) ?? '')
-
-const packageListRef = useTemplateRef('packageListRef')
 
 // Track if page just loaded (for hiding "Searching..." during view transition)
 const hasInteracted = shallowRef(false)
···
   incremental: true,
 }))
 
-// Track previous query for UI continuity
-const previousQuery = useState('search-previous-query', () => query.value)
-
-// Update previous query when results change
-watch(
-  () => results.value,
-  newResults => {
-    if (newResults && newResults.objects.length > 0) {
-      previousQuery.value = query.value
-    }
-  },
-)
-
-const resultsMatchQuery = computed(() => {
-  return previousQuery.value === query.value
-})
-
 // Results to display (directly from incremental search)
 const rawVisibleResults = computed(() => results.value)
 
···
   toggleKeyword,
   clearFilter,
   clearAllFilters,
-  setSort,
 } = useStructuredFilters({
   packages: resultsArray,
   initialSort: 'relevance-desc', // Default to search relevance
···
   clearFilter(chip)
 }
 
-// Handle sort change from table
-function handleSortChange(option: SortOption) {
-  setSort(option)
-}
-
 // Should we show the loading spinner?
 const showSearching = computed(() => {
   // Don't show during initial page load (view transition)
   if (!hasInteracted.value) return false
   // Show if pending and no results yet
   return status.value === 'pending' && displayResults.value.length === 0
-})
-
-const totalPages = computed(() => {
-  if (!visibleResults.value) return 0
-  return Math.ceil(visibleResults.value.total / pageSize)
 })
 
 // Load more when triggered by infinite scroll
···
 
           <PackageList
             v-if="displayResults.length > 0"
-            ref="packageListRef"
             :results="displayResults"
             :search-query="query"
             heading-level="h2"

nuxt.config.ts

···
     hydration: true,
   },
 
+  typescript: {
+    tsConfig: {
+      compilerOptions: {
+        noUnusedLocals: true,
+      },
+    },
+  },
+
   vite: {
     optimizeDeps: {
       include: [