gloomberb 0.5.1 → 0.6.0

package/src/utils/dom-screenshot.ts

@@ -0,0 +1,326 @@
+/// <reference lib="dom" />
+
+export interface PngScreenshot {
+  pngBase64: string;
+  width: number;
+  height: number;
+}
+
+interface CaptureOrigin {
+  left: number;
+  top: number;
+}
+
+function escapeAttributeValue(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+
+export function findPaneScreenshotTarget(paneId?: string): HTMLElement | null {
+  if (typeof document === "undefined") return null;
+  if (paneId) {
+    const escapedPaneId = escapeAttributeValue(paneId);
+    const target = document.querySelector<HTMLElement>(`[data-gloom-pane-id="${escapedPaneId}"]`);
+    if (target) return target;
+  }
+  return document.querySelector<HTMLElement>(
+    "[data-gloom-role='pane-window'][data-focused='true'], [data-gloom-role='detached-pane-window'][data-focused='true']",
+  );
+}
+
+function isVisible(style: CSSStyleDeclaration): boolean {
+  return style.display !== "none" && style.visibility !== "hidden" && Number.parseFloat(style.opacity || "1") > 0;
+}
+
+function isPaintableColor(value: string): boolean {
+  return value !== "" && value !== "transparent" && !/^rgba?\(\s*0\s*,\s*0\s*,\s*0\s*,\s*0\s*\)$/i.test(value);
+}
+
+function px(value: string): number {
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function localRect(rect: DOMRect, origin: CaptureOrigin) {
+  return {
+    x: rect.left - origin.left,
+    y: rect.top - origin.top,
+    width: rect.width,
+    height: rect.height,
+  };
+}
+
+function roundedRectPath(
+  context: CanvasRenderingContext2D,
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+  radius: number,
+): void {
+  const r = Math.max(0, Math.min(radius, width / 2, height / 2));
+  context.beginPath();
+  context.moveTo(x + r, y);
+  context.lineTo(x + width - r, y);
+  context.quadraticCurveTo(x + width, y, x + width, y + r);
+  context.lineTo(x + width, y + height - r);
+  context.quadraticCurveTo(x + width, y + height, x + width - r, y + height);
+  context.lineTo(x + r, y + height);
+  context.quadraticCurveTo(x, y + height, x, y + height - r);
+  context.lineTo(x, y + r);
+  context.quadraticCurveTo(x, y, x + r, y);
+  context.closePath();
+}
+
+function fillBackground(
+  context: CanvasRenderingContext2D,
+  style: CSSStyleDeclaration,
+  rect: ReturnType<typeof localRect>,
+): void {
+  if (!isPaintableColor(style.backgroundColor)) return;
+  context.fillStyle = style.backgroundColor;
+  roundedRectPath(context, rect.x, rect.y, rect.width, rect.height, px(style.borderTopLeftRadius));
+  context.fill();
+}
+
+function strokeBorder(
+  context: CanvasRenderingContext2D,
+  style: CSSStyleDeclaration,
+  rect: ReturnType<typeof localRect>,
+): void {
+  const widths = [
+    px(style.borderTopWidth),
+    px(style.borderRightWidth),
+    px(style.borderBottomWidth),
+    px(style.borderLeftWidth),
+  ];
+  if (widths.every((width) => width <= 0) || !isPaintableColor(style.borderTopColor)) return;
+
+  context.strokeStyle = style.borderTopColor;
+  context.lineWidth = Math.max(...widths);
+  roundedRectPath(
+    context,
+    rect.x + context.lineWidth / 2,
+    rect.y + context.lineWidth / 2,
+    Math.max(0, rect.width - context.lineWidth),
+    Math.max(0, rect.height - context.lineWidth),
+    px(style.borderTopLeftRadius),
+  );
+  context.stroke();
+}
+
+function shouldClip(style: CSSStyleDeclaration): boolean {
+  return [style.overflow, style.overflowX, style.overflowY].some((value) => (
+    value === "hidden" || value === "clip" || value === "auto" || value === "scroll"
+  ));
+}
+
+function applyClip(
+  context: CanvasRenderingContext2D,
+  style: CSSStyleDeclaration,
+  rect: ReturnType<typeof localRect>,
+): boolean {
+  if (!shouldClip(style)) return false;
+  roundedRectPath(context, rect.x, rect.y, rect.width, rect.height, px(style.borderTopLeftRadius));
+  context.clip();
+  return true;
+}
+
+function fontFor(style: CSSStyleDeclaration): string {
+  if (style.font) return style.font;
+  return [
+    style.fontStyle || "normal",
+    style.fontVariant || "normal",
+    style.fontWeight || "400",
+    `${style.fontSize || "14px"}/${style.lineHeight || "normal"}`,
+    style.fontFamily || "monospace",
+  ].join(" ");
+}
+
+function textBaselineOffset(style: CSSStyleDeclaration, rect: DOMRect): number {
+  const fontSize = px(style.fontSize) || rect.height;
+  const lineHeight = px(style.lineHeight) || rect.height || fontSize;
+  return Math.max(fontSize * 0.78, (lineHeight + fontSize * 0.58) / 2);
+}
+
+function drawTextNode(
+  context: CanvasRenderingContext2D,
+  textNode: Text,
+  origin: CaptureOrigin,
+): void {
+  const value = textNode.nodeValue ?? "";
+  if (value.length === 0 || value.trim().length === 0) return;
+  const parent = textNode.parentElement;
+  if (!parent) return;
+  const style = getComputedStyle(parent);
+  if (!isVisible(style) || !isPaintableColor(style.color)) return;
+
+  const range = document.createRange();
+  range.selectNodeContents(textNode);
+  const rects = Array.from(range.getClientRects()).filter((rect) => rect.width > 0 && rect.height > 0);
+  range.detach();
+  if (rects.length === 0) return;
+
+  context.fillStyle = style.color;
+  context.font = fontFor(style);
+  context.textAlign = "left";
+  context.textBaseline = "alphabetic";
+  context.direction = style.direction === "rtl" ? "rtl" : "ltr";
+
+  const explicitLines = value.split(/\r?\n/);
+  if (explicitLines.length === rects.length) {
+    rects.forEach((rect, index) => {
+      const line = explicitLines[index] ?? "";
+      if (line.length === 0) return;
+      context.fillText(line, rect.left - origin.left, rect.top - origin.top + textBaselineOffset(style, rect));
+    });
+    return;
+  }
+
+  context.fillText(value, rects[0]!.left - origin.left, rects[0]!.top - origin.top + textBaselineOffset(style, rects[0]!));
+}
+
+function drawCanvasElement(
+  context: CanvasRenderingContext2D,
+  canvas: HTMLCanvasElement,
+  origin: CaptureOrigin,
+): void {
+  const rect = canvas.getBoundingClientRect();
+  if (rect.width <= 0 || rect.height <= 0) return;
+  try {
+    context.drawImage(canvas, rect.left - origin.left, rect.top - origin.top, rect.width, rect.height);
+  } catch {
+    // Ignore canvases the browser considers unsafe to read.
+  }
+}
+
+function drawInputElement(
+  context: CanvasRenderingContext2D,
+  element: HTMLInputElement | HTMLTextAreaElement,
+  origin: CaptureOrigin,
+): void {
+  const value = element.value;
+  if (!value) return;
+  const style = getComputedStyle(element);
+  const rect = element.getBoundingClientRect();
+  if (!isVisible(style) || !isPaintableColor(style.color) || rect.width <= 0 || rect.height <= 0) return;
+  context.fillStyle = style.color;
+  context.font = fontFor(style);
+  const left = rect.left - origin.left + px(style.paddingLeft);
+  const top = rect.top - origin.top + px(style.paddingTop) + textBaselineOffset(style, rect);
+  for (const [index, line] of value.split(/\r?\n/).entries()) {
+    context.fillText(line, left, top + index * (px(style.lineHeight) || rect.height));
+  }
+}
+
+function drawElement(
+  context: CanvasRenderingContext2D,
+  element: Element,
+  origin: CaptureOrigin,
+): void {
+  if (!(element instanceof HTMLElement || element instanceof SVGElement)) return;
+
+  const style = getComputedStyle(element);
+  if (!isVisible(style)) return;
+
+  const rect = localRect(element.getBoundingClientRect(), origin);
+  if (rect.width <= 0 || rect.height <= 0) return;
+
+  context.save();
+  const opacity = Number.parseFloat(style.opacity || "1");
+  if (Number.isFinite(opacity)) {
+    context.globalAlpha *= Math.max(0, Math.min(opacity, 1));
+  }
+
+  fillBackground(context, style, rect);
+  strokeBorder(context, style, rect);
+  const clipped = applyClip(context, style, rect);
+
+  if (element instanceof HTMLCanvasElement) {
+    drawCanvasElement(context, element, origin);
+  } else if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+    drawInputElement(context, element, origin);
+  }
+
+  for (const child of Array.from(element.childNodes)) {
+    if (child.nodeType === Node.TEXT_NODE) {
+      drawTextNode(context, child as Text, origin);
+    } else if (child.nodeType === Node.ELEMENT_NODE) {
+      drawElement(context, child as Element, origin);
+    }
+  }
+
+  if (clipped) {
+    context.restore();
+  } else {
+    context.restore();
+  }
+}
+
+function blobToBase64(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = () => reject(reader.error ?? new Error("Could not read screenshot data."));
+    reader.onload = () => {
+      const result = typeof reader.result === "string" ? reader.result : "";
+      resolve(result.includes(",") ? result.slice(result.indexOf(",") + 1) : result);
+    };
+    reader.readAsDataURL(blob);
+  });
+}
+
+function canvasToPngBlob(canvas: HTMLCanvasElement): Promise<Blob> {
+  return new Promise((resolve, reject) => {
+    try {
+      canvas.toBlob((blob) => {
+        if (blob) resolve(blob);
+        else reject(new Error("Could not encode pane screenshot."));
+      }, "image/png");
+    } catch {
+      reject(new Error("Could not encode pane screenshot."));
+    }
+  });
+}
+
+async function waitForFonts(): Promise<void> {
+  const fontSet = document.fonts;
+  if (!fontSet) return;
+  await Promise.race([
+    fontSet.ready,
+    new Promise((resolve) => setTimeout(resolve, 250)),
+  ]).catch(() => {});
+}
+
+export async function captureElementPngBase64(element: HTMLElement): Promise<PngScreenshot> {
+  const rect = element.getBoundingClientRect();
+  const width = Math.ceil(rect.width);
+  const height = Math.ceil(rect.height);
+  if (width <= 0 || height <= 0) {
+    throw new Error("Pane is not visible.");
+  }
+
+  await waitForFonts();
+
+  const scale = Math.max(1, Math.min(globalThis.devicePixelRatio || 1, 3));
+  const canvas = document.createElement("canvas");
+  canvas.width = Math.ceil(width * scale);
+  canvas.height = Math.ceil(height * scale);
+  canvas.style.width = `${width}px`;
+  canvas.style.height = `${height}px`;
+  const context = canvas.getContext("2d");
+  if (!context) throw new Error("Could not create pane screenshot.");
+  context.scale(scale, scale);
+  context.clearRect(0, 0, width, height);
+  drawElement(context, element, { left: rect.left, top: rect.top });
+
+  return {
+    pngBase64: await blobToBase64(await canvasToPngBlob(canvas)),
+    width,
+    height,
+  };
+}
+
+export async function capturePaneScreenshotPngBase64(paneId?: string): Promise<PngScreenshot> {
+  const target = findPaneScreenshotTarget(paneId);
+  if (!target) throw new Error("Pane is not visible.");
+  return captureElementPngBase64(target);
+}

