fix: handle versions below 1.0.0

resolves #153

Author: danielroe

app/components/PackageVersions.vue

@@ -6,6 +6,9 @@ import {
   buildVersionToTagsMap,
   filterExcludedTags,
   getPrereleaseChannel,
+  getVersionGroupKey,
+  getVersionGroupLabel,
+  isSameVersionGroup,
   parseVersion,
 } from '~/utils/versions'
 import { fetchAllPackageVersions } from '~/composables/useNpmRegistry'
@@ -120,8 +123,10 @@ const tagVersions = ref<Map<string, VersionDisplay[]>>(new Map())
 const loadingTags = ref<Set<string>>(new Set())
 
 const otherVersionsExpanded = shallowRef(false)
-const expandedMajorGroups = ref<Set<number>>(new Set())
-const otherMajorGroups = shallowRef<Array<{ major: number; versions: VersionDisplay[] }>>([])
+const expandedMajorGroups = ref<Set<string>>(new Set())
+const otherMajorGroups = shallowRef<
+  Array<{ groupKey: string; label: string; versions: VersionDisplay[] }>
+>([])
 const otherVersionsLoading = shallowRef(false)
 
 // Cached full version list (local to component instance)
@@ -167,14 +172,14 @@ function processLoadedVersions(allVersions: PackageVersionInfo[]) {
     const tagVersion = distTags[row.tag]
     if (!tagVersion) continue
 
-    const tagParsed = parseVersion(tagVersion)
     const tagChannel = getPrereleaseChannel(tagVersion)
 
+    // Find all versions in the same version group + prerelease channel
+    // For 0.x versions, this means same major.minor; for 1.x+, same major
     const channelVersions = allVersions
       .filter(v => {
-        const vParsed = parseVersion(v.version)
         const vChannel = getPrereleaseChannel(v.version)
-        return vParsed.major === tagParsed.major && vChannel === tagChannel
+        return isSameVersionGroup(v.version, tagVersion) && vChannel === tagChannel
       })
       .sort((a, b) => compare(b.version, a.version))
       .map(v => ({
@@ -192,17 +197,19 @@ function processLoadedVersions(allVersions: PackageVersionInfo[]) {
     }
   }
 
-  // Group unclaimed versions by major
-  const byMajor = new Map<number, VersionDisplay[]>()
+  // Group unclaimed versions by version group key
+  // For 0.x versions, group by major.minor (e.g., "0.9", "0.10")
+  // For 1.x+, group by major (e.g., "1", "2")
+  const byGroupKey = new Map<string, VersionDisplay[]>()
 
   for (const v of allVersions) {
     if (claimedVersions.has(v.version)) continue
 
-    const major = parseVersion(v.version).major
-    if (!byMajor.has(major)) {
-      byMajor.set(major, [])
+    const groupKey = getVersionGroupKey(v.version)
+    if (!byGroupKey.has(groupKey)) {
+      byGroupKey.set(groupKey, [])
     }
-    byMajor.get(major)!.push({
+    byGroupKey.get(groupKey)!.push({
       version: v.version,
       time: v.time,
       tags: versionToTags.value.get(v.version),
@@ -211,16 +218,23 @@ function processLoadedVersions(allVersions: PackageVersionInfo[]) {
     })
   }
 
-  // Sort within each major
-  for (const versions of byMajor.values()) {
+  // Sort within each group
+  for (const versions of byGroupKey.values()) {
     versions.sort((a, b) => compare(b.version, a.version))
   }
 
-  // Build major groups sorted by major descending
-  const sortedMajors = Array.from(byMajor.keys()).sort((a, b) => b - a)
-  otherMajorGroups.value = sortedMajors.map(major => ({
-    major,
-    versions: byMajor.get(major)!,
+  // Build groups sorted by group key descending
+  // Sort: "2", "1", "0.10", "0.9" (numerically descending)
+  const sortedGroupKeys = Array.from(byGroupKey.keys()).sort((a, b) => {
+    const [aMajor, aMinor] = a.split('.').map(Number)
+    const [bMajor, bMinor] = b.split('.').map(Number)
+    if (aMajor !== bMajor) return (bMajor ?? 0) - (aMajor ?? 0)
+    return (bMinor ?? -1) - (aMinor ?? -1)
+  })
+  otherMajorGroups.value = sortedGroupKeys.map(groupKey => ({
+    groupKey,
+    label: getVersionGroupLabel(groupKey),
+    versions: byGroupKey.get(groupKey)!,
   }))
   expandedMajorGroups.value.clear()
 }
@@ -275,12 +289,12 @@ async function expandOtherVersions() {
   otherVersionsExpanded.value = true
 }
 
-// Toggle a major group
-function toggleMajorGroup(major: number) {
-  if (expandedMajorGroups.value.has(major)) {
-    expandedMajorGroups.value.delete(major)
+// Toggle a version group
+function toggleMajorGroup(groupKey: string) {
+  if (expandedMajorGroups.value.has(groupKey)) {
+    expandedMajorGroups.value.delete(groupKey)
   } else {
-    expandedMajorGroups.value.add(major)
+    expandedMajorGroups.value.add(groupKey)
   }
 }
 
@@ -521,28 +535,28 @@ function getTagVersions(tag: string): VersionDisplay[] {
             </div>
           </div>
 
-          <!-- Major version groups (untagged versions) -->
+          <!-- Version groups (untagged versions) -->
           <template v-if="otherMajorGroups.length > 0">
-            <div v-for="group in otherMajorGroups" :key="group.major">
-              <!-- Major group header -->
+            <div v-for="group in otherMajorGroups" :key="group.groupKey">
+              <!-- Version group header -->
               <div v-if="group.versions.length > 1" class="py-1">
                 <div class="flex items-center justify-between gap-2">
                   <div class="flex items-center gap-2 min-w-0">
                     <button
                       type="button"
                       class="w-4 h-4 flex items-center justify-center text-fg-subtle hover:text-fg transition-colors shrink-0 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg-muted focus-visible:ring-offset-1 focus-visible:ring-offset-bg rounded-sm"
-                      :aria-expanded="expandedMajorGroups.has(group.major)"
+                      :aria-expanded="expandedMajorGroups.has(group.groupKey)"
                       :aria-label="
-                        expandedMajorGroups.has(group.major)
-                          ? $t('package.versions.collapse_major', { major: group.major })
-                          : $t('package.versions.expand_major', { major: group.major })
+                        expandedMajorGroups.has(group.groupKey)
+                          ? $t('package.versions.collapse_major', { major: group.label })
+                          : $t('package.versions.expand_major', { major: group.label })
                       "
-                      @click="toggleMajorGroup(group.major)"
+                      @click="toggleMajorGroup(group.groupKey)"
                     >
                       <span
                         class="w-3 h-3 transition-transform duration-200"
                         :class="
-                          expandedMajorGroups.has(group.major)
+                          expandedMajorGroups.has(group.groupKey)
                             ? 'i-carbon-chevron-down'
                             : 'i-carbon-chevron-right'
                         "
@@ -653,9 +667,9 @@ function getTagVersions(tag: string): VersionDisplay[] {
                 </div>
               </div>
 
-              <!-- Major group versions -->
+              <!-- Version group versions -->
               <div
-                v-if="expandedMajorGroups.has(group.major) && group.versions.length > 1"
+                v-if="expandedMajorGroups.has(group.groupKey) && group.versions.length > 1"
                 class="ml-6 space-y-0.5"
               >
                 <div v-for="v in group.versions.slice(1)" :key="v.version" class="py-1">

app/utils/versions.ts

@@ -136,3 +136,46 @@ export function filterExcludedTags(tags: string[], excludeTags: string[]): strin
   const excludeSet = new Set(excludeTags)
   return tags.filter(tag => !excludeSet.has(tag))
 }
+
+/**
+ * Get a grouping key for a version that handles 0.x versions specially.
+ *
+ * Per semver spec, versions below 1.0.0 can have breaking changes in minor bumps,
+ * so 0.9.x should be in a separate group from 0.10.x.
+ *
+ * @param version - The version string (e.g., "0.9.3", "1.2.3")
+ * @returns A grouping key string (e.g., "0.9", "1")
+ */
+export function getVersionGroupKey(version: string): string {
+  const parsed = parseVersion(version)
+  if (parsed.major === 0) {
+    // For 0.x versions, group by major.minor
+    return `0.${parsed.minor}`
+  }
+  // For 1.x+, group by major only
+  return String(parsed.major)
+}
+
+/**
+ * Get a display label for a version group key.
+ *
+ * @param groupKey - The group key from getVersionGroupKey()
+ * @returns A display label (e.g., "0.9.x", "1.x")
+ */
+export function getVersionGroupLabel(groupKey: string): string {
+  return `${groupKey}.x`
+}
+
+/**
+ * Check if two versions belong to the same version group.
+ *
+ * For versions >= 1.0.0, same major = same group.
+ * For versions < 1.0.0, same major.minor = same group.
+ *
+ * @param versionA - First version string
+ * @param versionB - Second version string
+ * @returns true if both versions are in the same group
+ */
+export function isSameVersionGroup(versionA: string, versionB: string): boolean {
+  return getVersionGroupKey(versionA) === getVersionGroupKey(versionB)
+}

test/unit/versions.spec.ts

@@ -4,6 +4,9 @@ import {
   buildVersionToTagsMap,
   filterExcludedTags,
   getPrereleaseChannel,
+  getVersionGroupKey,
+  getVersionGroupLabel,
+  isSameVersionGroup,
   parseVersion,
   sortTags,
 } from '../../app/utils/versions'
@@ -305,3 +308,82 @@ describe('filterExcludedTags', () => {
     expect(filterExcludedTags(['beta', 'rc'], ['latest'])).toEqual(['beta', 'rc'])
   })
 })
+
+describe('getVersionGroupKey', () => {
+  it('groups 1.x+ versions by major only', () => {
+    expect(getVersionGroupKey('1.0.0')).toBe('1')
+    expect(getVersionGroupKey('1.5.3')).toBe('1')
+    expect(getVersionGroupKey('2.0.0')).toBe('2')
+    expect(getVersionGroupKey('10.5.2')).toBe('10')
+  })
+
+  it('groups 0.x versions by major.minor', () => {
+    expect(getVersionGroupKey('0.1.0')).toBe('0.1')
+    expect(getVersionGroupKey('0.1.5')).toBe('0.1')
+    expect(getVersionGroupKey('0.9.0')).toBe('0.9')
+    expect(getVersionGroupKey('0.9.3')).toBe('0.9')
+    expect(getVersionGroupKey('0.10.0')).toBe('0.10')
+    expect(getVersionGroupKey('0.10.5')).toBe('0.10')
+  })
+
+  it('handles prerelease versions', () => {
+    expect(getVersionGroupKey('1.0.0-beta.1')).toBe('1')
+    expect(getVersionGroupKey('0.5.0-alpha.1')).toBe('0.5')
+  })
+})
+
+describe('getVersionGroupLabel', () => {
+  it('formats 1.x+ group keys', () => {
+    expect(getVersionGroupLabel('1')).toBe('1.x')
+    expect(getVersionGroupLabel('2')).toBe('2.x')
+    expect(getVersionGroupLabel('10')).toBe('10.x')
+  })
+
+  it('formats 0.x group keys', () => {
+    expect(getVersionGroupLabel('0.1')).toBe('0.1.x')
+    expect(getVersionGroupLabel('0.9')).toBe('0.9.x')
+    expect(getVersionGroupLabel('0.10')).toBe('0.10.x')
+  })
+})
+
+describe('isSameVersionGroup', () => {
+  it('groups 1.x+ versions by major', () => {
+    expect(isSameVersionGroup('1.0.0', '1.5.3')).toBe(true)
+    expect(isSameVersionGroup('1.0.0', '1.99.99')).toBe(true)
+    expect(isSameVersionGroup('2.0.0', '2.1.0')).toBe(true)
+  })
+
+  it('separates different major versions', () => {
+    expect(isSameVersionGroup('1.0.0', '2.0.0')).toBe(false)
+    expect(isSameVersionGroup('1.5.3', '2.0.0')).toBe(false)
+  })
+
+  it('groups 0.x versions by major.minor', () => {
+    expect(isSameVersionGroup('0.1.0', '0.1.5')).toBe(true)
+    expect(isSameVersionGroup('0.9.0', '0.9.3')).toBe(true)
+    expect(isSameVersionGroup('0.10.0', '0.10.5')).toBe(true)
+  })
+
+  it('separates different 0.x minor versions', () => {
+    // This is the key test: 0.9.x should NOT be grouped with 0.10.x
+    expect(isSameVersionGroup('0.9.0', '0.10.0')).toBe(false)
+    expect(isSameVersionGroup('0.9.3', '0.10.5')).toBe(false)
+    expect(isSameVersionGroup('0.1.0', '0.2.0')).toBe(false)
+  })
+
+  it('separates 0.x from 1.x', () => {
+    expect(isSameVersionGroup('0.9.0', '1.0.0')).toBe(false)
+    expect(isSameVersionGroup('0.99.99', '1.0.0')).toBe(false)
+  })
+
+  it('handles prerelease versions in 1.x+', () => {
+    expect(isSameVersionGroup('1.0.0-beta.1', '1.0.0')).toBe(true)
+    expect(isSameVersionGroup('1.0.0-alpha.1', '1.5.0')).toBe(true)
+  })
+
+  it('handles prerelease versions in 0.x', () => {
+    expect(isSameVersionGroup('0.5.0-beta.1', '0.5.0')).toBe(true)
+    expect(isSameVersionGroup('0.5.0-alpha.1', '0.5.3')).toBe(true)
+    expect(isSameVersionGroup('0.5.0-beta.1', '0.6.0')).toBe(false)
+  })
+})