Fix bugs found in code review of the version-filtering changes

- Show the legacy-hidden default plugin count in SSR/no-JS output
  instead of the raw total
- Drop legacy versions stuck in filter state (bookmarked URL, or
  unchecking "Show older Gephi versions") instead of permanently
  zeroing results with no recovery
- Scope the "Show older versions" caret rotation to the summary icon
  instead of every icon in the disclosure
- Pick the "latest version" download CTA via a real numeric version
  comparison instead of relying on source JSON key order
- Log fetch failures in getLatestGephiVersion instead of swallowing
  them silently
- Break exact-timestamp ties when grouping versions by keeping the
  latest-iterated build
- Fix normalizeGephiVersion corrupting single-part version strings
- Simplify a redundant length check

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: mbastian

src/components/plugins/PluginsFilters.tsx

@@ -13,19 +13,23 @@ interface FilterStateType {
 }
 
 function searchToState(urlSearchParam: URLSearchParams): FilterStateType {
+  const showLegacy = urlSearchParam.get("legacy") === "1";
+  const versions =
+    urlSearchParam
+      .get("versions")
+      ?.split("|")
+      .map((v) => decodeURIComponent(v)) || [];
   return {
     query: urlSearchParam.get("query") || undefined,
-    versions:
-      urlSearchParam
-        .get("versions")
-        ?.split("|")
-        .map((v) => decodeURIComponent(v)) || [],
+    // Drop any legacy version stuck in a bookmarked/old URL when legacy versions aren't shown,
+    // otherwise it can never match a visible tag and silently zeroes the results.
+    versions: showLegacy ? versions : versions.filter((v) => !isLegacyGephiVersion(v)),
     categories:
       urlSearchParam
         .get("categories")
         ?.split("|")
         .map((v) => decodeURIComponent(v)) || [],
-    showLegacy: urlSearchParam.get("legacy") === "1",
+    showLegacy,
   };
 }
 function stateToSearch(state: FilterStateType): string {
@@ -163,7 +167,14 @@ export const PluginsFilters: FC<{ plugins: Plugin[] }> = ({ plugins }) => {
                 id="show-legacy-checkbox"
                 checked={state.showLegacy}
                 onChange={(e) => {
-                  setState((state) => ({ ...state, showLegacy: e.target.checked }));
+                  const showLegacy = e.target.checked;
+                  setState((state) => ({
+                    ...state,
+                    showLegacy,
+                    // Drop any checked legacy versions so they don't keep filtering to nothing
+                    // once their checkboxes disappear from the facet list.
+                    versions: showLegacy ? state.versions : state.versions.filter((v) => !isLegacyGephiVersion(v)),
+                  }));
                 }}
                 className="form-check-input"
               />

src/components/plugins/utils.ts

@@ -4,30 +4,58 @@ export function pluginElementId(id: string) {
   return `gephi-plugin-${id}`;
 }
 
+function parseGephiVersion(v: string): [number, number] {
+  const parts = v.split(".").map((n) => parseInt(n, 10) || 0);
+  return [parts[0] ?? 0, parts[1] ?? 0];
+}
+
 // Gephi 0.10+ no longer differentiates plugin builds at the patch level, so we
 // only keep major.minor for those. Pre-0.10 ("legacy") builds did differentiate
 // per patch, so we keep their full version string.
 export function isLegacyGephiVersion(v: string): boolean {
-  const [major, minor] = v.split(".").map((n) => parseInt(n, 10) || 0);
+  const [major, minor] = parseGephiVersion(v);
   return major === 0 && minor < 10;
 }
 
 export function normalizeGephiVersion(v: string): string {
   if (isLegacyGephiVersion(v)) return v;
-  const [major, minor] = v.split(".").map((n) => parseInt(n, 10) || 0);
+  const [major, minor] = parseGephiVersion(v);
   return `${major}.${minor}`;
 }
 
 export function pluginHasModernVersion(p: Plugin): boolean {
   return Object.keys(p.versions).some((v) => !isLegacyGephiVersion(v));
 }
 
+// Descending comparator so the most recent version sorts first, regardless of
+// the order versions happen to appear in the source data.
+export function compareGephiVersionsDesc(a: string, b: string): number {
+  const aParts = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const bParts = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+    const diff = (bParts[i] ?? 0) - (aParts[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+// Groups a plugin's versions by normalized tag, keeping the most recently
+// updated build per tag.
+export function groupPluginVersionsByTag(versions: Plugin["versions"]): Record<string, Plugin["versions"][string]> {
+  return Object.entries(versions).reduce<Record<string, Plugin["versions"][string]>>((acc, [v, info]) => {
+    const tag = normalizeGephiVersion(v);
+    if (!acc[tag] || new Date(info.last_update) >= new Date(acc[tag].last_update)) acc[tag] = info;
+    return acc;
+  }, {});
+}
+
 export async function getLatestGephiVersion(): Promise<string | null> {
   try {
     const resp = await fetch("https://api.github.com/repos/gephi/gephi/releases/latest");
     const data = (await resp.json()) as { tag_name: string };
     return normalizeGephiVersion(data.tag_name.replace(/^v/, ""));
-  } catch {
+  } catch (err) {
+    console.log("Failed to fetch the latest Gephi release version from GitHub.", err);
     return null;
   }
 }

src/pages/desktop/plugins/[id].astro

@@ -6,7 +6,12 @@ import { Image } from "astro:assets";
 import Banner from "../../../components/Banner.astro";
 import Layout from "../../../layouts/Layout.astro";
 import type { Plugin } from "../../../type";
-import { getLatestGephiVersion, isLegacyGephiVersion, normalizeGephiVersion } from "../../../components/plugins/utils";
+import {
+  compareGephiVersionsDesc,
+  getLatestGephiVersion,
+  groupPluginVersionsByTag,
+  isLegacyGephiVersion,
+} from "../../../components/plugins/utils";
 
 interface Props {
   plugin: Plugin;
@@ -37,15 +42,8 @@ try {
 
 // Since Gephi 0.10, plugin builds are no longer version-specific at the patch level, so
 // group download links by normalized version, keeping the most recently updated build per group.
-const groupedVersions = Object.entries(plugin.versions).reduce<Record<string, Plugin["versions"][string]>>(
-  (acc, [v, info]) => {
-    const tag = normalizeGephiVersion(v);
-    if (!acc[tag] || new Date(info.last_update) > new Date(acc[tag].last_update)) acc[tag] = info;
-    return acc;
-  },
-  {},
-);
-const sortedVersionTags = Object.keys(groupedVersions).reverse();
+const groupedVersions = groupPluginVersionsByTag(plugin.versions);
+const sortedVersionTags = Object.keys(groupedVersions).sort(compareGephiVersionsDesc);
 const modernVersionTags = sortedVersionTags.filter((v) => !isLegacyGephiVersion(v));
 const legacyVersionTags = sortedVersionTags.filter(isLegacyGephiVersion);
 const topVersionTag = modernVersionTags[0];
@@ -172,7 +170,7 @@ const topVersionIsLatestGephi = !!topVersionTag && topVersionTag === latestGephi
               instance.
             </div>
             {
-              modernVersionTags.length > 0 || legacyVersionTags.length > 0 ? (
+              sortedVersionTags.length > 0 ? (
                 <>
                   {modernVersionTags.length > 0 && (
                     <ul class="list-unstyled">

src/pages/desktop/plugins/index.astro

@@ -7,7 +7,7 @@ import Default from "../../../images/plugins/default-screenshot.jpg";
 import Layout from "../../../layouts/Layout.astro";
 import { PluginsFilters } from "../../../components/plugins/PluginsFilters";
 import type { Plugin } from "../../../type";
-import { pluginElementId } from "../../../components/plugins/utils";
+import { pluginElementId, pluginHasModernVersion } from "../../../components/plugins/utils";
 
 const pluginsDataRequest = await fetch(
   "https://raw.githubusercontent.com/gephi/gephi-plugins/refs/heads/gh-pages/plugins/plugins.json",
@@ -16,6 +16,10 @@ const pluginsDataRequest = await fetch(
 const pluginsData: Plugin[] | null = pluginsDataRequest.ok
   ? reverse(sortBy((await pluginsDataRequest.json()).plugins as Plugin[], (p) => new Date(p.last_update)))
   : null;
+
+// Matches PluginsFilters' default (legacy plugins hidden) so the count doesn't flash/mismatch
+// before hydration, and stays correct for no-JS clients.
+const defaultVisibleCount = pluginsData?.filter(pluginHasModernVersion).length ?? 0;
 ---
 
 <Layout pageId="desktop-plugins">
@@ -47,7 +51,7 @@ const pluginsData: Plugin[] | null = pluginsDataRequest.ok
 
           <section class="plugins-list-container container-fluid">
             <h2 id="plugins-list-total">
-              {pluginsData.length || "No"} {pluginsData.length > 1 ? "plugins" : "plugin"}
+              {defaultVisibleCount || "No"} {defaultVisibleCount > 1 ? "plugins" : "plugin"}
             </h2>
             <div class="plugins-list row">
               {pluginsData.map((p) => (

src/styles/_plugins.scss

@@ -140,12 +140,12 @@
       &::-webkit-details-marker {
         display: none;
       }
-    }
 
-    svg {
-      transition: all 0.2s ease-out;
+      svg {
+        transition: all 0.2s ease-out;
+      }
     }
-    &[open] svg {
+    &[open] summary svg {
       transform: rotate(180deg);
     }
   }