package/src/utils/exchange-rate-map.ts

@@ -1,3 +1,4 @@
+
 export function selectEffectiveExchangeRates(
   fetchedRates: Map<string, number>,
   persistedRates: Map<string, number>,

package/src/utils/exchanges.ts

@@ -0,0 +1,214 @@
+export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
+  NAS: "NASDAQ",
+  NASDAQ: "NASDAQ",
+  XNAS: "NASDAQ",
+  NMS: "NASDAQ",
+  NGM: "NASDAQ",
+  NCM: "NASDAQ",
+  NYQ: "NYSE",
+  NYS: "NYSE",
+  NYSE: "NYSE",
+  XNYS: "NYSE",
+  ASE: "AMEX",
+  AMEX: "AMEX",
+  XASE: "AMEX",
+  PCX: "AMEX",
+  ARCA: "ARCA",
+  ARCX: "ARCA",
+  BATS: "BATS",
+  TYO: "JPX",
+  TSE: "JPX",
+  TSEJ: "JPX",
+  JPX: "JPX",
+  HKG: "HKEX",
+  HKEX: "HKEX",
+  SEHK: "HKEX",
+  XHKG: "HKEX",
+  LON: "LSE",
+  LSE: "LSE",
+  XLON: "LSE",
+  TOR: "TSX",
+  TSX: "TSX",
+  XTSE: "TSX",
+  TSXV: "TSXV",
+  CN: "CSE",
+  CNSX: "CSE",
+  CSE: "CSE",
+  ASX: "ASX",
+  XASX: "ASX",
+  NZX: "NZX",
+  XNZE: "NZX",
+  SIX: "SWX",
+  SWX: "SWX",
+  EBS: "SWX",
+  XSWX: "SWX",
+  XETR: "XETRA",
+  XETRA: "XETRA",
+  IBIS: "XETRA",
+  IBIS2: "XETRA",
+  GER: "XETRA",
+  FSE: "FWB2",
+  FSX: "FWB2",
+  XFRA: "FWB2",
+  FWB: "FWB2",
+  FWB2: "FWB2",
+  EPA: "EPA",
+  XPAR: "EPA",
+  PAR: "EPA",
+  AMS: "AMS",
+  XAMS: "AMS",
+  BRU: "BRU",
+  XBRU: "BRU",
+  LIS: "LIS",
+  XLIS: "LIS",
+  BIT: "BIT",
+  XMIL: "BIT",
+  MIL: "BIT",
+  OMX: "SFB",
+  STO: "SFB",
+  XSTO: "SFB",
+  HEL: "HEL",
+  XHEL: "HEL",
+  CPH: "CPH",
+  XCSE: "CPH",
+  OSL: "OSL",
+  XOSL: "OSL",
+  ICE: "ICEX",
+  ICEX: "ICEX",
+  XICE: "ICEX",
+  WSE: "WSE",
+  XWAR: "WSE",
+  PRA: "PSE",
+  XPRA: "PSE",
+  VIE: "VIE",
+  XWBO: "VIE",
+  TPE: "TWSE",
+  TWSE: "TWSE",
+  TAI: "TWSE",
+  TWO: "TPEX",
+  TPEX: "TPEX",
+  ROCO: "TPEX",
+  NSE: "NSE",
+  NSI: "NSE",
+  XNSE: "NSE",
+  BSE: "BSE",
+  BOM: "BSE",
+  XBOM: "BSE",
+  SSE: "SSE",
+  XSHG: "SSE",
+  SHH: "SSE",
+  SZSE: "SZSE",
+  XSHE: "SZSE",
+  SHE: "SZSE",
+  KRX: "KRX",
+  XKRX: "KRX",
+  KOSPI: "KRX",
+  KOSDAQ: "KOSDAQ",
+  XKOS: "KOSDAQ",
+  SGX: "SGX",
+  XSES: "SGX",
+  BMV: "BMV",
+  XMEX: "BMV",
+  B3: "B3",
+  BVMF: "B3",
+  B3SA: "B3",
+  BUE: "BYMA",
+  BCBA: "BYMA",
+  JSE: "JSE",
+  XJSE: "JSE",
+  TLV: "TASE",
+  XTAE: "TASE",
+};
+
+export const PUBLIC_EXCHANGE_ALIASES: Record<string, string> = {
+  NASDAQ: "XNAS",
+  NYSE: "XNYS",
+  AMEX: "XASE",
+  ARCA: "ARCX",
+  HKEX: "XHKG",
+  LSE: "XLON",
+  TSX: "XTSE",
+  ASX: "XASX",
+  NZX: "XNZE",
+  SWX: "XSWX",
+  XETRA: "XETR",
+  FWB2: "XFRA",
+  EPA: "XPAR",
+  AMS: "XAMS",
+  BRU: "XBRU",
+  LIS: "XLIS",
+  BIT: "XMIL",
+  SFB: "XSTO",
+  HEL: "XHEL",
+  CPH: "XCSE",
+  OSL: "XOSL",
+  ICEX: "XICE",
+  WSE: "XWAR",
+  PSE: "XPRA",
+  VIE: "XWBO",
+  NSE: "XNSE",
+  BSE: "XBOM",
+  SSE: "XSHG",
+  SZSE: "XSHE",
+  KRX: "XKRX",
+  KOSDAQ: "XKOS",
+  SGX: "XSES",
+  BMV: "XMEX",
+  B3: "BVMF",
+  JSE: "XJSE",
+  TASE: "XTAE",
+};
+
+export const EXCHANGE_TIME_ZONES: Record<string, string> = {
+  NASDAQ: "America/New_York",
+  NYSE: "America/New_York",
+  ARCA: "America/New_York",
+  AMEX: "America/New_York",
+  BATS: "America/New_York",
+  FWB: "Europe/Berlin",
+  FWB2: "Europe/Berlin",
+  XETRA: "Europe/Berlin",
+  SWX: "Europe/Zurich",
+  SFB: "Europe/Stockholm",
+  HKEX: "Asia/Hong_Kong",
+  JPX: "Asia/Tokyo",
+  TPEX: "Asia/Taipei",
+  TWSE: "Asia/Taipei",
+  NSE: "Asia/Kolkata",
+  BSE: "Asia/Kolkata",
+  LSE: "Europe/London",
+  ASX: "Australia/Sydney",
+  SGX: "Asia/Singapore",
+  KRX: "Asia/Seoul",
+  KOSDAQ: "Asia/Seoul",
+};
+
+export function normalizeSymbol(value: string): string {
+  return value.trim().toUpperCase();
+}
+
+export function normalizeExchange(value?: string): string {
+  return (value ?? "").trim().toUpperCase();
+}
+
+export function canonicalExchange(value?: string): string {
+  const normalized = normalizeExchange(value);
+  return CANONICAL_EXCHANGE_ALIASES[normalized] ?? normalized;
+}
+
+export function publicExchange(value?: string): string {
+  const canonical = canonicalExchange(value);
+  return PUBLIC_EXCHANGE_ALIASES[canonical] ?? canonical;
+}
+
+export function canonicalTickerKey(symbol: string, exchange?: string): string {
+  const normalizedSymbol = normalizeSymbol(symbol);
+  const canonical = canonicalExchange(exchange);
+  return canonical ? `${normalizedSymbol}:${canonical}` : normalizedSymbol;
+}
+
+export function publicTickerKey(symbol: string, exchange?: string): string {
+  const normalizedSymbol = normalizeSymbol(symbol);
+  const publicValue = publicExchange(exchange);
+  return publicValue ? `${normalizedSymbol}:${publicValue}` : normalizedSymbol;
+}

