gloomberb 0.18.0 → 0.18.2

package/src/types/trading.ts

@@ -3,6 +3,36 @@ import type { BrokerContractRef } from "./instrument";
 type BrokerOrderAction = "BUY" | "SELL";
 export type BrokerOrderType = "MKT" | "LMT" | "STP" | "STP LMT";
 
+/** Explicit account classification for order confirmation. Missing values are treated as unknown. */
+export type BrokerTradingMode = "simulation" | "live" | "unknown";
+
+/** Synchronous ticket metadata. Adapters may vary this by contract and order type. */
+export interface BrokerTradingCapabilities {
+  enabled: boolean;
+  disabledReason?: string;
+  orderTypes: BrokerOrderType[];
+  tif: string[];
+  extendedHours?: boolean;
+  /** When set, extended hours are available only for these time-in-force values. */
+  extendedHoursTif?: string[];
+  fractionalQuantity?: boolean;
+  /** Explicitly permits sells beyond a known long position. Omission blocks short sales. */
+  shortSelling?: boolean;
+  minQuantity?: number;
+  quantityStep?: number;
+  priceDecimals?: number;
+  /** Broker-reported price increment for this instrument/order. Omit if unknown. */
+  priceStep?: number;
+  modify?: boolean;
+  cancel?: boolean;
+  executionKind?: "fills" | "order-summaries";
+  /**
+   * Multi-leg option orders take up to this many legs (at least 2). Declared
+   * for a combo contract (`secType: "BAG"`); omit when the broker takes none.
+   */
+  maxLegs?: number;
+}
+
 export interface BrokerCashBalance {
   currency: string;
   quantity: number;
@@ -13,6 +43,9 @@ export interface BrokerCashBalance {
 export interface BrokerAccount {
   accountId: string;
   name: string;
+  tradingMode?: BrokerTradingMode;
+  /** Broker-reported account classification, such as Cash or Margin. Omit when unavailable. */
+  accountType?: string;
   currency?: string;
   /** "cloud" is a connection held by the user's Gloom Cloud account. */
   source?: "gateway" | "flex" | "cloud";
@@ -64,10 +97,25 @@ export interface BrokerPortfolioPerformance {
   points: BrokerPortfolioPerformancePoint[];
 }
 
+/**
+ * One leg of a multi-leg option order. The action is what happens to this
+ * contract when the order fills; the ratio is its contracts per spread.
+ */
+export interface BrokerOrderLeg {
+  contract: BrokerContractRef;
+  action: BrokerOrderAction;
+  ratio: number;
+}
+
 export interface BrokerOrderRequest {
   brokerInstanceId?: string;
   accountId?: string;
+  /** A combo contract (`secType: "BAG"`, the underlying's symbol) when the order has legs. */
   contract: BrokerContractRef;
+  /**
+   * BUY pays a net debit and SELL receives a net credit. With legs, the
+   * legs' own actions say which contracts are bought and sold.
+   */
   action: BrokerOrderAction;
   orderType: BrokerOrderType;
   quantity: number;
@@ -75,9 +123,23 @@ export interface BrokerOrderRequest {
   stopPrice?: number;
   tif?: string;
   outsideRth?: boolean;
+  /**
+   * 2 or more option legs filled as one order. `quantity` counts spreads and
+   * `limitPrice` is the positive net price of one spread.
+   */
+  legs?: BrokerOrderLeg[];
 }
 
 export interface BrokerOrderPreview {
+  currency?: string;
+  estimatedCost?: number;
+  fees?: number;
+  buyingPowerBefore?: number;
+  buyingPowerAfter?: number;
+  buyingPowerImpact?: number;
+  warnings?: string[];
+  /** Blocking broker validation errors. A ticket must not submit when these are present. */
+  errors?: string[];
   initMarginBefore?: number;
   initMarginAfter?: number;
   maintMarginBefore?: number;
@@ -91,6 +153,8 @@ export interface BrokerOrderPreview {
 
 export interface BrokerOrder {
   orderId: number;
+  /** Broker-native identity, scoped to profile and account. Numeric orderId remains the mutation handle. */
+  brokerOrderId?: string;
   brokerInstanceId?: string;
   accountId?: string;
   status: string;
@@ -108,12 +172,15 @@ export interface BrokerOrder {
   reviewUrl?: string;
   updatedAt: number;
   contract: BrokerContractRef;
+  /** A multi-leg order's legs, as on its request. */
+  legs?: BrokerOrderLeg[];
 }
 
 export interface BrokerExecution {
   execId: string;
   brokerInstanceId?: string;
   orderId?: number;
+  brokerOrderId?: string;
   accountId?: string;
   side: string;
   shares: number;

package/src/ui/host.tsx

@@ -447,6 +447,8 @@ export interface AsciiTextProps extends BoxProps {
 interface HostTabItem {
   label: string;
   value: string;
+  /** Artwork before the label, such as a logo; decoration only. */
+  leading?: ReactNode;
   disabled?: boolean;
   reorderable?: boolean;
   onClose?: (value: string) => void;
@@ -611,6 +613,8 @@ export interface HostMenuItem {
   checked?: boolean;
   /** Tints the label, e.g. a status in its tone; the words carry the meaning. */
   color?: string;
+  /** Artwork before the label, such as a logo; decoration only. */
+  leading?: ReactNode;
 }
 
 export interface HostMenuProps {

package/src/utils/base-currency.ts

@@ -0,0 +1,108 @@
+import { currenciesNamed } from "./currency-names";
+import { isCurrencyCode } from "./currency-pair";
+import { isIsoCurrencyCode } from "./crypto-pair";
+
+/**
+ * Signs people write for a currency, as they read them: C$ and US$ as
+ * Canadians and Americans write them, S$, NZ$, R$. These settle a sign the
+ * runtime gives another currency too (C$ is also the cordoba's). The runtime
+ * adds CA$, A$, HK$, €, £, ₹ and the rest, so a sign several currencies use
+ * ($, ¥) names all of them.
+ */
+const EXTRA_SIGNS: ReadonlyArray<readonly [sign: string, code: string]> = [
+  ["US$", "USD"], ["U$S", "USD"], ["C$", "CAD"], ["CAN$", "CAD"], ["AU$", "AUD"], ["S$", "SGD"], ["SG$", "SGD"],
+  ["NZ$", "NZD"], ["R$", "BRL"], ["NT$", "TWD"], ["RMB", "CNY"], ["Fr", "CHF"], ["SFr", "CHF"], ["zł", "PLN"],
+  ["kr", "SEK"], ["kr", "NOK"], ["kr", "DKK"], ["kr", "ISK"], ["Kč", "CZK"], ["Ft", "HUF"], ["RM", "MYR"],
+  ["£", "GBP"], ["¥", "JPY"], ["¥", "CNY"],
+  ["$", "USD"], ["$", "CAD"], ["$", "AUD"], ["$", "NZD"], ["$", "HKD"], ["$", "SGD"], ["$", "MXN"],
+];
+
+/** The most traded currencies, first among those a shared sign ($, ¥, kr) names. */
+const SIGN_ORDER = ["USD", "EUR", "JPY", "GBP", "CNY", "CAD", "AUD", "CHF", "HKD", "SGD", "NZD", "MXN", "SEK", "NOK", "DKK"];
+
+let signIndex: ReadonlyMap<string, readonly string[]> | undefined;
+
+function signKey(sign: string): string {
+  return sign.normalize("NFC").replace(/\s+/g, "").toUpperCase();
+}
+
+function signs(): ReadonlyMap<string, readonly string[]> {
+  if (signIndex) return signIndex;
+  const built = new Map<string, string[]>();
+  const curated = new Set(EXTRA_SIGNS.map(([sign]) => signKey(sign)));
+  const add = (sign: string, code: string, extra = false) => {
+    const key = signKey(sign);
+    // A code is its own spelling, not a sign: CHF reads as the code.
+    if (!key || key === code || (!extra && curated.has(key))) return;
+    const codes = built.get(key) ?? [];
+    if (!codes.includes(code)) codes.push(code);
+    built.set(key, codes);
+  };
+  const codes = typeof Intl.supportedValuesOf === "function" ? Intl.supportedValuesOf("currency") : [];
+  for (const code of codes) {
+    if (!isCurrencyCode(code)) continue;
+    for (const currencyDisplay of ["symbol", "narrowSymbol"] as const) {
+      try {
+        const sign = new Intl.NumberFormat("en-US", { style: "currency", currency: code, currencyDisplay })
+          .formatToParts(0).find((part) => part.type === "currency")?.value;
+        if (sign) add(sign, code);
+      } catch {
+        // Intentional ignore: a code the runtime lists but cannot format has no sign to read.
+      }
+    }
+  }
+  for (const [sign, code] of EXTRA_SIGNS) add(sign, code, true);
+  const rank = (code: string) => {
+    const at = SIGN_ORDER.indexOf(code);
+    return at < 0 ? SIGN_ORDER.length : at;
+  };
+  for (const codesForSign of built.values()) codesForSign.sort((left, right) => rank(left) - rank(right));
+  signIndex = built;
+  return built;
+}
+
+/** The currencies a name (`Canadian dollar`, `yen`) or a sign (`CA$`, `C$`, `€`) stands for, most traded first. */
+function currenciesForNameOrSign(typed: string): string[] {
+  const named = currenciesNamed(typed).map(({ code }) => code);
+  if (named.length > 0) return named;
+  return [...signs().get(signKey(typed.trim())) ?? []];
+}
+
+/** What a typed base currency is: its ISO 4217 code, or why it is none and the codes it may have meant. */
+export type BaseCurrencyReading =
+  | { code: string }
+  | { error: string; suggestions: string[] };
+
+/**
+ * A base currency as `config set baseCurrency` takes it: an ISO 4217 code in
+ * any case (`cad` is CAD). A currency's name or sign (`Canadian dollar`,
+ * `CA$`) is refused with the code it stands for, so the setting is always a
+ * code the conversions can price; so is a code that is no currency (XAU, XYZ).
+ */
+export function readBaseCurrency(typed: string): BaseCurrencyReading {
+  const text = typed.trim();
+  const upper = text.toUpperCase();
+  if (/^[A-Z]{3}$/.test(upper) && isCurrencyCode(upper)) return { code: upper };
+  if (/^[A-Z]{3}$/.test(upper) && isIsoCurrencyCode(upper)) {
+    return { error: `${upper} is a metal, drawing-right or test code, not a currency.`, suggestions: [] };
+  }
+  const suggestions = text ? currenciesForNameOrSign(text) : [];
+  const shown = text ? JSON.stringify(text) : "An empty value";
+  if (suggestions.length === 1) return { error: `${shown} is not a currency code. Did you mean ${suggestions[0]}?`, suggestions };
+  if (suggestions.length > 1) {
+    return { error: `${shown} is not a currency code; it can be ${suggestions.slice(0, 6).join(", ")}.`, suggestions };
+  }
+  return { error: `${shown} is not an ISO 4217 currency code.`, suggestions };
+}
+
+/**
+ * A base currency as it was saved, as the setting reads it now: a code in
+ * capitals, and a name or sign an older version stored (`Canadian dollar`,
+ * `CA$`, `cad`) as the one code it stands for. Anything else stays as saved,
+ * for `doctor` and `config get` to flag, rather than turning into USD.
+ */
+export function normalizeStoredBaseCurrency(value: string): string {
+  const reading = readBaseCurrency(value);
+  if ("code" in reading) return reading.code;
+  return reading.suggestions.length === 1 ? reading.suggestions[0]! : value.trim();
+}

package/src/utils/currency-names.ts

@@ -0,0 +1,128 @@
+/**
+ * Currencies by the names people give them (`peso`, `Swiss franc`, `rand`),
+ * for `fx`, which takes ISO codes. Each currency lists its names, the first
+ * one saying whose it is. The last word of every name is also the generic
+ * word for it (`peso` for the Mexican peso), shared by every currency that
+ * uses it, so a word several currencies carry names all of them, most traded
+ * first.
+ */
+const CURRENCY_NAMES: ReadonlyArray<readonly [code: string, ...names: string[]]> = [
+  ["MXN", "Mexican peso"],
+  ["ARS", "Argentine peso"],
+  ["COP", "Colombian peso"],
+  ["CLP", "Chilean peso"],
+  ["PHP", "Philippine peso"],
+  ["UYU", "Uruguayan peso"],
+  ["DOP", "Dominican peso"],
+  ["USD", "US dollar", "United States dollar", "American dollar"],
+  ["CAD", "Canadian dollar"],
+  ["AUD", "Australian dollar"],
+  ["NZD", "New Zealand dollar"],
+  ["HKD", "Hong Kong dollar"],
+  ["SGD", "Singapore dollar"],
+  ["TWD", "Taiwan dollar"],
+  ["EUR", "euro"],
+  ["GBP", "British pound", "pound sterling"],
+  ["EGP", "Egyptian pound"],
+  ["JPY", "Japanese yen", "yen"],
+  ["CNY", "Chinese yuan", "yuan", "renminbi", "rmb"],
+  ["CHF", "Swiss franc"],
+  ["XOF", "West African CFA franc"],
+  ["XAF", "Central African CFA franc"],
+  ["INR", "Indian rupee"],
+  ["PKR", "Pakistani rupee"],
+  ["LKR", "Sri Lankan rupee"],
+  ["NPR", "Nepalese rupee"],
+  ["IDR", "Indonesian rupiah"],
+  ["KRW", "South Korean won", "Korean won", "won"],
+  ["BRL", "Brazilian real", "Brazilian reais", "reais"],
+  ["ZAR", "South African rand"],
+  ["TRY", "Turkish lira"],
+  ["NOK", "Norwegian krone", "Norwegian kroner"],
+  ["DKK", "Danish krone", "Danish kroner"],
+  ["SEK", "Swedish krona", "Swedish kronor"],
+  ["ISK", "Icelandic krona", "Icelandic kronur"],
+  ["CZK", "Czech koruna", "Czech crown"],
+  ["PLN", "Polish zloty", "Polish zlotych"],
+  ["HUF", "Hungarian forint"],
+  ["RON", "Romanian leu", "Romanian lei"],
+  ["BGN", "Bulgarian lev", "Bulgarian leva"],
+  ["RUB", "Russian ruble", "Russian rouble"],
+  ["UAH", "Ukrainian hryvnia"],
+  ["ILS", "Israeli shekel", "new shekel"],
+  ["THB", "Thai baht"],
+  ["VND", "Vietnamese dong"],
+  ["MYR", "Malaysian ringgit"],
+  ["BDT", "Bangladeshi taka"],
+  ["NGN", "Nigerian naira"],
+  ["GHS", "Ghanaian cedi"],
+  ["KES", "Kenyan shilling"],
+  ["UGX", "Ugandan shilling"],
+  ["TZS", "Tanzanian shilling"],
+  ["AED", "UAE dirham", "Emirati dirham"],
+  ["MAD", "Moroccan dirham"],
+  ["SAR", "Saudi riyal", "Saudi rial"],
+  ["QAR", "Qatari riyal", "Qatari rial"],
+  ["OMR", "Omani rial", "Omani riyal"],
+  ["IRR", "Iranian rial", "Iranian riyal"],
+  ["KWD", "Kuwaiti dinar"],
+  ["BHD", "Bahraini dinar"],
+  ["JOD", "Jordanian dinar"],
+  ["IQD", "Iraqi dinar"],
+  ["RSD", "Serbian dinar"],
+  ["DZD", "Algerian dinar"],
+  ["TND", "Tunisian dinar"],
+  ["LYD", "Libyan dinar"],
+  ["KZT", "Kazakhstani tenge"],
+  ["PEN", "Peruvian sol"],
+];
+
+/** One currency a name stands for. */
+export interface NamedCurrency {
+  code: string;
+  /** What tells it from the others that share the word: "Mexican" for peso. Empty when the name is the whole name. */
+  qualifier: string;
+}
+
+/** The text of a name as it is looked up: lower case, without accents, punctuation or "the". */
+function normalize(text: string): string {
+  return text.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase()
+    .replace(/[^a-z0-9]+/g, " ").trim()
+    .replace(/^the /, "");
+}
+
+let index: ReadonlyMap<string, readonly NamedCurrency[]> | undefined;
+
+function nameIndex(): ReadonlyMap<string, readonly NamedCurrency[]> {
+  if (index) return index;
+  const built = new Map<string, NamedCurrency[]>();
+  const add = (key: string, entry: NamedCurrency) => {
+    const found = built.get(key);
+    if (!found) built.set(key, [entry]);
+    else if (!found.some((other) => other.code === entry.code)) found.push(entry);
+  };
+  for (const [code, ...names] of CURRENCY_NAMES) {
+    for (const name of names) {
+      const words = normalize(name).split(" ");
+      const generic = words.at(-1)!;
+      // "Mexican" for "Mexican peso"; the whole name when it is one word, which says no more than the word.
+      const qualifier = words.length > 1 ? name.slice(0, name.length - generic.length).trim() : "";
+      add(normalize(name), { code, qualifier: "" });
+      add(generic, { code, qualifier });
+    }
+  }
+  index = built;
+  return built;
+}
+
+/**
+ * The currencies a name stands for: `Swiss franc` is CHF alone, `peso` is
+ * MXN, ARS, COP, CLP, PHP and more. A plural is its singular (`pesos`). Empty
+ * for text that names no currency.
+ */
+export function currenciesNamed(text: string): readonly NamedCurrency[] {
+  const key = normalize(text);
+  const names = nameIndex();
+  if (!key) return [];
+  return names.get(key) ?? (key.endsWith("s") ? names.get(key.slice(0, -1)) : undefined) ?? [];
+}

package/src/utils/currency-pair.ts

@@ -26,7 +26,8 @@ const NON_CURRENCY_CODES = new Set([
   "XAU", "XAG", "XPT", "XPD", "XDR", "XSU", "XUA", "XBA", "XBB", "XBC", "XBD", "XTS", "XXX", "XEU", "XFO", "XFU", "XRE",
 ]);
 
-function isCurrencyCode(code: string): boolean {
+/** Whether `code` is a currency code a pair can be written with: ISO 4217, less metals, drawing rights and testing codes. */
+export function isCurrencyCode(code: string): boolean {
   return !NON_CURRENCY_CODES.has(code) && isIsoCurrencyCode(code);
 }
 

package/src/utils/currency-units.ts

@@ -15,10 +15,13 @@ const SUB_UNIT_NAMES: Record<string, string> = {
 
 /**
  * A currency code as a reader should see it; a sub-unit says which one,
- * "GBp (pence)", and with `ofMajor` what it divides: "ILA (agorot, 1/100 ILS)".
+ * "GBp (pence)", "US¢ (US cents)", and with `ofMajor` what it divides:
+ * "ILA (agorot, 1/100 ILS)".
  */
 export function currencyUnitLabel(code?: string | null, { ofMajor = false }: { ofMajor?: boolean } = {}): string {
   const raw = (code ?? "").trim();
+  // US cents have no standard code; the one quotes carry (USX) is shown as US¢.
+  if (raw.toUpperCase() === US_CENTS) return ofMajor ? "US¢ (US cents, 1/100 USD)" : "US¢ (US cents)";
   const unit = SUB_UNIT_NAMES[raw];
   const major = SUB_UNIT_CURRENCIES[raw];
   if (!unit) return raw;
@@ -50,6 +53,34 @@ const SUB_UNIT_EXCHANGE_RULES = [
  */
 export const US_CENTS = "USX";
 
+/**
+ * Minor units with a sign of their own, by upper-cased code; GBp is read in
+ * its own case, as GBP is pounds. Agorot (ILA) have none in common use and
+ * keep their code.
+ */
+const MINOR_UNIT_SIGNS: Readonly<Record<string, string>> = { USX: "¢", GBX: "p", ZAC: "c" };
+
+/**
+ * The sign a price in a minor unit is written with, after the amount, where
+ * a major currency's symbol goes before it: US cents 314.95¢ (grains and
+ * softs), pence 412.50p, South African cents 1,250.00c. Null for a major
+ * currency, or a minor unit without one.
+ */
+export function minorUnitSign(code: string | null | undefined): string | null {
+  const raw = (code ?? "").trim();
+  if (raw === "GBp") return "p";
+  return MINOR_UNIT_SIGNS[raw.toUpperCase()] ?? null;
+}
+
+/**
+ * A quote currency's code as a column of codes shows it: US cents, a code no
+ * standard has, as US¢; every other code as it is (USD, GBp).
+ */
+export function currencyCodeLabel(code: string | null | undefined): string {
+  const raw = (code ?? "").trim();
+  return raw.toUpperCase() === US_CENTS ? "US¢" : raw;
+}
+
 /**
  * A currency's rate to USD where it is fixed rather than quoted: the dollar
  * itself, and US cents. Undefined for any other, whose rate the market sets.
@@ -64,6 +95,15 @@ export interface CurrencyUnitInfo {
   divisor: number;
 }
 
+/**
+ * The currency money held in a code is counted in, and how many of the code
+ * make one of it: resolveCurrencyUnit's, and US cents as a hundredth of a
+ * dollar, which a lot's cost in USX is.
+ */
+export function heldCurrencyUnit(currency?: string | null): CurrencyUnitInfo {
+  return currency?.trim().toUpperCase() === US_CENTS ? { currency: "USD", divisor: 100 } : resolveCurrencyUnit(currency);
+}
+
 interface ExchangeSubUnitOptions {
   allowDefaultCurrency?: boolean;
   allowMissingCurrency?: boolean;

package/src/utils/dom-screenshot.ts

@@ -469,11 +469,16 @@ function drawCanvasElement(
   }
 }
 
+/** Inputs whose value is not text on screen. A button's value is its label, so it is painted. */
+const NON_TEXT_INPUTS = new Set(["checkbox", "radio", "range", "color", "file", "hidden", "image"]);
+
 function drawInputElement(
   context: CanvasRenderingContext2D,
   element: HTMLInputElement | HTMLTextAreaElement,
   origin: CaptureOrigin,
 ): void {
+  // A checkbox's value ("on" unless set) is not on screen; its box is painted from its CSS.
+  if (element instanceof HTMLInputElement && NON_TEXT_INPUTS.has(element.type)) return;
   // Paint what the screen shows: a password field is dots, never its value.
   const typed = element instanceof HTMLInputElement && element.type === "password"
     ? "\u2022".repeat(element.value.length)
@@ -593,6 +598,12 @@ function drawElement(pass: PaintPass, element: Element): void {
 
   const style = getComputedStyle(element);
   if (!isVisible(style)) return;
+  // A `display: contents` element (a ColumnGrid row) has no box of its own: its children are laid
+  // out in its parent's, so its empty rect must not leave them out.
+  if (style.display === "contents") {
+    drawChildren(pass, element);
+    return;
+  }
 
   const rect = localRect(element.getBoundingClientRect(), origin);
   if (rect.width <= 0 || rect.height <= 0) return;
@@ -624,19 +635,21 @@ function drawElement(pass: PaintPass, element: Element): void {
   }
 
   // An SVG's shapes and text are in its raster; they are not boxes to walk.
-  if (!(element instanceof SVGElement)) {
-    for (const child of paintOrder(element)) {
-      if (child.nodeType === Node.TEXT_NODE) {
-        drawTextNode(context, child as Text, origin);
-      } else {
-        drawElement(pass, child as Element);
-      }
-    }
-  }
+  if (!(element instanceof SVGElement)) drawChildren(pass, element);
 
   context.restore();
 }
 
+function drawChildren(pass: PaintPass, element: Element): void {
+  for (const child of paintOrder(element)) {
+    if (child.nodeType === Node.TEXT_NODE) {
+      drawTextNode(pass.context, child as Text, pass.origin);
+    } else {
+      drawElement(pass, child as Element);
+    }
+  }
+}
+
 /** Where a child falls in its parent's paint: below the flow, in it, or above it at its z-index. */
 function paintLayer(child: Element): number {
   const style = getComputedStyle(child);