fix: show correct dependencies count (#787)

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

app/composables/usePackageComparison.ts

···
 import { encodePackageName } from '#shared/utils/npm'
 import type { PackageAnalysisResponse } from './usePackageAnalysis'
 import { isBinaryOnlyPackage } from '#shared/utils/binary-detection'
+import { formatBytes } from '~/utils/formatters'
+import { getDependencyCount } from '~/utils/npm/dependency-count'
 
 export interface PackageComparisonData {
   package: ComparisonPackage
   downloads?: number
   /** Package's own unpacked size (from dist.unpackedSize) */
   packageSize?: number
+  /** Number of direct dependencies */
+  directDeps: number | null
   /** Install size data (fetched lazily) */
   installSize?: {
     selfSize: number
     totalSize: number
+    /** Total dependency count */
     dependencyCount: number
   }
   analysis?: PackageAnalysisResponse
···
               },
               downloads: downloads?.downloads,
               packageSize,
+              directDeps: versionData ? getDependencyCount(versionData) : null,
               installSize: undefined, // Will be filled in second pass
               analysis: analysis ?? undefined,
               vulnerabilities: {
···
   function isFacetLoading(facet: ComparisonFacet): boolean {
     if (!installSizeLoading.value) return false
     // These facets depend on install-size API
-    return facet === 'installSize' || facet === 'dependencies'
+    return facet === 'installSize' || facet === 'totalDependencies'
   }
 
   // Check if a specific column (package) is loading
···
   t: (key: string, params?: Record<string, unknown>) => string,
 ): FacetValue | null {
   switch (facet) {
-    case 'downloads':
+    case 'downloads': {
       if (data.downloads === undefined) return null
       return {
         raw: data.downloads,
         display: formatCompactNumber(data.downloads),
         status: 'neutral',
       }
-
-    case 'packageSize':
+    }
+    case 'packageSize': {
       if (!data.packageSize) return null
       return {
         raw: data.packageSize,
         display: formatBytes(data.packageSize),
         status: data.packageSize > 5 * 1024 * 1024 ? 'warning' : 'neutral',
       }
-
-    case 'installSize':
+    }
+    case 'installSize': {
       if (!data.installSize) return null
       return {
         raw: data.installSize.totalSize,
         display: formatBytes(data.installSize.totalSize),
         status: data.installSize.totalSize > 50 * 1024 * 1024 ? 'warning' : 'neutral',
       }
-
-    case 'moduleFormat':
+    }
+    case 'moduleFormat': {
       if (!data.analysis) return null
       const format = data.analysis.moduleFormat
       return {
···
         display: format === 'dual' ? 'ESM + CJS' : format.toUpperCase(),
         status: format === 'esm' || format === 'dual' ? 'good' : 'neutral',
       }
-
-    case 'types':
+    }
+    case 'types': {
       if (data.isBinaryOnly) {
         return {
           raw: 'binary',
···
               : t('compare.facets.values.types_none'),
         status: types.kind === 'included' ? 'good' : types.kind === '@types' ? 'info' : 'bad',
       }
-
-    case 'engines':
+    }
+    case 'engines': {
       const engines = data.metadata?.engines
       if (!engines?.node) {
         return { raw: null, display: t('compare.facets.values.any'), status: 'neutral' }
···
         display: `Node ${engines.node}`,
         status: 'neutral',
       }
-
-    case 'vulnerabilities':
+    }
+    case 'vulnerabilities': {
       if (!data.vulnerabilities) return null
       const count = data.vulnerabilities.count
       const sev = data.vulnerabilities.severity
···
               }),
         status: count === 0 ? 'good' : sev.critical > 0 || sev.high > 0 ? 'bad' : 'warning',
       }
-
-    case 'lastUpdated':
+    }
+    case 'lastUpdated': {
       if (!data.metadata?.lastUpdated) return null
       const date = new Date(data.metadata.lastUpdated)
       return {
···
         status: isStale(date) ? 'warning' : 'neutral',
         type: 'date',
       }
-
-    case 'license':
+    }
+    case 'license': {
       const license = data.metadata?.license
       if (!license) {
         return { raw: null, display: t('compare.facets.values.unknown'), status: 'warning' }
···
         display: license,
         status: 'neutral',
       }
-
-    case 'dependencies':
-      if (!data.installSize) return null
-      const depCount = data.installSize.dependencyCount
+    }
+    case 'dependencies': {
+      const depCount = data.directDeps
+      if (depCount === null) return null
       return {
         raw: depCount,
         display: String(depCount),
-        status: depCount > 50 ? 'warning' : 'neutral',
+        status: depCount > 10 ? 'warning' : 'neutral',
       }
-
-    case 'deprecated':
+    }
+    case 'deprecated': {
       const isDeprecated = !!data.metadata?.deprecated
       return {
         raw: isDeprecated,
···
           : t('compare.facets.values.not_deprecated'),
         status: isDeprecated ? 'bad' : 'good',
       }
-
+    }
     // Coming soon facets
-    case 'totalDependencies':
+    case 'totalDependencies': {
+      if (!data.installSize) return null
+      const totalDepCount = data.installSize.dependencyCount
+      return {
+        raw: totalDepCount,
+        display: String(totalDepCount),
+        status: totalDepCount > 50 ? 'warning' : 'neutral',
+      }
+    }
+    default: {
       return null
-
-    default:
-      return null
+    }
   }
