gloomberb 0.15.7 → 0.16.0

package/src/utils/html-entities.ts

@@ -5,6 +5,21 @@ const NAMED_ENTITIES: Readonly<Record<string, string>> = {
   lt: "<",
   nbsp: " ",
   quot: "\"",
+  // Typography SEC filings and letters are full of.
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  ndash: "\u2013",
+  mdash: "\u2014",
+  hellip: "\u2026",
+  bull: "\u2022",
+  middot: "\u00B7",
+  sect: "\u00A7",
+  para: "\u00B6",
+  copy: "\u00A9",
+  reg: "\u00AE",
+  trade: "\u2122",
 };
 
 function decodeCodePoint(codePoint: number, fallback: string): string {

package/src/utils/http-proxy-response.ts

@@ -17,6 +17,8 @@ interface HttpProxyRequestInit {
   method?: string;
   headers?: Record<string, string>;
   body?: string;
+  /** A binary body, such as an image upload, which `body` would mangle as text. */
+  bodyBase64?: string;
   redirect?: "follow" | "error" | "manual";
   timeoutMs?: number;
 }
@@ -50,10 +52,40 @@ function headersToRecord(headers: HeadersInit | undefined): Record<string, strin
   return { ...headers };
 }
 
-async function serializeBody(body: BodyInit | null | undefined): Promise<string | undefined> {
-  if (body == null) return undefined;
-  if (typeof body === "string") return body;
-  return new Response(body).text();
+const BASE64_CHUNK_BYTES = 0x8000;
+
+function encodeBase64(bytes: Uint8Array): string {
+  let binary = "";
+  for (let offset = 0; offset < bytes.length; offset += BASE64_CHUNK_BYTES) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + BASE64_CHUNK_BYTES));
+  }
+  return btoa(binary);
+}
+
+function decodeBase64(value: string): Uint8Array<ArrayBuffer> | undefined {
+  try {
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return bytes;
+  } catch {
+    return undefined;
+  }
+}
+
+function isBinaryBody(body: BodyInit): boolean {
+  return (typeof Blob !== "undefined" && body instanceof Blob)
+    || body instanceof ArrayBuffer
+    || ArrayBuffer.isView(body);
+}
+
+async function serializeBody(body: BodyInit | null | undefined): Promise<Pick<HttpProxyRequestInit, "body" | "bodyBase64">> {
+  if (body == null) return {};
+  if (typeof body === "string") return { body };
+  if (isBinaryBody(body)) {
+    return { bodyBase64: encodeBase64(new Uint8Array(await new Response(body).arrayBuffer())) };
+  }
+  return { body: await new Response(body).text() };
 }
 
 /** Client half: flattens a `fetch` call into JSON the proxy can carry. */
