gloomberb 0.18.3 → 0.18.5

package/src/team/collections.ts

@@ -1,7 +1,9 @@
 import type { TeamCollection, TeamCollectionItem } from "../api-client";
 import { getManualPortfolioPositionPrefill } from "../portfolio/manual-lots";
 import type { AppConfig } from "../types/config";
-import type { Portfolio, TickerRecord, Watchlist } from "../types/ticker";
+import type { Portfolio, TickerPosition, TickerRecord, Watchlist } from "../types/ticker";
+import { heldCurrencyUnit, normalizeHeldCurrencyCode } from "../utils/currency-units";
+import { debugLog } from "../utils/debug-log";
 
 const TEAM_COLLECTION_PREFIX = "team:";
 
@@ -61,12 +63,112 @@ export function reconcileConfigCollections(
   return { ...config, watchlists, portfolios };
 }
 
+/**
+ * What a portfolio item carries of the holding beside its quantity, as sent:
+ * its purchase date, and its currency with the rate its cost was bought at
+ * (null when it has none), which go together. A field left out is kept as the
+ * server has it, so a sync never clears a date or rate it did not know; a null
+ * date clears the server's.
+ */
+interface TeamItemTerms {
+  dateAcquired?: string | null;
+  currency?: string;
+  costFxRate?: number | null;
+  costFxCurrency?: string | null;
+}
+
+interface LotTerms {
+  dateAcquired?: string;
+  /** The holding's currency, the one `costFx` is a rate of. */
+  currency?: string;
+  /** Null: no rate, the cost converts at today's. Undefined: lots whose rates do not become one. */
+  costFx?: { rate: number; currency: string } | null;
+}
+
 interface LocalMember {
   ticker: TickerRecord;
   /** The ticker's shares in the collection: its one lot, or the total of several. Null with no position. */
   quantity: number | null;
   /** Several lots that cannot be totalled (mixed currencies, a long and a short lot): there is no quantity to compare or send. */
   lotsNotTotalled?: boolean;
+  /**
+   * Several lots whose cost FX rates cannot become one position's: a server
+   * count does not collapse them (applyMembership), so their total is not sent
+   * over the server's either, only for a ticker the server does not hold yet.
+   */
+  lotsKept?: boolean;
+  /** The manual lots it holds; only a single one sends its date or rate on its own. */
+  lotCount?: number;
+  /** The purchase date and rate of the lot, or of several as one position keeps them. */
+  terms?: LotTerms;
+}
+
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
+const CURRENCY_CODE = /^[A-Za-z]{3}$/;
+
+/** Two currencies whose amounts are the same unit: a rate of one is a rate of the other (GBp and GBX are both pence). */
+function sameHeldUnit(left: string | undefined, right: string | undefined): boolean {
+  if (!left?.trim() || !right?.trim()) return false;
+  const a = heldCurrencyUnit(normalizeHeldCurrencyCode(left));
+  const b = heldCurrencyUnit(normalizeHeldCurrencyCode(right));
+  return a.currency === b.currency && a.divisor === b.divisor;
+}
+
+function positionCostFx(position: Pick<TickerPosition, "costFxRate" | "costFxCurrency">): { rate: number; currency: string } | null {
+  const rate = position.costFxRate;
+  return typeof rate === "number" && Number.isFinite(rate) && rate > 0 && position.costFxCurrency?.trim()
+    ? { rate, currency: position.costFxCurrency.trim().toUpperCase() }
+    : null;
+}
+
+/**
+ * The date, currency and rate a server item holds, each only when it holds a
+ * usable one. An item with a currency carries the holding's terms as a
+ * teammate's app set them, a missing date or rate included: the first terms
+ * an item gets carry the currency (changedTerms). One without (written before
+ * terms were synced, or by an older app) carries none, and a lot keeps its own.
+ */
+function itemTerms(item: TeamCollectionItem): LotTerms {
+  const currency = typeof item.currency === "string" && CURRENCY_CODE.test(item.currency.trim()) ? normalizeHeldCurrencyCode(item.currency) : undefined;
+  return {
+    ...(typeof item.dateAcquired === "string" && ISO_DAY.test(item.dateAcquired) ? { dateAcquired: item.dateAcquired } : {}),
+    ...(currency ? { currency, costFx: positionCostFx({ costFxRate: item.costFxRate ?? undefined, costFxCurrency: item.costFxCurrency ?? undefined }) } : {}),
+  };
+}
+
+/** A lot's purchase date as the server stores it, null with none; undefined for one it cannot store, which is never sent. */
+function lotDate(terms: LotTerms | undefined): string | null | undefined {
+  if (!terms?.dateAcquired) return null;
+  return ISO_DAY.test(terms.dateAcquired) ? terms.dateAcquired : undefined;
+}
+
+/**
+ * What a push sends of a lot's terms over the server's item (none for a
+ * ticker it does not hold yet), of the parts asked. A date or rate goes as it
+ * is. A missing one goes as null only where this client knows the holding has
+ * none: from a single lot, which takes the item's date and its rate in the
+ * lot's unit whenever they arrive (applyMembership), so one the item holds and
+ * the lot lacks was cleared here; and a rate where the item holds none either.
+ * Otherwise the server keeps its own: several lots never take the item's, so
+ * theirs lacking one says nothing about the holding.
+ */
+function sentTerms(
+  terms: LotTerms | undefined,
+  item: TeamCollectionItem | undefined,
+  parts: { date: boolean; rate: boolean },
+  single: boolean,
+): TeamItemTerms | null {
+  const sent: TeamItemTerms = {};
+  const held = item ? itemTerms(item) : {};
+  const date = lotDate(terms);
+  if (parts.date && (date || (date === null && single && held.dateAcquired))) sent.dateAcquired = date ?? null;
+  if (parts.rate && terms?.currency && CURRENCY_CODE.test(terms.currency) && terms.costFx !== undefined
+    && (terms.costFx || !held.costFx || (single && sameHeldUnit(held.currency, terms.currency)))) {
+    sent.currency = terms.currency;
+    sent.costFxRate = terms.costFx?.rate ?? null;
+    sent.costFxCurrency = terms.costFx?.currency ?? null;
+  }
+  return Object.keys(sent).length > 0 ? sent : null;
 }
 
 /** Which tickers a team collection holds locally, keyed by symbol. */
