Refactos IPv4 /31,32 fix and improves logic

Author: Lissy93

src/lib/components/tools/NetworkVisualizer.svelte

@@ -14,55 +14,44 @@
    * Generates visual representation of network range
    */
   function generateNetworkBlocks() {
-    const totalHosts = subnetInfo.hostCount;
-    const _usableHosts = subnetInfo.usableHosts;
-    const cidr = subnetInfo.cidr;
-
-    // For visualization, we'll show up to 256 blocks max
+    const { hostCount, cidr } = subnetInfo;
     const maxBlocks = 256;
-    const blocksToShow = Math.min(totalHosts, maxBlocks);
-    const blockSize = totalHosts > maxBlocks ? Math.ceil(totalHosts / maxBlocks) : 1;
-
-    const blocks = [];
-
-    // RFC 3021: /31 networks have no network/broadcast addresses
-    const is31Subnet = cidr === 31;
-    const is32Subnet = cidr === 32;
-
-    for (let i = 0; i < blocksToShow; i++) {
-      let type: 'network' | 'broadcast' | 'usable';
-      let tooltip: string;
-
-      if (is31Subnet) {
-        // /31: Both IPs are usable hosts (point-to-point)
-        type = 'usable';
-        tooltip = i === 0 ? 'Usable Host 1 (P2P)' : 'Usable Host 2 (P2P)';
-      } else if (is32Subnet) {
-        // /32: Single host
-        type = 'usable';
-        tooltip = 'Single Host';
-      } else {
-        // Normal subnet: first is network, last is broadcast, rest are usable
-        const isNetwork = i === 0;
-        const isBroadcast = i === blocksToShow - 1 && totalHosts > 2;
-
-        type = isNetwork ? 'network' : isBroadcast ? 'broadcast' : 'usable';
-        tooltip = isNetwork
-          ? 'Network Address'
-          : isBroadcast
-            ? 'Broadcast Address'
-            : `Usable Host${blockSize > 1 ? 's' : ''}`;
+    const blocksToShow = Math.min(hostCount, maxBlocks);
+    const blockSize = hostCount > maxBlocks ? Math.ceil(hostCount / maxBlocks) : 1;
+
+    return Array.from({ length: blocksToShow }, (_, i) => {
+      const isFirst = i === 0;
+      const isLast = i === blocksToShow - 1;
+
+      // RFC 3021: /31 and /32 have all IPs usable
+      if (cidr === 31) {
+        return {
+          id: i,
+          type: 'usable' as const,
+          represents: blockSize,
+          tooltip: isFirst ? 'Usable Host 1 (P2P)' : 'Usable Host 2 (P2P)',
+        };
       }
 
-      blocks.push({
-        id: i,
-        type,
-        represents: blockSize,
-        tooltip,
-      });
-    }
+      if (cidr === 32) {
+        return {
+          id: i,
+          type: 'usable' as const,
+          represents: blockSize,
+          tooltip: 'Single Host',
+        };
+      }
+
+      // Normal subnets have network/broadcast reserved
+      const type = isFirst ? 'network' : isLast && hostCount > 2 ? 'broadcast' : 'usable';
+      const tooltip = isFirst
+        ? 'Network Address'
+        : isLast && hostCount > 2
+          ? 'Broadcast Address'
+          : `Usable Host${blockSize > 1 ? 's' : ''}`;
 
-    return blocks;
+      return { id: i, type, represents: blockSize, tooltip };
+    });
   }
 
   let networkBlocks = $derived(generateNetworkBlocks());

src/lib/utils/ip-calculations.ts

@@ -74,33 +74,17 @@ export function calculateSubnet(ip: string, cidr: number): SubnetInfo {
   const hostBits = 32 - cidr;
   const hostCount = Math.pow(2, hostBits);
 
-  // Calculate usable hosts based on CIDR
-  // RFC 3021: /31 has 2 usable hosts (point-to-point, no network/broadcast)
-  // /32 has 1 usable host (single host route)
-  // All others: total - 2 (excluding network and broadcast)
-  let usableHosts: number;
-  if (cidr === 32) {
-    usableHosts = 1;
-  } else if (cidr === 31) {
-    usableHosts = 2; // Both IPs are usable for point-to-point links
-  } else {
-    usableHosts = hostCount - 2;
-  }
+  // RFC 3021: /31 point-to-point has both IPs usable, /32 is single host
+  const usableHosts = cidr === 32 ? 1 : cidr === 31 ? 2 : hostCount - 2;
 
-  // Calculate first and last host based on CIDR
+  // For /31 and /32, all IPs are usable (no reserved network/broadcast)
   let firstHost: IPAddress;
   let lastHost: IPAddress;
 
-  if (cidr === 32) {
-    // Host route - first and last are the same
-    firstHost = network;
-    lastHost = network;
-  } else if (cidr === 31) {
-    // Point-to-point - use network and broadcast as hosts (RFC 3021)
+  if (cidr >= 31) {
     firstHost = network;
-    lastHost = broadcast;
+    lastHost = cidr === 32 ? network : broadcast;
   } else {
-    // Normal subnet - exclude network and broadcast
     firstHost = numberToIP(ipToNumber(network.octets.join('.')) + 1);
     lastHost = numberToIP(ipToNumber(broadcast.octets.join('.')) - 1);
   }

tests/unit/utils/ip-calculations.test.ts

@@ -245,4 +245,4 @@ describe('IP calculations core logic', () => {
       expect(subnet.usableHosts).toBe(2);
     });
   });
-});
+});