gloomberb 0.4.1 → 0.5.1

package/src/utils/format.ts

@@ -116,17 +116,95 @@ export function formatWithDivisor(value: number | undefined, divisor: number): s
   return scaled.toFixed(decimals);
 }
 
-/** Pad/truncate a string to a fixed width */
+const COMBINING_MARK_RE = /\p{Mark}/u;
+const EMOJI_PRESENTATION_RE = /\p{Emoji_Presentation}/u;
+const EXTENDED_PICTOGRAPHIC_RE = /\p{Extended_Pictographic}/u;
+const REGIONAL_INDICATOR_RE = /\p{Regional_Indicator}/u;
+
+function segmentGraphemes(value: string): string[] {
+  const Segmenter = (Intl as any).Segmenter;
+  if (typeof Segmenter === "function") {
+    return Array.from(
+      new Segmenter(undefined, { granularity: "grapheme" }).segment(value),
+      (entry: any) => entry.segment as string,
+    );
+  }
+  return Array.from(value);
+}
+
+function isFullwidthCodePoint(codePoint: number): boolean {
+  return codePoint >= 0x1100 && (
+    codePoint <= 0x115f ||
+    codePoint === 0x2329 ||
+    codePoint === 0x232a ||
+    (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+    (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+    (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+    (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+    (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+    (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+    (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+    (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+    (codePoint >= 0x20000 && codePoint <= 0x3fffd)
+  );
+}
+
+function graphemeWidth(segment: string): number {
+  if (
+    REGIONAL_INDICATOR_RE.test(segment) ||
+    EMOJI_PRESENTATION_RE.test(segment) ||
+    EXTENDED_PICTOGRAPHIC_RE.test(segment)
+  ) {
+    return 2;
+  }
+
+  let width = 0;
+  for (const char of Array.from(segment)) {
+    const codePoint = char.codePointAt(0) ?? 0;
+    if (
+      codePoint === 0 ||
+      codePoint < 32 ||
+      (codePoint >= 0x7f && codePoint < 0xa0) ||
+      codePoint === 0x200d ||
+      (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+      COMBINING_MARK_RE.test(char)
+    ) {
+      continue;
+    }
+    width += isFullwidthCodePoint(codePoint) ? 2 : 1;
+  }
+  return width;
+}
+
+export function displayWidth(value: string): number {
+  return segmentGraphemes(value).reduce((total, segment) => total + graphemeWidth(segment), 0);
+}
+
+function truncateToWidth(value: string, width: number): string {
+  if (width <= 0) return "";
+  let output = "";
+  let used = 0;
+  for (const segment of segmentGraphemes(value)) {
+    const nextWidth = graphemeWidth(segment);
+    if (used + nextWidth > width) break;
+    output += segment;
+    used += nextWidth;
+  }
+  return output;
+}
+
+/** Pad/truncate a string to a fixed display width */
 export function padTo(str: string, width: number, align: "left" | "right" | "center" = "left"): string {
-  if (str.length > width) return str.slice(0, width);
-  if (align === "right") return str.padStart(width);
+  const clipped = displayWidth(str) > width ? truncateToWidth(str, width) : str;
+  const clippedWidth = displayWidth(clipped);
+  const padding = Math.max(0, width - clippedWidth);
+  if (align === "right") return " ".repeat(padding) + clipped;
   if (align === "center") {
-    const totalPadding = width - str.length;
-    const leftPadding = Math.floor(totalPadding / 2);
-    const rightPadding = totalPadding - leftPadding;
-    return " ".repeat(leftPadding) + str + " ".repeat(rightPadding);
+    const leftPadding = Math.floor(padding / 2);
+    const rightPadding = padding - leftPadding;
+    return " ".repeat(leftPadding) + clipped + " ".repeat(rightPadding);
   }
-  return str.padEnd(width);
+  return clipped + " ".repeat(padding);
 }
 
 /** Convert a value from one currency to base currency using cached exchange rates */

package/src/utils/inline-content-tokenizer.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import { tokenizeInlineContent } from "./inline-content-tokenizer";
+
+describe("tokenizeInlineContent", () => {
+  test("returns mixed text, link, and ticker tokens in one pass", () => {
+    expect(tokenizeInlineContent("Read https://example.com then watch $NVDA")).toEqual([
+      { kind: "text", value: "Read " },
+      { kind: "link", value: "https://example.com", url: "https://example.com" },
+      { kind: "text", value: " then watch " },
+      { kind: "ticker", value: "$NVDA", symbol: "NVDA" },
+    ]);
+  });
+
+  test("does not split ticker-like text out of links", () => {
+    expect(tokenizeInlineContent("Read https://example.com/$TSLA before $NVDA")).toEqual([
+      { kind: "text", value: "Read " },
+      { kind: "link", value: "https://example.com/$TSLA", url: "https://example.com/$TSLA" },
+      { kind: "text", value: " before " },
+      { kind: "ticker", value: "$NVDA", symbol: "NVDA" },
+    ]);
+  });
+});

package/src/utils/inline-content-tokenizer.ts

@@ -0,0 +1,76 @@
+import { tokenizeInlineLinks } from "./link-tokenizer";
+
+export interface InlineContentTextToken {
+  kind: "text";
+  value: string;
+}
+
+export interface InlineContentLinkToken {
+  kind: "link";
+  value: string;
+  url: string;
+}
+
+export interface InlineContentTickerToken {
+  kind: "ticker";
+  value: string;
+  symbol: string;
+}
+
+export type InlineContentToken =
+  | InlineContentTextToken
+  | InlineContentLinkToken
+  | InlineContentTickerToken;
+
+const TICKER_TOKEN_RE = /\$[A-Z][A-Z0-9.-]{0,9}/g;
+const SYMBOL_CHAR_RE = /[A-Za-z0-9.-]/;
+
+function trimTrailingTickerPunctuation(value: string): string {
+  let trimmed = value;
+  while (trimmed.length > 2 && /[.-]$/.test(trimmed)) {
+    trimmed = trimmed.slice(0, -1);
+  }
+  return trimmed;
+}
+
+function isValidTickerBoundary(text: string, start: number, end: number): boolean {
+  const prev = start > 0 ? text[start - 1] : "";
+  const next = end < text.length ? text[end] : "";
+  return !SYMBOL_CHAR_RE.test(prev) && !SYMBOL_CHAR_RE.test(next);
+}
+
+export function tokenizeInlineContent(text: string): InlineContentToken[] {
+  const tokens: InlineContentToken[] = [];
+
+  for (const segment of tokenizeInlineLinks(text)) {
+    if (segment.kind === "link") {
+      tokens.push(segment);
+      continue;
+    }
+
+    let cursor = 0;
+    let match: RegExpExecArray | null;
+
+    TICKER_TOKEN_RE.lastIndex = 0;
+    while ((match = TICKER_TOKEN_RE.exec(segment.value)) !== null) {
+      const rawValue = match[0];
+      const start = match.index;
+      const rawEnd = start + rawValue.length;
+      const value = trimTrailingTickerPunctuation(rawValue);
+      const end = start + value.length;
+      if (!isValidTickerBoundary(segment.value, start, rawEnd)) continue;
+
+      if (start > cursor) {
+        tokens.push({ kind: "text", value: segment.value.slice(cursor, start) });
+      }
+      tokens.push({ kind: "ticker", value, symbol: value.slice(1) });
+      cursor = end;
+    }
+
+    if (cursor < segment.value.length) {
+      tokens.push({ kind: "text", value: segment.value.slice(cursor) });
+    }
+  }
+
+  return tokens;
+}

package/src/utils/link-tokenizer.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+import { tokenizeInlineLinks } from "./link-tokenizer";
+
+describe("tokenizeInlineLinks", () => {
+  test("extracts http links and preserves surrounding text", () => {
+    expect(tokenizeInlineLinks("Read https://example.com/story now")).toEqual([
+      { kind: "text", value: "Read " },
+      { kind: "link", value: "https://example.com/story", url: "https://example.com/story" },
+      { kind: "text", value: " now" },
+    ]);
+  });
+
+  test("drops trailing punctuation from the link token", () => {
+    expect(tokenizeInlineLinks("See https://example.com/story.)")).toEqual([
+      { kind: "text", value: "See " },
+      { kind: "link", value: "https://example.com/story", url: "https://example.com/story" },
+      { kind: "text", value: ".)" },
+    ]);
+  });
+
+  test("normalizes www links for opening", () => {
+    expect(tokenizeInlineLinks("Visit www.example.com/test")).toEqual([
+      { kind: "text", value: "Visit " },
+      { kind: "link", value: "www.example.com/test", url: "https://www.example.com/test" },
+    ]);
+  });
+});

package/src/utils/link-tokenizer.ts

@@ -0,0 +1,93 @@
+export interface InlineLinkTextToken {
+  kind: "text";
+  value: string;
+}
+
+export interface InlineLinkUrlToken {
+  kind: "link";
+  value: string;
+  url: string;
+}
+
+export type InlineLinkToken = InlineLinkTextToken | InlineLinkUrlToken;
+
+const LINK_TOKEN_RE = /\b(?:https?:\/\/|www\.)[^\s<>"']+/gi;
+const ALWAYS_TRIM_RE = /[.,!?;:]/;
+const BRACKET_PAIRS: Record<string, string> = {
+  ")": "(",
+  "]": "[",
+  "}": "{",
+};
+
+function countChar(value: string, char: string): number {
+  let total = 0;
+  for (const current of value) {
+    if (current === char) total += 1;
+  }
+  return total;
+}
+
+function trimTrailingLinkPunctuation(rawValue: string): { value: string; trailing: string } {
+  let value = rawValue;
+
+  while (value.length > 0) {
+    const lastChar = value[value.length - 1]!;
+    if (ALWAYS_TRIM_RE.test(lastChar)) {
+      value = value.slice(0, -1);
+      continue;
+    }
+
+    const openingChar = BRACKET_PAIRS[lastChar];
+    if (!openingChar) break;
+
+    if (countChar(value, lastChar) > countChar(value, openingChar)) {
+      value = value.slice(0, -1);
+      continue;
+    }
+
+    break;
+  }
+
+  return { value, trailing: rawValue.slice(value.length) };
+}
+
+function normalizeLinkUrl(value: string): string {
+  return /^https?:\/\//i.test(value) ? value : `https://${value}`;
+}
+
+export function tokenizeInlineLinks(text: string): InlineLinkToken[] {
+  const tokens: InlineLinkToken[] = [];
+  let cursor = 0;
+  let match: RegExpExecArray | null;
+
+  LINK_TOKEN_RE.lastIndex = 0;
+  while ((match = LINK_TOKEN_RE.exec(text)) !== null) {
+    const rawValue = match[0];
+    const start = match.index;
+    const end = start + rawValue.length;
+
+    if (start > cursor) {
+      tokens.push({ kind: "text", value: text.slice(cursor, start) });
+    }
+
+    const trimmed = trimTrailingLinkPunctuation(rawValue);
+    if (trimmed.value) {
+      tokens.push({
+        kind: "link",
+        value: trimmed.value,
+        url: normalizeLinkUrl(trimmed.value),
+      });
+    }
+    if (trimmed.trailing) {
+      tokens.push({ kind: "text", value: trimmed.trailing });
+    }
+
+    cursor = end;
+  }
+
+  if (cursor < text.length) {
+    tokens.push({ kind: "text", value: text.slice(cursor) });
+  }
+
+  return tokens;
+}

package/src/utils/market-format.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "bun:test";
+import {
+  formatMarketCost,
+  formatMarketCostWithCurrency,
+  formatCompactMarketPriceWithCurrency,
+  formatMarketPrice,
+  formatMarketPriceWithCurrency,
+  formatMarketQuantity,
+  formatSignedMarketPrice,
+  resolveAssetDisplayKind,
+} from "./market-format";
+
+describe("resolveAssetDisplayKind", () => {
+  test("prefers explicit cash balances", () => {
+    expect(resolveAssetDisplayKind({ isCashBalance: true, assetCategory: "STK" })).toBe("cash");
+  });
+
+  test("maps common broker security types", () => {
+    expect(resolveAssetDisplayKind({ assetCategory: "CRYPTO" })).toBe("crypto");
+    expect(resolveAssetDisplayKind({ assetCategory: "STK" })).toBe("equity");
+    expect(resolveAssetDisplayKind({ contractSecType: "OPT" })).toBe("contract");
+    expect(resolveAssetDisplayKind({ assetCategory: "FOREX" })).toBe("cash");
+    expect(resolveAssetDisplayKind({ assetCategory: "CURRENCY" })).toBe("cash");
+    expect(resolveAssetDisplayKind({ assetCategory: "CCY" })).toBe("cash");
+  });
+
+  test("falls back to contract formatting when only a multiplier is present", () => {
+    expect(resolveAssetDisplayKind({ multiplier: 100 })).toBe("contract");
+  });
+});
+
+describe("formatMarketQuantity", () => {
+  test("preserves additional FX precision while trimming trailing zeroes", () => {
+    expect(formatMarketQuantity(-351957.025, { isCashBalance: true })).toBe("-351,957.025");
+    expect(formatMarketQuantity(-303029.144938754, { isCashBalance: true })).toBe("-303,029.144939");
+  });
+
+  test("shows whole equities without decimals and fractional equities with up to four decimals", () => {
+    expect(formatMarketQuantity(10, { assetCategory: "STK" })).toBe("10");
+    expect(formatMarketQuantity(10.125, { assetCategory: "STK" })).toBe("10.125");
+    expect(formatMarketQuantity(10.123456, { assetCategory: "STK" })).toBe("10.1235");
+  });
+
+  test("uses higher precision for crypto quantities", () => {
+    expect(formatMarketQuantity(0.123456789, { assetCategory: "CRYPTO" })).toBe("0.12345679");
+  });
+});
+
+describe("formatMarketPrice", () => {
+  test("uses semantic precision for equities, cash, and crypto", () => {
+    expect(formatMarketPrice(190.2, { assetCategory: "STK" })).toBe("190.2");
+    expect(formatMarketPrice(259.7499, { assetCategory: "STK" })).toBe("259.75");
+    expect(formatMarketPrice(1.084567, { isCashBalance: true })).toBe("1.084567");
+    expect(formatMarketPrice(1.17364, { assetCategory: "CURRENCY" })).toBe("1.17364");
+    expect(formatMarketPrice(0.000123456789, { assetCategory: "CRYPTO" })).toBe("0.00012346");
+  });
+
+  test("can adapt chart precision to the visible price range", () => {
+    expect(formatMarketPrice(1.167815, { assetCategory: "CURRENCY", priceRange: 0.12 })).toBe("1.17");
+    expect(formatMarketPrice(1.167815, { assetCategory: "CURRENCY", priceRange: 0.0024 })).toBe("1.1678");
+    expect(formatMarketPrice(259.7499, {
+      assetCategory: "STK",
+      minimumFractionDigits: 2,
+      precisionOffset: 1,
+      priceRange: 80,
+    })).toBe("259.75");
+  });
+
+  test("can lock price displays to a specific number of decimals", () => {
+    expect(formatMarketPrice(18, { assetCategory: "STK", fixedFractionDigits: 1 })).toBe("18.0");
+    expect(formatMarketPriceWithCurrency(18, "USD", { assetCategory: "STK", fixedFractionDigits: 2 })).toBe("$18.00");
+  });
+
+  test("fits within the supplied width before falling back to truncation elsewhere", () => {
+    expect(formatMarketPrice(1.084567, { isCashBalance: true, maxWidth: 6 })).toBe("1.0846");
+    expect(formatMarketQuantity(123456.789, { assetCategory: "CRYPTO", maxWidth: 7 })).toBe("123,457");
+  });
+
+  test("formats signed price changes without double signs", () => {
+    expect(formatSignedMarketPrice(0.123456, { isCashBalance: true })).toBe("+0.123456");
+    expect(formatSignedMarketPrice(-0.123456, { isCashBalance: true })).toBe("-0.123456");
+  });
+});
+
+describe("formatMarketCost", () => {
+  test("keeps equity cost displays conservative while preserving FX and crypto precision", () => {
+    expect(formatMarketCost(119.3687, { assetCategory: "STK" })).toBe("119.37");
+    expect(formatMarketCost(1.084567, { isCashBalance: true })).toBe("1.084567");
+    expect(formatMarketCost(113905.720075, { assetCategory: "CRYPTO" })).toBe("113,905.720075");
+  });
+});
+
+describe("formatMarketPriceWithCurrency", () => {
+  test("renders price-like values with a symbol and variable decimals", () => {
+    expect(formatMarketPriceWithCurrency(190.25, "USD", { assetCategory: "STK" })).toBe("$190.25");
+    expect(formatMarketPriceWithCurrency(1.084567, "EUR", { isCashBalance: true })).toBe("€1.084567");
+    expect(formatMarketPriceWithCurrency(1.17364, "USD", { assetCategory: "CURRENCY" })).toBe("$1.17364");
+  });
+
+  test("preserves chart-style compact notation for large values", () => {
+    expect(formatCompactMarketPriceWithCurrency(21_970, "JPY")).toBe("¥22.0K");
+    expect(formatCompactMarketPriceWithCurrency(12_340, "HKD")).toBe("HK$12.3K");
+  });
+
+  test("formats position cost values with tighter equity precision", () => {
+    expect(formatMarketCostWithCurrency(119.3687, "HKD", { assetCategory: "STK" })).toBe("HK$119.37");
+    expect(formatMarketCostWithCurrency(50.9507, "USD", { assetCategory: "OPT", multiplier: 100 })).toBe("$50.9507");
+  });
+});