@@ -84,35 +186,76 @@ export function localMembership(
       continue;
     }
     if (!ticker.metadata.portfolios.includes(localCollectionId)) continue;
-    const { position, lotCount } = getManualPortfolioPositionPrefill(ticker, localCollectionId);
+    const { position, lotCount, costFxConflict } = getManualPortfolioPositionPrefill(ticker, localCollectionId);
+    const currency = position?.currency?.trim() ? normalizeHeldCurrencyCode(position.currency) : undefined;
     members.set(ticker.metadata.ticker, {
       ticker,
       quantity: position ? position.shares : null,
+      lotCount,
       ...(lotCount > 1 && !position ? { lotsNotTotalled: true } : {}),
+      ...(lotCount > 1 && position && costFxConflict ? { lotsKept: true } : {}),
+      ...(position ? {
+        terms: {
+          ...(position.dateAcquired ? { dateAcquired: position.dateAcquired } : {}),
+          ...(currency ? { currency } : {}),
+          ...(costFxConflict ? {} : { costFx: positionCostFx(position) }),
+        },
+      } : {}),
     });
   }
   return members;
 }
 
 export interface MembershipDiff {
-  add: Array<{ symbol: string; quantity: number | null }>;
+  add: Array<{ symbol: string; quantity: number | null; terms?: TeamItemTerms }>;
   remove: string[];
 }
 