-}
-
-function formatBytes(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} kB`
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
 }
 
 function isStale(date: Date): boolean {

app/pages/package/[...package].vue

···
 import { areUrlsEquivalent } from '#shared/utils/url'
 import { isEditableElement } from '~/utils/input'
 import { formatBytes } from '~/utils/formatters'
+import { getDependencyCount } from '~/utils/npm/dependency-count'
 import { NuxtLink } from '#components'
 import { useModal } from '~/composables/useModal'
 import { useAtproto } from '~/composables/atproto/useAtproto'
···
     .replace(/\.git$/, '')
     .replace(/^ssh:\/\/git@github\.com/, 'https://github.com')
     .replace(/^git@github\.com:/, 'https://github.com/')
-}
-
-function getDependencyCount(version: PackumentVersion | null): number {
-  if (!version?.dependencies) return 0
-  return Object.keys(version.dependencies).length
 }
 
 // Check if a version has provenance/attestations

app/utils/npm/dependency-count.ts

···
+import type { PackumentVersion } from '#shared/types'
+
+export function getDependencyCount(version: PackumentVersion | null): number {
+  if (!version?.dependencies) return 0
+  return Object.keys(version.dependencies).length
+}

shared/types/comparison.ts

···
   },
   totalDependencies: {
     category: 'performance',
-    comingSoon: true,
   },
   // Health
   downloads: {
···
   version: string
   description?: string
 }
+
+// ComingSoon tests run only when FACET_INFO has at least one comingSoon facet
+export const comingSoonFacets = (Object.keys(FACET_INFO) as ComparisonFacet[]).filter(
+  f => FACET_INFO[f].comingSoon,
+)
+export const hasComingSoonFacets = comingSoonFacets.length > 0

test/nuxt/components/compare/FacetSelector.spec.ts

···
 import type { ComparisonFacet } from '#shared/types/comparison'
-import { CATEGORY_ORDER, FACET_INFO, FACETS_BY_CATEGORY } from '#shared/types/comparison'
+import {
+  CATEGORY_ORDER,
+  FACET_INFO,
+  FACETS_BY_CATEGORY,
+  comingSoonFacets,
+  hasComingSoonFacets,
+} from '#shared/types/comparison'
 import FacetSelector from '~/components/Compare/FacetSelector.vue'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { computed, ref } from 'vue'
···
   license: { label: 'License', description: 'Package license' },
   dependencies: { label: 'Direct Deps', description: 'Number of direct dependencies' },
   totalDependencies: {
-    label: 'Total Deps',
+    label: 'Total deps',
     description: 'Total number of dependencies including transitive',
   },
   deprecated: { label: 'Deprecated?', description: 'Whether the package is deprecated' },
···
   compatibility: 'Compatibility',
   security: 'Security & Compliance',
 }
+
+const comingSoonFacetId = comingSoonFacets[0]
+const comingSoonFacetLabel = hasComingSoonFacets
+  ? (facetLabels[comingSoonFacetId!]?.label ?? comingSoonFacetId)
+  : ''
 
 // Helper to build facet info with labels
 function buildFacetInfo(facet: ComparisonFacet) {
···
     })
   })
 
-  describe('comingSoon facets', () => {
+  describe.runIf(hasComingSoonFacets)('comingSoon facets', () => {
     it('disables comingSoon facets', async () => {
       const component = await mountSuspended(FacetSelector)
 
       // totalDependencies is marked as comingSoon
       const buttons = component.findAll('button')
-      const comingSoonButton = buttons.find(b => b.text().includes('Total Deps'))
+      const comingSoonButton = buttons.find(b => b.text().includes(comingSoonFacetLabel))
 
       expect(comingSoonButton?.attributes('disabled')).toBeDefined()
     })
···
 
       // Find the comingSoon button
       const buttons = component.findAll('button')
-      const comingSoonButton = buttons.find(b => b.text().includes('Total Deps'))
+      const comingSoonButton = buttons.find(b => b.text().includes(comingSoonFacetLabel))
 
       // Should not have checkmark or add icon
       expect(comingSoonButton?.find('.i-carbon\\:checkmark').exists()).toBe(false)
···
       const component = await mountSuspended(FacetSelector)
 
       const buttons = component.findAll('button')
-      const comingSoonButton = buttons.find(b => b.text().includes('Total Deps'))
+      const comingSoonButton = buttons.find(b => b.text().includes(comingSoonFacetLabel))
       await comingSoonButton?.trigger('click')
 
       // toggleFacet should not have been called with totalDependencies
-      expect(mockToggleFacet).not.toHaveBeenCalledWith('totalDependencies')
+      expect(mockToggleFacet).not.toHaveBeenCalledWith(comingSoonFacetId)
     })
   })
 
···
 
     it('disables all button when all facets in category are selected', async () => {
       // Select all performance facets
-      const performanceFacets = FACETS_BY_CATEGORY.performance.filter(
+      const performanceFacets: (string | ComparisonFacet)[] = FACETS_BY_CATEGORY.performance.filter(
         f => !FACET_INFO[f].comingSoon,
       )
       mockSelectedFacets.value = performanceFacets
-      mockIsFacetSelected.mockImplementation((f: string) =>
-        performanceFacets.includes(f as ComparisonFacet),
-      )
+      mockIsFacetSelected.mockImplementation((f: string) => performanceFacets.includes(f))
 
       const component = await mountSuspended(FacetSelector)
 
···
       expect(component.find('.bg-bg-muted').exists()).toBe(true)
     })
 
-    it('applies cursor-not-allowed to comingSoon facets', async () => {
+    it.runIf(hasComingSoonFacets)('applies cursor-not-allowed to comingSoon facets', async () => {
       const component = await mountSuspended(FacetSelector)
 
       expect(component.find('.cursor-not-allowed').exists()).toBe(true)

test/nuxt/composables/use-facet-selection.spec.ts

···
 import { mountSuspended } from '@nuxt/test-utils/runtime'
 import { ref } from 'vue'
 import type { ComparisonFacet } from '#shared/types/comparison'
-import { DEFAULT_FACETS, FACETS_BY_CATEGORY } from '#shared/types/comparison'
+import {
+  DEFAULT_FACETS,
+  FACET_INFO,
+  FACETS_BY_CATEGORY,
+  hasComingSoonFacets,
+} from '#shared/types/comparison'
 import type { FacetInfoWithLabels } from '~/composables/useFacetSelection'
 
 // Mock useRouteQuery - needs to be outside of the helper to persist across calls
···
     expect(isFacetSelected('types')).toBe(true)
   })
 
-  it('filters out comingSoon facets from query', async () => {
+  it.runIf(hasComingSoonFacets)('filters out comingSoon facets from query', async () => {
     mockRouteQuery.value = 'downloads,totalDependencies,types'
 
     const { isFacetSelected } = await useFacetSelectionInComponent()
···
       selectCategory('performance')
 
       const performanceFacets = FACETS_BY_CATEGORY.performance.filter(
-        f => f !== 'totalDependencies', // comingSoon facet
+        f => !FACET_INFO[f].comingSoon, // comingSoon facet
       )
       for (const facet of performanceFacets) {
         expect(isFacetSelected(facet)).toBe(true)
···
       deselectCategory('performance')
 
       const nonComingSoonPerformanceFacets = FACETS_BY_CATEGORY.performance.filter(
-        f => f !== 'totalDependencies',
+        f => !FACET_INFO[f].comingSoon,
       )
       for (const facet of nonComingSoonPerformanceFacets) {
         expect(isFacetSelected(facet)).toBe(false)
···
 
       expect(Array.isArray(allFacets)).toBe(true)
       expect(allFacets.length).toBeGreaterThan(0)
-    })
-
-    it('allFacets includes all facets including comingSoon', async () => {
-      const { allFacets } = await useFacetSelectionInComponent()
-
-      expect(allFacets).toContain('totalDependencies')
     })
   })