gloomberb 0.10.4 → 0.11.0

package/src/plugins/builtin/ipo-calendar/client.ts

@@ -0,0 +1,296 @@
+import type { ConnectionHealthRegistry } from "../../../core/connection-health";
+import { httpFetch } from "../../../utils/http-transport";
+import type { IPORecord, IPOStatus } from "./types";
+
+export const STOCKANALYSIS_IPO_CONNECTION_ID = "stockanalysis-ipo";
+
+const SA_RECENT_URL = "https://stockanalysis.com/ipos/__data.json";
+const SA_CALENDAR_URL = "https://stockanalysis.com/ipos/calendar/__data.json";
+const FETCH_TIMEOUT_MS = 15_000;
+
+const SA_USER_AGENT =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+
+let connectionHealth: ConnectionHealthRegistry | null = null;
+
+export function attachIpoCalendarHealth(health?: ConnectionHealthRegistry): void {
+  connectionHealth = health ?? null;
+}
+
+export function resetIpoCalendarHealth(): void {
+  connectionHealth = null;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isRecordArray(value: unknown): value is unknown[] {
+  return Array.isArray(value);
+}
+
+function num(value: unknown): number | null {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return value;
+}
+
+function str(value: unknown): string | null {
+  if (typeof value !== "string" || !value.trim()) return null;
+  return value;
+}
+
+/**
+ * Resolve a SvelteKit devalue reference from the flat data array.
+ * Objects and arrays store integer indices into the same flat array;
+ * primitives are returned directly.
+ */
+function resolveRef(flat: unknown[], index: number, depth = 0): unknown {
+  if (depth > 20) return undefined;
+  if (typeof index !== "number" || index < 0 || index >= flat.length) return undefined;
+  const value = flat[index];
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return value.map((item) =>
+      typeof item === "number" ? resolveRef(flat, item, depth + 1) : item,
+    );
+  }
+  const result: Record<string, unknown> = {};
+  for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+    result[key] = typeof val === "number" ? resolveRef(flat, val, depth + 1) : val;
+  }
+  return result;
+}
+
+function isIpoRecordShape(value: unknown): value is Record<string, unknown> {
+  return isObject(value) && "s" in value && "ipoDate" in value;
+}
+
+function countIpoRecords(flat: unknown[]): number {
+  let count = 0;
+  for (const item of flat) {
+    if (isIpoRecordShape(item)) count += 1;
+  }
+  return count;
+}
+
+/**
+ * SvelteKit `__data.json` ships several nodes. Node 0 is session/cookie
+ * boilerplate whose first entry is an object; the IPO rows live in a later
+ * node. Select by record shape, not by the first object-shaped node.
+ */
+export function getFlatData(payload: unknown): unknown[] | null {
+  const root = isObject(payload) ? payload : null;
+  const nodes = root?.nodes;
+  if (!isRecordArray(nodes)) return null;
+
+  let best: unknown[] | null = null;
+  let bestCount = 0;
+  for (const node of nodes) {
+    const nodeData = isObject(node) ? node.data : undefined;
+    if (!isRecordArray(nodeData) || nodeData.length === 0) continue;
+    const count = countIpoRecords(nodeData);
+    if (count > bestCount) {
+      best = nodeData;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+
+function findRecordObjects(flat: unknown[]): Record<string, unknown>[] {
+  const records: Record<string, unknown>[] = [];
+  for (const item of flat) {
+    if (isIpoRecordShape(item)) records.push(item);
+  }
+  return records;
+}
+
+function resolveRecord(flat: unknown[], record: Record<string, unknown>): Record<string, unknown> {
+  const resolved: Record<string, unknown> = {};
+  for (const [key, val] of Object.entries(record)) {
+    resolved[key] = typeof val === "number" ? resolveRef(flat, val) : val;
+  }
+  return resolved;
+}
+
+function parseDate(value: unknown): Date | null {
+  const text = str(value);
+  if (!text) return null;
+  const parsed = new Date(`${text}T00:00:00Z`);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+
+function parsePriceRange(value: unknown): [number, number] | null {
+  const text = str(value);
+  if (!text) return null;
+  const match = text.match(/\$?([\d.]+)\s*-\s*\$?([\d.]+)/);
+  if (!match) return null;
+  const low = parseFloat(match[1]!);
+  const high = parseFloat(match[2]!);
+  if (!Number.isFinite(low) || !Number.isFinite(high)) return null;
+  return [low, high];
+}
+
+function recordFromRecent(flat: unknown[], record: Record<string, unknown>): IPORecord | null {
+  const resolved = resolveRecord(flat, record);
+  const ticker = str(resolved.s);
+  const companyName = str(resolved.n);
+  const date = parseDate(resolved.ipoDate);
+  if (!ticker || !companyName || !date) return null;
+
+  const pricedPrice = num(resolved.ipoPrice);
+  const closePrice = num(resolved.ippc);
+  const change1D = num(resolved.ipr);
+  const hasPerformance = closePrice != null || change1D != null;
+  const status: IPOStatus = hasPerformance ? "trading" : "priced";
+
+  return {
+    ticker,
+    companyName,
+    date,
+    status,
+    exchange: null,
+    offerSize: null,
+    priceRange: null,
+    pricedPrice,
+    shares: null,
+    closePrice,
+    change1D,
+  };
+}
+
+function recordFromCalendar(flat: unknown[], record: Record<string, unknown>): IPORecord | null {
+  const resolved = resolveRecord(flat, record);
+  const ticker = str(resolved.s);
+  const companyName = str(resolved.n);
+  const date = parseDate(resolved.ipoDate);
+  if (!ticker || !companyName || !date) return null;
+
+  const exchange = str(resolved.exchange);
+  const priceRange = parsePriceRange(resolved.ipoPriceRange);
+  const shares = num(resolved.sharesOffered);
+  const dealSize = num(resolved.ds);
+  const offerSize = dealSize ?? (shares != null && priceRange != null ? shares * priceRange[0] : null);
+
+  return {
+    ticker,
+    companyName,
+    date,
+    status: "upcoming",
+    exchange,
+    offerSize,
+    priceRange,
+    pricedPrice: null,
+    shares,
+    closePrice: null,
+    change1D: null,
+  };
+}
+
+function getCalendarSectionIndices(flat: unknown[], root: Record<string, unknown>, field: string): number[] {
+  const index = num(root[field]);
+  if (index == null) return [];
+  const value = flat[index];
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is number => typeof item === "number");
+}
+
+function fetchJson(url: string, headers: Record<string, string>): Promise<unknown> {
+  return httpFetch(url, {
+    headers,
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+  }).then((response) => {
+    if (!response.ok) {
+      throw new Error(`Request failed (${response.status}) for ${url}`);
+    }
+    return response.json();
+  });
+}
+
+function fetchStockAnalysis(url: string, operation: string): Promise<unknown> {
+  const request = () => fetchJson(url, {
+    "User-Agent": SA_USER_AGENT,
+    Accept: "application/json",
+  });
+  return connectionHealth?.hasSource(STOCKANALYSIS_IPO_CONNECTION_ID)
+    ? connectionHealth.track(STOCKANALYSIS_IPO_CONNECTION_ID, operation, request)
+    : request();
+}
+
+async function fetchRecentIpos(): Promise<IPORecord[]> {
+  const payload = await fetchStockAnalysis(SA_RECENT_URL, "fetchRecent");
+  const flat = getFlatData(payload);
+  if (!flat) return [];
+  const records = findRecordObjects(flat);
+  return records
+    .map((record) => recordFromRecent(flat, record))
+    .filter((record): record is IPORecord => record !== null);
+}
+
+function parseCalendarRecords(flat: unknown[]): IPORecord[] {
+  const root = isObject(flat[0]) ? flat[0] : null;
+  if (root) {
+    const sections = ["thisWeekData", "nextWeekData", "laterData"];
+    const results: IPORecord[] = [];
+    for (const field of sections) {
+      const indices = getCalendarSectionIndices(flat, root, field);
+      for (const idx of indices) {
+        const record = isObject(flat[idx]) ? flat[idx] as Record<string, unknown> : null;
+        if (!record) continue;
+        const parsed = recordFromCalendar(flat, record);
+        if (parsed) results.push(parsed);
+      }
+    }
+    if (results.length > 0) return results;
+  }
+
+  return findRecordObjects(flat)
+    .map((record) => recordFromCalendar(flat, record))
+    .filter((record): record is IPORecord => record !== null);
+}
+
+async function fetchUpcomingIpos(): Promise<IPORecord[]> {
+  const payload = await fetchStockAnalysis(SA_CALENDAR_URL, "fetchUpcoming");
+  const flat = getFlatData(payload);
+  if (!flat) return [];
+  return parseCalendarRecords(flat);
+}
+
+function dedupeAndSort(records: IPORecord[]): IPORecord[] {
+  const byTicker = new Map<string, IPORecord>();
+  const statusOrder: Record<IPOStatus, number> = { upcoming: 0, priced: 1, trading: 2 };
+  for (const record of records) {
+    const key = record.ticker.toUpperCase();
+    const existing = byTicker.get(key);
+    if (!existing || statusOrder[record.status] < statusOrder[existing.status]) {
+      byTicker.set(key, record);
+    }
+  }
+  return [...byTicker.values()].sort((a, b) => b.date.getTime() - a.date.getTime());
+}
+
+export interface IpoCalendarFetchResult {
+  records: IPORecord[];
+  /** One entry per endpoint that failed, so a half board is never shown as whole. */
+  errors: string[];
+}
+
+export async function fetchIpoCalendar(): Promise<IpoCalendarFetchResult> {
+  const [recentResult, upcomingResult] = await Promise.allSettled([
+    fetchRecentIpos(),
+    fetchUpcomingIpos(),
+  ]);
+
+  const records: IPORecord[] = [];
+  const errors: string[] = [];
+  if (recentResult.status === "fulfilled") records.push(...recentResult.value);
+  else errors.push(`recent: ${recentResult.reason}`);
+  if (upcomingResult.status === "fulfilled") records.push(...upcomingResult.value);
+  else errors.push(`upcoming: ${upcomingResult.reason}`);
+
+  if (records.length === 0 && errors.length > 0) {
+    throw new Error(`IPO data unavailable (${errors.join("; ")})`);
+  }
+
+  return { records: dedupeAndSort(records), errors };
+}

package/src/plugins/builtin/ipo-calendar/index.tsx

@@ -0,0 +1,65 @@
+import type { PluginModule } from "../plugin-module";
+import {
+  attachIpoCalendarHealth,
+  resetIpoCalendarHealth,
+  STOCKANALYSIS_IPO_CONNECTION_ID,
+} from "./client";
+import { attachIpoCalendarPersistence, resetIpoCalendarPersistence } from "./cache";
+import { IPOCalendarPane } from "./pane";
+import { IPO_CALENDAR_PANE_ID } from "./types";
+
+let disposeConnection: (() => void) | null = null;
+
+export const ipoCalendarModule: PluginModule = {
+  setup(ctx) {
+    attachIpoCalendarHealth(ctx.connectionHealth);
+    attachIpoCalendarPersistence(ctx.persistence);
+    disposeConnection = ctx.connectionHealth.registerSource({
+      id: STOCKANALYSIS_IPO_CONNECTION_ID,
+      name: "Stock Analysis",
+      kind: "api",
+      ownerId: "macro",
+      detail: "stockanalysis.com",
+      priority: 300,
+    });
+  },
+
+  dispose() {
+    disposeConnection?.();
+    disposeConnection = null;
+    resetIpoCalendarHealth();
+    resetIpoCalendarPersistence();
+  },
+
+  panes: [
+    {
+      id: IPO_CALENDAR_PANE_ID,
+      name: "IPO Calendar",
+      icon: "I",
+      component: IPOCalendarPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 110, height: 28 },
+    },
+  ],
+
+  paneTemplates: [
+    {
+      id: "ipo-calendar-pane",
+      paneId: IPO_CALENDAR_PANE_ID,
+      label: "IPO Calendar",
+      description: "Upcoming and recent IPOs from Stock Analysis: pricing, offer size, and first-day return.",
+      keywords: [
+        "ipo",
+        "initial",
+        "public",
+        "offering",
+        "new",
+        "listing",
+        "debut",
+      ],
+      shortcut: { prefix: "IPO" },
+      createInstance: () => ({ placement: "floating" }),
+    },
+  ],
+};

package/src/plugins/builtin/ipo-calendar/model.ts

@@ -0,0 +1,145 @@
+import type { DataTableColumn } from "../../../components";
+import { colors } from "../../../theme/colors";
+import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
+import type { IPORecord, IPOStatus } from "./types";
+
+type IPOColumnId =
+  | "ticker"
+  | "company"
+  | "date"
+  | "status"
+  | "exchange"
+  | "offer"
+  | "price"
+  | "shares"
+  | "return";
+
+export type IPOColumn = DataTableColumn & { id: IPOColumnId };
+
+export interface IPOSortPreference {
+  columnId: IPOColumnId | null;
+  direction: SortDirection;
+}
+
+export const DEFAULT_SORT_PREFERENCE: IPOSortPreference = {
+  columnId: null,
+  direction: "asc",
+};
+
+export function statusColor(status: IPOStatus): string {
+  switch (status) {
+    case "upcoming":
+      return colors.warning;
+    case "priced":
+      return colors.textBright;
+    case "trading":
+      return colors.positive;
+  }
+}
+
+export function formatDate(date: Date): string {
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  return `${date.getUTCFullYear()}-${month}-${day}`;
+}
+
+export function formatOfferSize(value: number | null): string {
+  if (value == null) return "—";
+  const abs = Math.abs(value);
+  if (abs >= 1e9) return `$${(value / 1e9).toFixed(1)}B`;
+  if (abs >= 1e6) return `$${(value / 1e6).toFixed(1)}M`;
+  if (abs >= 1e3) return `$${(value / 1e3).toFixed(0)}K`;
+  return `$${value.toFixed(0)}`;
+}
+
+export function formatShares(value: number | null): string {
+  if (value == null) return "—";
+  const abs = Math.abs(value);
+  if (abs >= 1e9) return `${(value / 1e9).toFixed(1)}B`;
+  if (abs >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
+  if (abs >= 1e3) return `${(value / 1e3).toFixed(1)}K`;
+  return String(value);
+}
+
+export function formatPrice(record: IPORecord): string {
+  if (record.pricedPrice != null) return `$${record.pricedPrice.toFixed(2)}`;
+  if (record.priceRange != null) return `$${record.priceRange[0].toFixed(2)}-$${record.priceRange[1].toFixed(2)}`;
+  return "—";
+}
+
+export function formatReturn(value: number | null): string {
+  if (value == null) return "—";
+  const sign = value > 0 ? "+" : "";
+  return `${sign}${value.toFixed(1)}%`;
+}
+
+export function stockAnalysisUrl(ticker: string): string {
+  return `https://stockanalysis.com/stocks/${ticker.toLowerCase()}/`;
+}
+
+/** "$100.00-$120.00" is the widest price a row can hold; anything narrower clips a real number. */
+const PRICE_WIDTH = 15;
+
+export function buildColumns(width: number): IPOColumn[] {
+  const fixed = 7 + 11 + 9 + 8 + 8 + PRICE_WIDTH + 7 + 8;
+  const companyWidth = Math.max(10, width - fixed - 11);
+  return [
+    { id: "ticker", label: "TICKER", width: 7, align: "left" },
+    { id: "company", label: "COMPANY", width: companyWidth, align: "left" },
+    { id: "date", label: "DATE", width: 11, align: "left" },
+    { id: "status", label: "STATUS", width: 9, align: "left" },
+    { id: "exchange", label: "EXCH", width: 8, align: "left" },
+    { id: "offer", label: "OFFER", width: 8, align: "right" },
+    { id: "price", label: "PRICE", width: PRICE_WIDTH, align: "right" },
+    { id: "shares", label: "SHARES", width: 7, align: "right" },
+    { id: "return", label: "RETURN", width: 8, align: "right" },
+  ];
+}
+
+function getSortValue(columnId: IPOColumnId, row: IPORecord): string | number | null {
+  switch (columnId) {
+    case "ticker":
+      return row.ticker;
+    case "company":
+      return row.companyName;
+    case "date":
+      return row.date.getTime();
+    case "status":
+      return row.status;
+    case "exchange":
+      return row.exchange ?? "";
+    case "offer":
+      return row.offerSize;
+    case "price":
+      return row.pricedPrice ?? row.priceRange?.[0] ?? null;
+    case "shares":
+      return row.shares;
+    case "return":
+      return row.change1D;
+  }
+}
+
+export function sortRows(rows: IPORecord[], sort: IPOSortPreference): IPORecord[] {
+  if (!sort.columnId) return rows;
+  return [...rows].sort((a, b) =>
+    compareSortValues(getSortValue(sort.columnId!, a), getSortValue(sort.columnId!, b), sort.direction),
+  );
+}
+
+export function nextSortPreference(current: IPOSortPreference, columnId: string): IPOSortPreference {
+  const typed = columnId as IPOColumnId;
+  if (current.columnId !== typed) return { columnId: typed, direction: "asc" };
+  if (current.direction === "asc") return { columnId: typed, direction: "desc" };
+  return DEFAULT_SORT_PREFERENCE;
+}
+
+export function matchesSearch(record: IPORecord, query: string): boolean {
+  if (!query) return true;
+  const q = query.toLowerCase();
+  return (
+    record.ticker.toLowerCase().includes(q)
+    || record.companyName.toLowerCase().includes(q)
+    || (record.exchange?.toLowerCase().includes(q) ?? false)
+    || record.status.includes(q)
+  );
+}