@@ -67,7 +99,7 @@ export async function toRequestEnvelope(
     init: {
       method: init?.method,
       headers: headersToRecord(init?.headers),
-      body: await serializeBody(init?.body),
+      ...await serializeBody(init?.body),
       redirect: init?.redirect,
       timeoutMs,
     },
@@ -78,7 +110,7 @@ export async function toRequestEnvelope(
 export interface ProxiedRequestInit {
   method: string;
   headers: Record<string, string>;
-  body?: string;
+  body?: string | Uint8Array<ArrayBuffer>;
   redirect?: "follow" | "error" | "manual";
   /** Positive and finite when present; each proxy applies its own ceiling. */
   timeoutMs?: number;
@@ -98,10 +130,15 @@ export function readRequestInit(raw: unknown): ProxiedRequestInit {
         .filter((entry): entry is [string, string] => typeof entry[1] === "string"),
     )
     : {};
+  const acceptsBody = method !== "GET" && method !== "HEAD";
   return {
     method,
     headers,
-    body: typeof init.body === "string" && method !== "GET" && method !== "HEAD" ? init.body : undefined,
+    body: !acceptsBody
+      ? undefined
+      : typeof init.body === "string"
+        ? init.body
+        : typeof init.bodyBase64 === "string" ? decodeBase64(init.bodyBase64) : undefined,
     redirect: init.redirect === "manual" || init.redirect === "error" || init.redirect === "follow"
       ? init.redirect
       : undefined,

package/src/utils/plugin-proxy-hosts.json

@@ -1,9 +1,12 @@
 {
   "hosts": [
     "api.elections.kalshi.com",
+    "api.fda.gov",
     "api.votehub.com",
+    "clinicaltrials.gov",
     "clob.polymarket.com",
     "data-api.polymarket.com",
+    "efts.sec.gov",
     "gamma-api.polymarket.com",
     "nasdaqtrader.com",
     "production.dataviz.cnn.io"

package/src/utils/price-history.ts

@@ -1,6 +1,6 @@
 import type { PricePoint, TickerFinancials } from "../types/financials";
 import { canonicalExchange, resolveExchangeTimeZone } from "./exchanges";
-import { hasPublishedSessionCalendar, isTimestampStaleForExchangeSession, latestRegularSessionClose, sessionCalendarTimeZone } from "../market-data/market/freshness";
+import { hasPublishedSessionCalendar, isRegularSessionTime, isTimestampStaleForExchangeSession, latestRegularSessionClose, latestRegularSessionOpen, sessionCalendarTimeZone } from "../market-data/market/freshness";
 import { zonedDateTimeParts } from "./zoned-date-time";
 import { regularHistorySessionStaleness } from "../market-data/history-session";
 import type { HistorySession } from "../types/price-history";
@@ -177,6 +177,19 @@ export function isPriceHistoryStaleForCurrentWindow(
   ) {
     return true;
   }
+  // Bars that reach the close of the venue's latest session stay current
+  // once it has closed, so a closed market keeps its last session until the
+  // next one opens. A copy taken earlier in that session is still behind.
+  const regularSession = isRegularSessionTime(exchange, now);
+  if (regularSession !== null) {
+    const open = latestRegularSessionOpen(exchange, now);
+    const close = latestRegularSessionClose(exchange, now)?.close;
+    if (open !== null && close !== undefined && latestTime >= close - allowedLag) {
+      if (!regularSession && close > open && latestTime >= open) return false;
+      // After the next open they answer until its first delayed bar is due.
+      if (regularSession && close < open && latestTime < open && now - open <= allowedLag) return false;
+    }
+  }
   const hasExchangeSession = Boolean(resolveExchangeTimeZone(exchange));
   if (age <= MAX_CURRENT_INTRADAY_HISTORY_LAG_MS) return hasExchangeSession;
   return !hasExchangeSession;
@@ -288,6 +301,27 @@ export function calendarHistoryFetchState(
   return now - lastCheck >= pace ? "recheck" : "behind";
 }
 
+/**
+ * True when the latest bar is from the venue's latest settled session or a
+ * later one, read on the calendar calendarHistoryFetchState uses. A venue
+ * whose sessions are unknown, round-the-clock ones included, proves nothing.
+ */
+export function reachesLatestSettledSession(
+  points: PricePoint[],
+  now = Date.now(),
+  options: Pick<PriceHistoryFreshnessOptions, "exchange" | "intervalMs"> = {},
+): boolean {
+  const normalized = normalizePriceHistory(points);
+  const latest = normalized.findLast(hasFiniteClose);
+  const latestTime = latest ? getPricePointTimestamp(latest) : Number.NaN;
+  if (!Number.isFinite(latestTime)) return false;
+  // Bare symbols resolve to their US listing at the sources.
+  const session = latestRegularSessionClose(canonicalExchange(options.exchange) || "NYSE", now - SESSION_BAR_SETTLE_MS);
+  if (!session) return false;
+  const intervalMs = options.intervalMs ?? inferredHistoryIntervalMs(normalized) ?? DAY_MS;
+  return !isBarBeforeSession(latestTime, session.date, Math.max(intervalMs, DAY_MS), session.timeZone);
+}
+
 function isPlaceholderBar(point: PricePoint): boolean {
   return point.volume === 0 && Number.isFinite(point.close)
     && point.open === point.close && point.high === point.close && point.low === point.close;

package/src/utils/sec.ts

@@ -33,7 +33,25 @@ function isEquityType(value?: string): boolean {
   return normalized.length === 0 || ["STK", "EQUITY", "ADR", "COMMONSTOCK", "DEPOSITARYRECEIPT"].includes(normalized);
 }
 
+const FUND_TYPES = new Set(["ETF", "ETP", "FUND", "MUTUALFUND", "CEF", "CLOSEDEND", "CLOSEDENDFUND"]);
+
+function isFundType(value?: string): boolean {
+  return FUND_TYPES.has(normalize(value).replace(/[\s_-]/g, ""));
+}
+
 export function isUsEquityTicker(ticker: TickerRecord | null | undefined): boolean {
+  return isUsListingOfType(ticker, isEquityType);
+}
+
+/** A US equity, or a US-listed fund, which files fund forms with the SEC. */
+export function isUsEquityOrFundTicker(ticker: TickerRecord | null | undefined): boolean {
+  return isUsListingOfType(ticker, (type) => isEquityType(type) || isFundType(type));
+}
+
+function isUsListingOfType(
+  ticker: TickerRecord | null | undefined,
+  acceptsType: (type?: string) => boolean,
+): boolean {
   if (!ticker) return false;
 
   const primaryContract = ticker.metadata.broker_contracts?.[0];
@@ -45,8 +63,9 @@ export function isUsEquityTicker(ticker: TickerRecord | null | undefined): boole
     ticker.metadata.exchange,
   ];
 
-  return isEquityType(type)
-    && currency === "USD"
+  // A listing saved without a known currency counts by its venue.
+  return acceptsType(type)
+    && (currency === "USD" || !currency)
     && exchangeCandidates.some((exchange) => isUsExchange(exchange));
 }
 

package/src/utils/text-wrap.ts

@@ -1,4 +1,4 @@
-import { displayWidth } from "./format";
+import { displayWidth, truncateToDisplayWidth } from "./format";
 
 export function truncateWithEllipsis(text: string, width: number): string {
   if (width <= 0) return "";
@@ -56,16 +56,21 @@ export function wrapTextLines(
     let current = "";
     for (const rawWord of paragraph.split(" ")) {
       let word = rawWord;
-      while (word.length > width) {
-        const available = current ? width - current.length - 1 : width;
+      while (displayWidth(word) > width) {
+        const available = current ? width - displayWidth(current) - 1 : width;
         if (available <= 0) {
           pushLine(current);
           current = "";
           continue;
         }
-        if (word.length <= available) break;
-        const piece = word.slice(0, available);
-        word = word.slice(available);
+        if (displayWidth(word) <= available) break;
+        const piece = splitLongTextSegmentByDisplayWidth(word, available)[0]!;
+        if (current && displayWidth(piece) > available) {
+          pushLine(current);
+          current = "";
+          continue;
+        }
+        word = word.slice(piece.length);
         pushLine(current ? `${current} ${piece}` : piece);
         current = "";
       }
@@ -75,7 +80,7 @@ export function wrapTextLines(
         continue;
       }
 
-      if (current.length + 1 + word.length <= width) {
+      if (displayWidth(current) + 1 + displayWidth(word) <= width) {
         current = `${current} ${word}`;
       } else {
         pushLine(current);
@@ -92,7 +97,7 @@ export function wrapTextLines(
     lines.length === maxLines &&
     paragraphs.join(" ").length > lines.join(" ").length
   ) {
-    lines[maxLines - 1] = truncateWithEllipsis(
+    lines[maxLines - 1] = truncateToDisplayWidth(
       lines[maxLines - 1] ?? "",
       width,
     );

package/src/utils/zoned-date-time.ts

@@ -77,3 +77,70 @@ export function zonedWallClockToUtcMs(
   const verifiedOffset = zonedOffsetMs(candidate, timeZone);
   return wallMs - verifiedOffset;
 }
+
+const QUARTER_HOUR_MS = 15 * 60_000;
+const offsetBuckets = new Map<string, Map<number, number>>();
+
+/**
+ * An instant's wall-clock reading in a zone, as a timestamp whose UTC fields
+ * read the local date and time. Offsets only change on quarter-hour edges, so
+ * each quarter hour is measured once.
+ */
+export function zonedWallClockMs(utcMs: number, timeZone: string): number {
+  if (!Number.isFinite(utcMs)) return utcMs;
+  let buckets = offsetBuckets.get(timeZone);
+  if (!buckets) {
+    buckets = new Map();
+    offsetBuckets.set(timeZone, buckets);
+  }
+  const bucket = Math.floor(utcMs / QUARTER_HOUR_MS);
+  let offset = buckets.get(bucket);
+  if (offset === undefined) {
+    offset = zonedOffsetMs(bucket * QUARTER_HOUR_MS, timeZone);
+    if (buckets.size >= 100_000) buckets.clear();
+    buckets.set(bucket, offset);
+  }
+  return utcMs + offset;
+}
+
+// Zones whose usual short name reads the same in summer and winter, the way
+// the tape writes "ET". Any other zone is named by its city.
+const TIME_ZONE_LABELS: Readonly<Record<string, string>> = {
+  UTC: "UTC",
+  "Etc/UTC": "UTC",
+  "America/New_York": "ET",
+  "America/Toronto": "ET",
+  "America/Chicago": "CT",
+  "America/Sao_Paulo": "BRT",
+  "America/Argentina/Buenos_Aires": "ART",
+  "Europe/London": "UK",
+  "Europe/Lisbon": "WET",
+  "Europe/Berlin": "CET",
+  "Europe/Paris": "CET",
+  "Europe/Amsterdam": "CET",
+  "Europe/Brussels": "CET",
+  "Europe/Madrid": "CET",
+  "Europe/Rome": "CET",
+  "Europe/Zurich": "CET",
+  "Europe/Vienna": "CET",
+  "Europe/Stockholm": "CET",
+  "Europe/Copenhagen": "CET",
+  "Europe/Oslo": "CET",
+  "Europe/Warsaw": "CET",
+  "Europe/Prague": "CET",
+  "Europe/Helsinki": "EET",
+  "Atlantic/Reykjavik": "GMT",
+  "Africa/Johannesburg": "SAST",
+  "Asia/Kolkata": "IST",
+  "Asia/Hong_Kong": "HKT",
+  "Asia/Singapore": "SGT",
+  "Asia/Tokyo": "JST",
+  "Asia/Seoul": "KST",
+  "Australia/Sydney": "AET",
+  "Pacific/Auckland": "NZT",
+};
+
+/** A short name for a zone that holds all year: "ET" for New York, "JST" for Tokyo, else the city. */
+export function timeZoneLabel(timeZone: string): string {
+  return TIME_ZONE_LABELS[timeZone] ?? timeZone.split("/").at(-1)!.replaceAll("_", " ");
+}