package/src/utils/format.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { displayWidth, formatTimeAgo, padTo } from "./format";
+import { normalizeTimestamp } from "./timestamp";
 
 describe("formatTimeAgo", () => {
   test("handles UTC ISO timestamps with explicit offsets", () => {
@@ -13,6 +14,12 @@ describe("formatTimeAgo", () => {
   });
 });
 
+describe("normalizeTimestamp", () => {
+  test("parses Twitter API timestamps", () => {
+    expect(normalizeTimestamp("Wed Apr 29 03:20:20 +0000 2026")).toBe("2026-04-29T03:20:20.000Z");
+  });
+});
+
 describe("padTo", () => {
   test("pads and truncates by display width instead of UTF-16 length", () => {
     expect(displayWidth("🇺🇸")).toBe(2);

package/src/utils/format.ts

@@ -224,6 +224,7 @@ export function convertCurrency(
 /** Format a date/timestamp as relative time (e.g., "5m ago", "2h ago") */
 export function formatTimeAgo(date: Date | string): string {
   const ts = toTimestampMillis(date);
+  if (Number.isNaN(ts)) return "unknown";
   const seconds = Math.floor((Date.now() - ts) / 1000);
   if (seconds < 60) return "just now";
   const minutes = Math.floor(seconds / 60);

package/src/utils/fuzzy-search.ts

@@ -1,3 +1,4 @@
+
 /** Simple fuzzy matching: all query chars must appear in order in target */
 export function fuzzyMatch(query: string, target: string): { match: boolean; score: number } {
   const q = query.toLowerCase();

package/src/utils/html-entities.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, test } from "bun:test";
+import { decodeHtmlEntities } from "./html-entities";
+
+describe("decodeHtmlEntities", () => {
+  test("decodes common tweet HTML entities", () => {
+    expect(decodeHtmlEntities("demand/supply & unit economics $ASML")).toBe("demand/supply & unit economics $ASML");
+  });
+});

package/src/utils/html-entities.ts

@@ -0,0 +1,32 @@
+const NAMED_ENTITIES: Record<string, string> = {
+  amp: "&",
+  apos: "'",
+  gt: ">",
+  lt: "<",
+  nbsp: " ",
+  quot: "\"",
+};
+
+function decodeCodePoint(codePoint: number, fallback: string): string {
+  return Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= 0x10ffff
+    ? String.fromCodePoint(codePoint)
+    : fallback;
+}
+
+export function decodeHtmlEntities(value: string): string {
+  return value.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z][a-z0-9]+);?/gi, (match, entity: string) => {
+    const normalized = entity.toLowerCase();
+
+    if (normalized.startsWith("#x")) {
+      const codePoint = Number.parseInt(normalized.slice(2), 16);
+      return decodeCodePoint(codePoint, match);
+    }
+
+    if (normalized.startsWith("#")) {
+      const codePoint = Number.parseInt(normalized.slice(1), 10);
+      return decodeCodePoint(codePoint, match);
+    }
+
+    return NAMED_ENTITIES[normalized] ?? match;
+  });
+}

package/src/utils/http-transport.ts

@@ -0,0 +1,11 @@
+export type HttpFetchTransport = (url: string, init?: RequestInit) => Promise<Response>;
+
+let httpFetchTransport: HttpFetchTransport | null = null;
+
+export function setHttpFetchTransport(transport: HttpFetchTransport | null): void {
+  httpFetchTransport = transport;
+}
+
+export function httpFetch(url: string, init?: RequestInit): Promise<Response> {
+  return (httpFetchTransport ?? globalThis.fetch)(url, init);
+}