hackernews-tui 0.1.0

package/src/lib/hn-utils.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import {
+  classifyStory,
+  cycleValue,
+  decodeHtmlEntities,
+  formatRelativeTime,
+  getErrorMessage,
+  htmlToText,
+  toSingleLine,
+  truncate,
+} from "./hn-utils";
+
+describe("hn-utils", () => {
+  test("truncate returns original when under limit", () => {
+    expect(truncate("hello", 10)).toBe("hello");
+  });
+
+  test("truncate adds ellipsis when over limit", () => {
+    expect(truncate("abcdefghij", 7)).toBe("abcd...");
+  });
+
+  test("toSingleLine strips newlines and tabs", () => {
+    expect(toSingleLine("foo\nbar\t baz")).toBe("foo bar baz");
+  });
+
+  test("decodeHtmlEntities decodes named and numeric entities", () => {
+    expect(decodeHtmlEntities("Tom &amp; Jerry &#39;ok&#39; &lt;3")).toBe("Tom & Jerry 'ok' <3");
+  });
+
+  test("htmlToText strips tags and keeps structure", () => {
+    const input = "<p>Hello &amp; welcome</p><li>one</li><li>two</li><br/>done";
+    expect(htmlToText(input)).toBe("Hello & welcome\n- one\n- two\ndone");
+  });
+
+  test("formatRelativeTime uses provided now timestamp", () => {
+    const nowMs = 1_700_000_000_000;
+    const nowSeconds = Math.floor(nowMs / 1000);
+    expect(formatRelativeTime(nowSeconds - 30, nowMs)).toBe("30s ago");
+    expect(formatRelativeTime(nowSeconds - 3600, nowMs)).toBe("1h ago");
+  });
+
+  test("classifyStory detects ask/show/job", () => {
+    expect(classifyStory({ id: 1, title: "Ask HN: something", type: "story" })).toBe("ask");
+    expect(classifyStory({ id: 2, title: "Show HN: app", type: "story" })).toBe("show");
+    expect(classifyStory({ id: 3, title: "job", type: "job" })).toBe("job");
+    expect(classifyStory({ id: 4, title: "Normal story", type: "story" })).toBe("story");
+  });
+
+  test("cycleValue rotates and wraps", () => {
+    const values = ["a", "b", "c"] as const;
+    expect(cycleValue(values, "a")).toBe("b");
+    expect(cycleValue(values, "c")).toBe("a");
+  });
+
+  test("getErrorMessage handles unknown values", () => {
+    expect(getErrorMessage(new Error("boom"))).toBe("boom");
+    expect(getErrorMessage("x")).toBe("Unknown error");
+  });
+});

package/src/lib/hn-utils.ts

@@ -0,0 +1,157 @@
+export interface HNItem {
+  id: number;
+  deleted?: boolean;
+  type?: "job" | "story" | "comment" | "poll" | "pollopt";
+  by?: string;
+  time?: number;
+  text?: string;
+  dead?: boolean;
+  parent?: number;
+  poll?: number;
+  kids?: number[];
+  url?: string;
+  score?: number;
+  title?: string;
+  parts?: number[];
+  descendants?: number;
+}
+
+export type StoryKind = "story" | "ask" | "show" | "job";
+
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return "Unknown error";
+}
+
+export function truncate(value: string, maxLength: number): string {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  if (maxLength <= 3) {
+    return value.slice(0, maxLength);
+  }
+  return `${value.slice(0, maxLength - 3)}...`;
+}
+
+export function toSingleLine(value: string): string {
+  return value
+    .replace(/[\r\n\t]+/g, " ")
+    .replace(/\s{2,}/g, " ")
+    .trim();
+}
+
+export function decodeHtmlEntities(value: string): string {
+  return value.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (_, rawEntity: string) => {
+    if (rawEntity.startsWith("#x") || rawEntity.startsWith("#X")) {
+      const codePoint = Number.parseInt(rawEntity.slice(2), 16);
+      if (Number.isFinite(codePoint)) {
+        return String.fromCodePoint(codePoint);
+      }
+      return `&${rawEntity};`;
+    }
+
+    if (rawEntity.startsWith("#")) {
+      const codePoint = Number.parseInt(rawEntity.slice(1), 10);
+      if (Number.isFinite(codePoint)) {
+        return String.fromCodePoint(codePoint);
+      }
+      return `&${rawEntity};`;
+    }
+
+    switch (rawEntity) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+      case "rsquo":
+      case "lsquo":
+      case "#39":
+      case "#x27":
+        return "'";
+      case "nbsp":
+        return " ";
+      default:
+        return `&${rawEntity};`;
+    }
+  });
+}
+
+export function htmlToText(input?: string): string {
+  if (!input) {
+    return "";
+  }
+
+  const withBreaks = input
+    .replace(/<p>/gi, "\n\n")
+    .replace(/<\/p>/gi, "")
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/<li>/gi, "\n- ")
+    .replace(/<\/li>/gi, "");
+
+  const withoutTags = withBreaks.replace(/<[^>]+>/g, "");
+  return decodeHtmlEntities(withoutTags)
+    .replace(/\u00a0/g, " ")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+export function formatRelativeTime(unixSeconds?: number, nowMs: number = Date.now()): string {
+  if (!unixSeconds) {
+    return "unknown time";
+  }
+
+  const seconds = Math.max(0, Math.floor(nowMs / 1000) - unixSeconds);
+  if (seconds < 60) {
+    return `${seconds}s ago`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m ago`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h ago`;
+  }
+  const days = Math.floor(hours / 24);
+  if (days < 30) {
+    return `${days}d ago`;
+  }
+  const months = Math.floor(days / 30);
+  if (months < 12) {
+    return `${months}mo ago`;
+  }
+  const years = Math.floor(months / 12);
+  return `${years}y ago`;
+}
+
+export function classifyStory(item: HNItem): StoryKind {
+  if (item.type === "job") {
+    return "job";
+  }
+
+  const title = (item.title ?? "").toLowerCase();
+  if (title.startsWith("ask hn")) {
+    return "ask";
+  }
+  if (title.startsWith("show hn")) {
+    return "show";
+  }
+  return "story";
+}
+
+export function cycleValue<T>(values: readonly T[], current: T): T {
+  const currentIndex = values.indexOf(current);
+  if (currentIndex < 0) {
+    return values[0] as T;
+  }
+  const nextIndex = (currentIndex + 1) % values.length;
+  return values[nextIndex] as T;
+}

package/src/lib/open-external-url.ts

@@ -0,0 +1,17 @@
+import { spawn } from "node:child_process";
+
+export function openExternalUrl(url: string): void {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    const child = spawn("open", [url], { detached: true, stdio: "ignore" });
+    child.unref();
+    return;
+  }
+  if (platform === "win32") {
+    const child = spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" });
+    child.unref();
+    return;
+  }
+  const child = spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+  child.unref();
+}