feat: slight stats updates for better results and ux

Author: Wamy-Dev

src/commands/test.ts

@@ -23,8 +23,11 @@ import {
   timingRows,
   seekRows,
   downloadRows,
+  seekStatsRows,
+  computeSeekStats,
   formatBytes,
   formatSpeed,
+  formatEta,
 } from "../library/tables";
 import { sendResultsToPrivatebin } from "../functions/privatebinFunctions";
 
@@ -51,7 +54,11 @@ function makeProgressBox(renderer: CliRenderer, title: string) {
       bar.content = "░".repeat(BAR_WIDTH);
     }
     const total = state.totalBytes !== null ? ` / ${formatBytes(state.totalBytes)}` : "";
-    stats.content = `${formatBytes(state.bytes)}${total}  ·  ${formatSpeed(state.bytesPerSecond)}`;
+    const eta =
+      state.totalBytes !== null && state.bytesPerSecond > 0
+        ? `  ·  ETA ${formatEta((state.totalBytes - state.bytes) / state.bytesPerSecond)}`
+        : "";
+    stats.content = `${formatBytes(state.bytes)}${total}  ·  ${formatSpeed(state.bytesPerSecond)}${eta}`;
   };
 
   const finish = (color: string) => {
@@ -100,6 +107,7 @@ export default defineCommand({
       : null;
 
     const results = new Map<TimingPhase, number>();
+    let latencyMs: number | null = null;
     if (!skipTimings && renderer) {
       const progressBox = new BoxRenderable(renderer, {
         borderStyle: "rounded",
@@ -115,16 +123,29 @@ export default defineCommand({
         rows.set(key, row);
         progressBox.add(row);
       }
+      const latencyRow = new TextRenderable(renderer, {
+        content: `⋯  Latency`,
+        fg: "#888888",
+      });
+      progressBox.add(latencyRow);
       renderer.root.add(progressBox);
 
-      await getLinkTimings(link, undefined, (phase, ms) => {
+      const linkTimings = await getLinkTimings(link, undefined, (phase, ms) => {
         results.set(phase, ms);
         const row = rows.get(phase);
         if (!row) return;
         const label = PHASES.find((p) => p.key === phase)?.label ?? phase;
         row.content = `✓  ${label.padEnd(16)} ${ms.toFixed(2)} ms`;
         row.fg = "#00d787";
       });
+      latencyMs = linkTimings?.tcp ?? null;
+      if (latencyMs !== null) {
+        latencyRow.content = `✓  ${"Latency".padEnd(16)} ${latencyMs.toFixed(2)} ms`;
+        latencyRow.fg = "#00d787";
+      } else {
+        latencyRow.content = `✗  Latency`;
+        latencyRow.fg = "#ff5f5f";
+      }
     }
 
     const seekResults = skipSeek
@@ -166,21 +187,25 @@ export default defineCommand({
       ? null
       : await sendResultsToPrivatebin({
           linkInfo: linkInfo,
-          timings: !skipTimings ? Object.fromEntries(results) : undefined,
-          seekResults: !skipSeek && seekResults ? seekResults : undefined,
+          timings: !skipTimings
+            ? { ...Object.fromEntries(results), latencyMs }
+            : undefined,
+          seekResults: !skipSeek && seekResults
+            ? { runs: seekResults, stats: computeSeekStats(seekResults) }
+            : undefined,
           downloadResults: !skipDownload ? { single: singleResult, multi: multiResult } : undefined,
         });
 
     console.log(renderTable("Link Information", linkInfoRows(linkInfo)));
     if (!skipTimings) {
-      console.log(renderTable("Network Timings", timingRows(results)));
+      console.log(renderTable("Network Timings", timingRows(results, latencyMs)));
     }
     if (!skipSeek && seekResults) {
       console.log(
         renderMultiTable(
           "Seek Results",
           ["#", "Status", "TTFB", "Receive", "Total"],
-          seekRows(seekResults),
+          [...seekRows(seekResults), ...seekStatsRows(seekResults)],
         ),
       );
     }

src/functions/linkValidation.ts

@@ -11,9 +11,19 @@ export type LinkInformation = {
     error?: string;
 }
 
-async function isVideoLink(headers: Headers): Promise<boolean> {
+const VIDEO_EXTENSIONS = new Set([
+    "mp4", "mkv", "webm", "mov", "avi", "flv", "wmv",
+    "m4v", "mpg", "mpeg", "ts", "m2ts", "3gp", "ogv", "vob",
+]);
+
+async function isVideoLink(headers: Headers, fileName: string | null): Promise<boolean> {
     const contentType = headers.get("Content-Type");
-    return contentType ? contentType.startsWith("video/") : false;
+    if (contentType?.startsWith("video/")) return true;
+    if (fileName) {
+        const ext = fileName.split(".").pop()?.toLowerCase();
+        if (ext && VIDEO_EXTENSIONS.has(ext)) return true;
+    }
+    return false;
 }
 
 async function getLinkName(headers: Headers, link: string): Promise<string> {
@@ -113,14 +123,15 @@ export async function getLinkInformation(link: string): Promise<LinkInformation>
             };
         }
 
+        const fileName = await getLinkName(response.headers, link);
         const data: LinkInformation = {
             status: response.status,
             contentType: response.headers.get("Content-Type"),
             size: await linkSize(response.headers),
             acceptsRanges: await linkAcceptsRanges(response.headers),
-            fileName: await getLinkName(response.headers, link),
+            fileName,
             domain: new URL(link).hostname,
-            isVideo: await isVideoLink(response.headers)
+            isVideo: await isVideoLink(response.headers, fileName)
         }
         return data;
     } catch (error) {

src/library/tables.ts

@@ -25,6 +25,17 @@ export function formatDuration(ms: number): string {
   return `${(ms / 1000).toFixed(2)} s`;
 }
 
+export function formatEta(seconds: number): string {
+  if (!Number.isFinite(seconds) || seconds < 0) return "—";
+  const s = Math.round(seconds);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  const sec = s % 60;
+  const pad = (n: number) => n.toString().padStart(2, "0");
+  if (h > 0) return `${h}:${pad(m)}:${pad(sec)}`;
+  return `${m}:${pad(sec)}`;
+}
+
 export const PHASES: { key: TimingPhase; label: string }[] = [
   { key: "dns", label: "DNS Resolution" },
   { key: "tcp", label: "TCP Connect" },
@@ -46,23 +57,27 @@ export function renderTable(title: string, rows: [string, string][]): string {
   return [top, sep, ...body, bot].join("\n");
 }
 
+export type TableRow = string[] | "separator";
+
 export function renderMultiTable(
   title: string,
   headers: string[],
-  rows: string[][],
+  rows: TableRow[],
 ): string {
+  const dataRows = rows.filter((r): r is string[] => Array.isArray(r));
   const widths = headers.map((h, i) =>
-    Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)),
+    Math.max(h.length, ...dataRows.map((r) => (r[i] ?? "").length)),
   );
   const inner = widths.reduce((a, b) => a + b, 0) + (widths.length - 1) * 3 + 2;
   const titleBar = ` ${title} `;
   const top = `╭${titleBar}${"─".repeat(Math.max(0, inner - titleBar.length))}╮`;
   const colSep = `├${widths.map((w) => "─".repeat(w + 2)).join("┬")}┤`;
   const headerLine = `│ ${headers.map((h, i) => h.padEnd(widths[i]!)).join(" │ ")} │`;
   const headerSep = `├${widths.map((w) => "─".repeat(w + 2)).join("┼")}┤`;
-  const bodyLines = rows.map(
-    (r) => `│ ${r.map((c, i) => (c ?? "").padEnd(widths[i]!)).join(" │ ")} │`,
-  );
+  const bodyLines = rows.map((r) => {
+    if (r === "separator") return headerSep;
+    return `│ ${r.map((c, i) => (c ?? "").padEnd(widths[i]!)).join(" │ ")} │`;
+  });
   const bot = `╰${widths.map((w) => "─".repeat(w + 2)).join("┴")}╯`;
   return [top, colSep, headerLine, headerSep, ...bodyLines, bot].join("\n");
 }
@@ -80,11 +95,18 @@ export function linkInfoRows(info: LinkInformation): [string, string][] {
   ];
 }
 
-export function timingRows(results: Map<TimingPhase, number>): [string, string][] {
-  return PHASES.map(({ key, label }) => [
+export function timingRows(
+  results: Map<TimingPhase, number>,
+  latencyMs?: number | null,
+): [string, string][] {
+  const rows: [string, string][] = PHASES.map(({ key, label }) => [
     label,
     results.has(key) ? `${results.get(key)!.toFixed(2)} ms` : "—",
   ]);
+  if (latencyMs !== undefined) {
+    rows.push(["Latency", latencyMs !== null ? `${latencyMs.toFixed(2)} ms` : "—"]);
+  }
+  return rows;
 }
 
 export function downloadRows(
@@ -114,3 +136,63 @@ export function seekRows(seeks: LinkTimings[]): string[][] {
     fmt(s.total),
   ]);
 }
+
+export interface SeekStat {
+  avg: number;
+  stdev: number;
+  min: number;
+  max: number;
+}
+
+export interface SeekStats {
+  ttfb: SeekStat | null;
+  receive: SeekStat | null;
+  total: SeekStat | null;
+}
+
+function statsOf(values: number[]): SeekStat | null {
+  if (values.length === 0) return null;
+  const avg = values.reduce((a, b) => a + b, 0) / values.length;
+  const stdev =
+    values.length < 2
+      ? 0
+      : Math.sqrt(
+          values.reduce((a, b) => a + (b - avg) ** 2, 0) / (values.length - 1),
+        );
+  return { avg, stdev, min: Math.min(...values), max: Math.max(...values) };
+}
+
+export function computeSeekStats(seeks: LinkTimings[]): SeekStats {
+  const collect = (pick: (s: LinkTimings) => number | null) =>
+    seeks.map(pick).filter((v): v is number => v !== null);
+  return {
+    ttfb: statsOf(collect((s) => s.wait)),
+    receive: statsOf(collect((s) => s.receive)),
+    total: statsOf(collect((s) => s.total)),
+  };
+}
+
+export function seekStatsRows(seeks: LinkTimings[]): TableRow[] {
+  const fmt = (n: number | null | undefined) =>
+    n === null || n === undefined ? "—" : `${n.toFixed(2)} ms`;
+  const stats = computeSeekStats(seeks);
+  const cols: Array<keyof SeekStat> = ["avg", "stdev", "min", "max"];
+  const labels: Record<keyof SeekStat, string> = {
+    avg: "Avg",
+    stdev: "Stdev",
+    min: "Min",
+    max: "Max",
+  };
+  const rows: TableRow[] = [];
+  for (const key of cols) {
+    rows.push("separator");
+    rows.push([
+      labels[key],
+      "",
+      fmt(stats.ttfb?.[key]),
+      fmt(stats.receive?.[key]),
+      fmt(stats.total?.[key]),
+    ]);
+  }
+  return rows;
+}