+/**
+ * The date and rate a single lot sends on their own, its count unchanged:
+ * those the server lacks, holds otherwise, or holds where the lot was cleared.
+ * A rate goes only over the server's in the same unit, or none, so two
+ * teammates holding it in different currencies never overwrite each other
+ * back and forth, nor do pence written GBp and GBX; only a server that keeps
+ * terms (one that answers with them) is sent any. The first terms an item
+ * gets carry the currency, so it is read as carrying them (itemTerms).
+ */
+function changedTerms(terms: LotTerms | undefined, item: TeamCollectionItem): TeamItemTerms | null {
+  if (!terms || item.dateAcquired === undefined) return null;
+  const held = itemTerms(item);
+  const local = lotDate(terms);
+  const date = local !== undefined && local !== (held.dateAcquired ?? null);
+  const ownsRate = !held.currency || sameHeldUnit(held.currency, terms.currency);
+  const rate = ownsRate && terms.costFx !== undefined
+    && ((held.costFx?.rate ?? null) !== (terms.costFx?.rate ?? null)
+      || (held.costFx?.currency ?? null) !== (terms.costFx?.currency ?? null)
+      || (date && !held.currency));
+  return date || rate ? sentTerms(terms, item, { date, rate }, true) : null;
+}
+
 /**
  * What changed locally since the last known server set, to push upstream.
  * Lots that cannot be totalled have no quantity to push: a ticker the server
- * already holds is left as the server has it, and a new one goes up without one.
+ * already holds is left as the server has it, and a new one goes up without
+ * one; nor do lots whose rates cannot be merged push theirs over the server's.
+ * A count goes up with the purchase date and rate the position keeps, and a
+ * single lot's date or rate on its own when only that changed.
  */
 export function diffMembership(
-  local: ReadonlyMap<string, Pick<LocalMember, "quantity" | "lotsNotTotalled">>,
+  local: ReadonlyMap<string, Pick<LocalMember, "quantity" | "lotsNotTotalled" | "lotsKept" | "lotCount" | "terms">>,
   known: ReadonlyMap<string, TeamCollectionItem>,
 ): MembershipDiff {
   const add: MembershipDiff["add"] = [];
   const remove: string[] = [];
   for (const [symbol, entry] of local) {
     const item = known.get(symbol);
-    if (!item || (!entry.lotsNotTotalled && (item.quantity ?? null) !== entry.quantity)) add.push({ symbol, quantity: entry.quantity });
+    if (!item || (!entry.lotsNotTotalled && !entry.lotsKept && (item.quantity ?? null) !== entry.quantity)) {
+      const terms = sentTerms(entry.terms, item, { date: true, rate: true }, entry.lotCount === 1);
+      add.push({ symbol, quantity: entry.quantity, ...(terms ? { terms } : {}) });
+      continue;
+    }
+    const terms = entry.lotCount === 1 ? changedTerms(entry.terms, item) : null;
+    if (terms) add.push({ symbol, quantity: entry.quantity, terms });
   }
   for (const symbol of known.keys()) {
     if (!local.has(symbol)) remove.push(symbol);
@@ -120,6 +263,8 @@ export function diffMembership(
   return { add, remove };
 }
 
+const teamsLog = debugLog.createLogger("teams");
+
 /** Applies server items to a ticker's metadata for one collection. */
 export function applyMembership(
   ticker: TickerRecord,
@@ -142,7 +287,7 @@ export function applyMembership(
   }
   const has = metadata.portfolios.includes(localCollectionId);
   // The lot itself, or the total of several lots (null when those cannot be totalled).
-  const { position, lotCount } = getManualPortfolioPositionPrefill(ticker, localCollectionId);
+  const { position, lotCount, costFxConflict } = getManualPortfolioPositionPrefill(ticker, localCollectionId);
   const quantity = item?.quantity ?? null;
   if (!item) {
     if (!has && lotCount === 0) return null;
@@ -155,30 +300,46 @@ export function applyMembership(
       },
     };
   }
+  const withMembership = () => (has ? null : { ...ticker, metadata: { ...metadata, portfolios: [...metadata.portfolios, localCollectionId] } });
   // Several lots are collapsed into one only when the server's quantity differs
   // from their total, and never when they cannot be totalled: no lot is dropped
   // for a number that was not compared with all of them.
-  if (lotCount > 1 && (!position || position.shares === quantity)) {
-    return has ? null : { ...ticker, metadata: { ...metadata, portfolios: [...metadata.portfolios, localCollectionId] } };
-  }
-  if (has && (position?.shares ?? null) === quantity) return null;
+  if (lotCount > 1 && (!position || position.shares === quantity)) return withMembership();
   const positions = metadata.positions.filter((entry) => entry.portfolio !== localCollectionId);
-  if (quantity !== null) {
+  if (quantity === null) {
+    if (has && !position) return null;
+  } else {
     // A count that turns a long into a short, or back, is a new position: the old one's cost and date
     // were for what was closed, so the lot keeps neither and its cost is unknown until it is entered.
     const flipped = !!position && quantity !== 0 && position.shares !== 0 && Math.sign(quantity) !== Math.sign(position.shares);
-    positions.push({
+    // The team's purchase date and rate, as the teammate who set the holding sent them, a cleared one
+    // included; the rate only for a lot in the currency it is a rate of. An item that carries no terms
+    // leaves the lot its own, several lots theirs merged.
+    const shared = itemTerms(item);
+    const lotCurrency = position?.currency ?? shared.currency ?? currency;
+    const sharedRate = shared.currency && sameHeldUnit(shared.currency, lotCurrency) ? { costFx: shared.costFx ?? null } : null;
+    if (lotCount > 1 && costFxConflict && !sharedRate && !flipped) {
+      teamsLog.warn("Kept several lots of a team portfolio holding whose cost FX rates cannot become one position", { symbol: metadata.ticker });
+      return withMembership();
+    }
+    const dateAcquired = shared.currency ? shared.dateAcquired : shared.dateAcquired ?? (flipped ? undefined : position?.dateAcquired);
+    const costFx = sharedRate ? sharedRate.costFx : flipped || !position ? null : positionCostFx(position);
+    const lot: TickerPosition = {
       portfolio: localCollectionId,
       shares: quantity,
       ...(flipped ? {} : { avgCost: position?.avgCost ?? 0 }),
-      currency: position?.currency ?? currency,
+      currency: lotCurrency,
       broker: "manual",
-      ...(!flipped && position?.dateAcquired ? { dateAcquired: position.dateAcquired } : {}),
+      ...(dateAcquired ? { dateAcquired } : {}),
       // So does the rate its cost was bought at, with its cost.
-      ...(!flipped && position?.costFxRate != null && position.costFxCurrency ? { costFxRate: position.costFxRate, costFxCurrency: position.costFxCurrency } : {}),
+      ...(costFx ? { costFxRate: costFx.rate, costFxCurrency: costFx.currency } : {}),
       // A future's contract size stays with the holding when the team changes its count.
       ...(position?.multiplier ? { multiplier: position.multiplier } : {}),
-    });
+    };
+    // A single lot already as the server has it is left as it is.
+    if (has && lotCount === 1 && position && position.shares === quantity && position.dateAcquired === lot.dateAcquired
+      && position.costFxRate === lot.costFxRate && position.costFxCurrency === lot.costFxCurrency) return null;
+    positions.push(lot);
   }
   return {
     ...ticker,

package/src/telemetry/crash-reports.ts

@@ -18,7 +18,9 @@ import { VERSION } from "../version";
  * failures are posted to Gloom's API, which forwards them to error tracking;
  * the app never talks to an analytics service itself. What leaves the
  * machine is the error (type, message, stack), the surface, the app version
- * and the OS. Nothing from the workspace goes along: no portfolio, config,
+ * and the OS. A plugin load failure can add a line of state about the
+ * plugin's files to the message (see `CrashReportContext.detail`). Nothing
+ * from the workspace goes along: no portfolio, config,
  * query, ticker list or layout. The user's home directory is replaced by `~`
  * before sending.
  *
@@ -71,6 +73,12 @@ export interface CrashReportContext {
   componentStack?: string | null;
   /** A failed update step (update-failures.ts), sent as it is: it holds no free text. */
   update?: UpdateFailureReport;
+  /**
+   * State that explains the failure, appended to the message in brackets.
+   * The message, not the stack: error tracking keeps only frames from the
+   * stack, and an import error has none.
+   */
+  detail?: string;
 }
 
 interface PendingError {
@@ -105,11 +113,14 @@ function isOptOut(value: string | undefined): boolean {
   return normalized === "1" || normalized === "true" || normalized === "yes";
 }
 
-/** Replaces the home directory, in native, forward-slash and URL-encoded forms, with `~`. */
+/**
+ * Replaces the home directory, in native, forward-slash, URL-encoded and
+ * escaped (a Windows path in JSON or a string literal) forms, with `~`.
+ */
 export function stripHomeDir(text: string, homeDir: string | null | undefined): string {
   const home = homeDir?.trim().replace(/[\\/]+$/, "");
   if (!home || home.length < 3) return text;
-  const forms = new Set([home, home.replaceAll("\\", "/")]);
+  const forms = new Set([home, home.replaceAll("\\", "/"), home.replaceAll("\\", "\\\\")]);
   for (const form of [...forms]) forms.add(encodeURI(form));
   let result = text;
   for (const form of forms) {
@@ -155,7 +166,9 @@ function topFrame(stack: string | undefined, type: string): string {
 }
 
 function toReportError(error: unknown, context: CrashReportContext): PendingError {
-  const described = describeError(error);
+  const thrown = describeError(error);
+  const detail = readString(context.detail?.trim());
+  const described = detail ? { ...thrown, message: `${thrown.message} [${detail}]` } : thrown;
   const componentStack = readString(context.componentStack?.trim());
   const stack = [
     described.stack ? clip(described.stack, MAX_STACK_LENGTH) : null,

package/src/telemetry/usage-counts.ts

@@ -97,7 +97,6 @@ let officialIds: ReadonlySet<string> | null = null;
 let officialLookup: Promise<void> | null = null;
 let automationDepth = 0;
 const builtinPlugins = new WeakSet<object>();
-const openListeners = new Set<() => void>();
 
 /** Reads the config switch and the environment. Absent means on. */
 export function usageCountsEnabled(
@@ -197,27 +196,10 @@ export function automationActive(): boolean {
   return automationDepth > 0;
 }
 
-/**
- * Calls `listener` each time the user opens a function, with nothing about
- * which one. The web terminal's first-screen measure uses it; automation never
- * reaches it.
- */
-export function subscribeFunctionOpens(listener: () => void): () => void {
-  openListeners.add(listener);
-  return () => {
-    openListeners.delete(listener);
-  };
-}
-
 /** Counts one open of a function by the user. Never throws. */
 export function recordFunctionOpen(fn: UsageFunction): void {
   try {
     if (automationDepth > 0) return;
-    for (const listener of openListeners) {
-      try { listener(); } catch (error) {
-        logFailure("telemetry-usage-counts", "Could not notify function-open listener")(error);
-      }
-    }
     if (host && !host.isEnabled()) return;
     count(fn, "opened");
     scheduleFlush();

package/src/test-support/builtin-panes.ts

@@ -5,7 +5,7 @@ import type { GloomPlugin, PaneDef } from "../types/plugin";
 
 /**
  * Every built-in pane definition, the panes a plugin registers in `setup()`
- * included, as `gloomberb catalog` finds them. `dispose` stops the plugins
+ * included, as `gloom catalog` finds them. `dispose` stops the plugins
  * that were set up.
  */
 export async function loadBuiltinPanes(): Promise<{ panes: Map<string, PaneDef>; dispose: () => void }> {

package/src/theme/colors.ts

@@ -1,6 +1,6 @@
 import { blendForContrast, blendForContrastOnSurfaces, blendHex, higherContrast } from "./color-utils";
 import { getTheme, DEFAULT_THEME, type Theme } from "./themes";
-import { roleColours } from "./ui-tokens";
+import { hoverColour, themeCssVariables } from "./ui-tokens";
 
 export type ThemeColors = Readonly<Omit<Theme, "name" | "description">>;
 
@@ -24,34 +24,11 @@ export const colors = new Proxy({ ...currentColors } as ThemeColors, {
   }),
 }) as ThemeColors;
 
-type ColorKey = keyof typeof colors;
-
 let currentThemeId = DEFAULT_THEME;
 let transientPreviewThemeId: string | null = null;
 let cssThemeId: string | null = null;
 let cssThemeDocument: unknown = null;
 
-const THEME_CSS_VARIABLES: Array<[ColorKey, string]> = [
-  ["bg", "--gloom-bg"],
-  ["panel", "--gloom-panel"],
-  ["border", "--gloom-border"],
-  ["borderFocused", "--gloom-border-focused"],
-  ["text", "--gloom-text"],
-  ["textDim", "--gloom-text-dim"],
-  ["textBright", "--gloom-text-bright"],
-  ["textMuted", "--gloom-text-muted"],
-  ["positive", "--gloom-positive"],
-  ["negative", "--gloom-negative"],
-  ["neutral", "--gloom-neutral"],
-  ["warning", "--gloom-warning"],
-  ["header", "--gloom-header"],
-  ["headerText", "--gloom-header-text"],
-  ["selected", "--gloom-selected"],
-  ["selectedText", "--gloom-selected-text"],
-  ["commandBg", "--gloom-command-bg"],
-  ["commandBorder", "--gloom-command-border"],
-];
-
 export function getCurrentThemeId(): string {
   return currentThemeId;
 }
@@ -114,7 +91,7 @@ export function getChartIndicatorColor(index: number): string {
 
 /** Returns a hover background color derived from bg and selected */
 export function hoverBg(palette: ThemeColors = colors): string {
-  return blendHex(palette.bg, palette.selected, 0.5);
+  return hoverColour(palette);
 }
 
 /** Body-text contrast, which text on a hovered control keeps whatever the surface. */
@@ -145,11 +122,7 @@ function syncThemeCssVariables(): void {
   if (cssThemeId === currentThemeId && cssThemeDocument === documentLike) return;
   cssThemeId = currentThemeId;
   cssThemeDocument = documentLike;
-  for (const [key, name] of THEME_CSS_VARIABLES) {
-    style.setProperty(name, currentColors[key]);
-  }
-  style.setProperty("--gloom-hover-bg", hoverBg());
-  for (const [name, value] of roleColours(currentColors)) style.setProperty(name, value);
+  for (const [name, value] of themeCssVariables(currentColors)) style.setProperty(name, value);
 }
 
 export function commandBarBg(palette: ThemeColors = colors): string {
@@ -318,6 +291,14 @@ export function priceColor(value: number, palette: ThemeColors = colors): string
   return palette.neutral;
 }
 
+/**
+ * `priceColor` for a figure as it is printed, to `digits` decimals: a move that
+ * rounds to zero (0.00%, never -0.00%) is neutral, not red or green.
+ */
+export function shownPriceColor(value: number, digits: number, palette: ThemeColors = colors): string {
+  return priceColor(Number(value.toFixed(digits)), palette);
+}
+
 const TONE_TINT = 0.18;
 
 /**

package/src/theme/ui-tokens.ts

@@ -53,11 +53,16 @@ function surfaceSunkenColour(palette: Palette): string {
   return palette.bg;
 }
 
+/** A row or control under the pointer: halfway from the background to the selection. */
+export function hoverColour(palette: Palette): string {
+  return blendHex(palette.bg, palette.selected, 0.5);
+}
+
 /**
  * The colour roles the palette names indirectly, as `--gloom-*` variables:
  * styles.css and inline styles read these, never a blend of their own.
  */
-export function roleColours(palette: Palette): Array<[string, string]> {
+function roleColours(palette: Palette): Array<[string, string]> {
   return [
     ["--gloom-surface-raised", surfaceRaisedColour(palette)],
     ["--gloom-surface-sunken", surfaceSunkenColour(palette)],
@@ -69,3 +74,34 @@ export function roleColours(palette: Palette): Array<[string, string]> {
     ["--gloom-locked", palette.textDim],
   ];
 }
+
+/** The palette entries styles.css reads as they are. */
+const PALETTE_VARIABLES: Array<[keyof Palette, string]> = [
+  ["bg", "--gloom-bg"],
+  ["panel", "--gloom-panel"],
+  ["border", "--gloom-border"],
+  ["borderFocused", "--gloom-border-focused"],
+  ["text", "--gloom-text"],
+  ["textDim", "--gloom-text-dim"],
+  ["textBright", "--gloom-text-bright"],
+  ["textMuted", "--gloom-text-muted"],
+  ["positive", "--gloom-positive"],
+  ["negative", "--gloom-negative"],
+  ["neutral", "--gloom-neutral"],
+  ["warning", "--gloom-warning"],
+  ["header", "--gloom-header"],
+  ["headerText", "--gloom-header-text"],
+  ["selected", "--gloom-selected"],
+  ["selectedText", "--gloom-selected-text"],
+  ["commandBg", "--gloom-command-bg"],
+  ["commandBorder", "--gloom-command-border"],
+];
+
+/** Every custom property a theme sets on the document root, which the desktop and web stylesheet draws with. */
+export function themeCssVariables(palette: Palette): Array<[string, string]> {
+  return [
+    ...PALETTE_VARIABLES.map(([key, name]): [string, string] => [name, palette[key]]),
+    ["--gloom-hover-bg", hoverColour(palette)],
+    ...roleColours(palette),
+  ];
+}