gloomberb 0.3.7 → 0.4.1

package/src/market-data/selectors.ts

@@ -4,6 +4,7 @@ import type { InstrumentRef, NewsRequest, OptionsRequest, SecFilingsRequest, Cha
 import type { QueryEntry } from "./result-types";
 import { hasLikelyQuoteUnitMismatch } from "../utils/currency-units";
 import { normalizePriceHistory } from "../utils/price-history";
+import { resolveTickerFinancialsQuoteState } from "../utils/quote-resolution";
 
 export function buildInstrumentKey(instrument: InstrumentRef): string {
   const contractKey = instrument.instrument?.conId
@@ -51,8 +52,9 @@ export function buildChartKey(request: ChartRequest): string {
   return [
     "chart",
     buildInstrumentKey(request.instrument),
-    request.range,
-    request.granularity ?? "daily",
+    request.bufferRange,
+    request.granularity ?? "range",
+    request.resolution ?? "",
     request.startDate ? request.startDate.toISOString() : "",
     request.endDate ? request.endDate.toISOString() : "",
     request.barSize ?? "",
@@ -95,54 +97,6 @@ export function hasLikelyPriceUnitMismatch(
   return hasLikelyQuoteUnitMismatch(left, right);
 }
 
-function mergeDefinedQuoteFields(
-  preferred: Quote | null | undefined,
-  fallback: Quote | null | undefined,
-): Quote | undefined {
-  const mergedEntries: Array<[string, unknown]> = [];
-  for (const source of [fallback, preferred]) {
-    if (!source) continue;
-    for (const [key, value] of Object.entries(source)) {
-      if (value !== undefined) {
-        mergedEntries.push([key, value]);
-      }
-    }
-  }
-  if (mergedEntries.length === 0) return undefined;
-  return Object.fromEntries(mergedEntries) as Quote;
-}
-
-function projectExtendedHoursQuote(
-  snapshotQuote: Quote | null | undefined,
-  liveQuote: Quote | null | undefined,
-): Quote | undefined {
-  const merged = mergeDefinedQuoteFields(liveQuote, snapshotQuote);
-  if (!merged) return undefined;
-  if (!snapshotQuote || !liveQuote) return merged;
-
-  const snapshotState = snapshotQuote.marketState;
-  if (snapshotState !== "PRE" && snapshotState !== "POST") return merged;
-  if (liveQuote.marketState === "PRE" || liveQuote.marketState === "POST") return merged;
-
-  if (snapshotState === "PRE") {
-    return {
-      ...merged,
-      marketState: "PRE",
-      preMarketPrice: liveQuote.price,
-      preMarketChange: liveQuote.change,
-      preMarketChangePercent: liveQuote.changePercent,
-    };
-  }
-
-  return {
-    ...merged,
-    marketState: "POST",
-    postMarketPrice: liveQuote.price,
-    postMarketChange: liveQuote.change,
-    postMarketChangePercent: liveQuote.changePercent,
-  };
-}
-
 export function buildTickerFinancialsSnapshot(
   snapshotEntry: QueryEntry<TickerFinancials>,
   quoteEntry?: QueryEntry<TickerFinancials["quote"]>,
@@ -152,15 +106,27 @@ export function buildTickerFinancialsSnapshot(
   const quote = resolveEntryData(quoteEntry);
   const priceHistory = resolveEntryData(chartEntry);
   if (!snapshot && !quote && !priceHistory) return null;
-  const resolvedQuote = snapshot?.quote && quote && hasLikelyPriceUnitMismatch(snapshot.quote, quote)
-    ? snapshot.quote
-    : (projectExtendedHoursQuote(snapshot?.quote, quote) ?? snapshot?.quote);
+  if (snapshot?.quote && quote && hasLikelyPriceUnitMismatch(snapshot.quote, quote)) {
+    return {
+      ...(resolveTickerFinancialsQuoteState(snapshot) ?? {
+        annualStatements: snapshot?.annualStatements ?? [],
+        quarterlyStatements: snapshot?.quarterlyStatements ?? [],
+        priceHistory: snapshot?.priceHistory ?? [],
+      }),
+      priceHistory: normalizePriceHistory(priceHistory ?? snapshot?.priceHistory ?? []),
+    };
+  }
+
+  const resolved = resolveTickerFinancialsQuoteState(snapshot ?? {
+    annualStatements: [],
+    quarterlyStatements: [],
+    priceHistory: [],
+  }, quote);
+
+  if (!resolved) return null;
+
   return {
-    quote: resolvedQuote,
-    fundamentals: snapshot?.fundamentals,
-    profile: snapshot?.profile,
-    annualStatements: snapshot?.annualStatements ?? [],
-    quarterlyStatements: snapshot?.quarterlyStatements ?? [],
+    ...resolved,
     priceHistory: normalizePriceHistory(priceHistory ?? snapshot?.priceHistory ?? []),
   };
 }

package/src/plugins/builtin/chat-controller.test.ts

@@ -7,7 +7,15 @@ import { ChatController } from "./chat-controller";
 const TRANSCRIPT_KIND = "channel-transcript";
 const TRANSCRIPT_KEY = "everyone";
 const TRANSCRIPT_SOURCE = "server";
+const TRANSCRIPT_SCHEMA_VERSION = 2;
+const originalConnectChannel = apiClient.connectChannel.bind(apiClient);
 const originalGetSession = apiClient.getSession.bind(apiClient);
+const originalGetMessages = apiClient.getMessages.bind(apiClient);
+
+async function flushMicrotasks() {
+  await Promise.resolve();
+  await Promise.resolve();
+}
 
 class MemoryPersistence implements PluginPersistence {
   private readonly state = new Map<string, { schemaVersion: number; value: unknown }>();
@@ -76,8 +84,11 @@ class MemoryPersistence implements PluginPersistence {
 }
 
 afterEach(() => {
+  apiClient.dispose();
   apiClient.setSessionToken(null);
+  apiClient.connectChannel = originalConnectChannel;
   apiClient.getSession = originalGetSession;
+  apiClient.getMessages = originalGetMessages;
 });
 
 describe("ChatController", () => {
@@ -101,12 +112,13 @@ describe("ChatController", () => {
       draft: "cached draft",
       replyToId: "m1",
       lastCursor: "2026-03-28T00:00:00.000Z",
+      lastViewedMessageId: "m1",
     }, { schemaVersion: 1 });
     persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
       messages: [message],
     }, {
       sourceKey: TRANSCRIPT_SOURCE,
-      schemaVersion: 1,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
       cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
     });
 
@@ -155,12 +167,13 @@ describe("ChatController", () => {
       draft: "cached draft",
       replyToId: null,
       lastCursor: null,
+      lastViewedMessageId: null,
     }, { schemaVersion: 1 });
     persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
       messages: [],
     }, {
       sourceKey: TRANSCRIPT_SOURCE,
-      schemaVersion: 1,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
       cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
     });
 
@@ -169,7 +182,10 @@ describe("ChatController", () => {
 
     expect(apiClient.getSessionToken()).toBeNull();
     expect(persistence.getState("session", { schemaVersion: 1 })).toBeNull();
-    expect(persistence.getResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, { sourceKey: TRANSCRIPT_SOURCE, schemaVersion: 1 })).toBeNull();
+    expect(persistence.getResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+    })).toBeNull();
   });
 
   test("pauses verification polling while the app is backgrounded", () => {
@@ -188,6 +204,35 @@ describe("ChatController", () => {
     controller.reset(true);
   });
 
+  test("dispose stops verification polling and closes the live connection", () => {
+    const controller = new ChatController();
+    let closed = false;
+
+    apiClient.setSessionToken("token-123");
+    (controller as any).user = { id: "u1", username: "vince", emailVerified: false };
+    (controller as any).syncVerificationPolling();
+    expect((controller as any).verificationPollTimer).not.toBeNull();
+
+    (controller as any).user = { id: "u1", username: "vince", emailVerified: true };
+    apiClient.connectChannel = () => ({
+      send: async () => {
+        throw new Error("not implemented");
+      },
+      close: () => {
+        closed = true;
+      },
+    });
+
+    controller.ensureConnection();
+    expect((controller as any).wsConnection).not.toBeNull();
+
+    controller.dispose();
+
+    expect(closed).toBe(true);
+    expect((controller as any).verificationPollTimer).toBeNull();
+    expect((controller as any).wsConnection).toBeNull();
+  });
+
   test("keeps the cached session when session refresh fails transiently", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -214,4 +259,356 @@ describe("ChatController", () => {
       emailVerified: true,
     });
   });
+
+  test("refreshes the public transcript without requiring a session", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const message: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "hello from the lobby",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+    };
+
+    controller.attachPersistence(persistence);
+    apiClient.getMessages = async () => [message];
+
+    await controller.refreshMessages();
+
+    expect(controller.getSnapshot().messages).toEqual([message]);
+    expect(persistence.getResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+    })?.value).toEqual({
+      messages: [message],
+    });
+  });
+
+  test("stores the latest message id as the incremental cursor", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const initial: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "hello",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+    };
+    const next: ChatMessage = {
+      id: "m2",
+      channelId: "everyone",
+      content: "new message",
+      replyToId: null,
+      createdAt: "2026-03-28T00:01:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    persistence.setState("channel:everyone", {
+      draft: "",
+      replyToId: null,
+      lastCursor: "m1",
+      lastViewedMessageId: "m1",
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages: [initial],
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+
+    controller.attachPersistence(persistence);
+
+    const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
+    apiClient.getMessages = async (channelId, opts) => {
+      calls.push({ channelId, opts });
+      return opts?.after === "m1" ? [next] : [];
+    };
+
+    await controller.refreshMessages();
+
+    expect(calls).toEqual([{
+      channelId: "everyone",
+      opts: { limit: 50, after: "m1" },
+    }]);
+    expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2"]);
+    expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
+      lastCursor: "m2",
+    });
+  });
+
+  test("shows a pending message immediately and replaces it when the send succeeds", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const replyTarget: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "first",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+    const sentMessage: ChatMessage = {
+      id: "m2",
+      channelId: "everyone",
+      content: "hello",
+      replyToId: "m1",
+      createdAt: "2026-03-28T00:01:00.000Z",
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+      replyTo: { content: "first", user: { username: "bob" } },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    persistence.setState("channel:everyone", {
+      draft: "hello",
+      replyToId: "m1",
+      lastCursor: "m1",
+      lastViewedMessageId: "m1",
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages: [replyTarget],
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+
+    controller.attachPersistence(persistence);
+
+    let resolveSend: ((message: ChatMessage) => void) | null = null;
+    apiClient.connectChannel = () => ({
+      send: () => new Promise<ChatMessage>((resolve) => {
+        resolveSend = resolve;
+      }),
+      close: () => {},
+    });
+
+    controller.send("hello", "m1");
+
+    let snapshot = controller.getSnapshot();
+    expect(snapshot.draft).toBe("");
+    expect(snapshot.replyToId).toBeNull();
+    expect(snapshot.messages.map((message) => message.id)).toEqual(["m1", snapshot.messages[1]!.id]);
+    expect(snapshot.messages[1]).toMatchObject({
+      content: "hello",
+      replyToId: "m1",
+      clientStatus: "sending",
+      replyTo: { content: "first", user: { username: "bob" } },
+    });
+
+    resolveSend?.(sentMessage);
+    await flushMicrotasks();
+
+    snapshot = controller.getSnapshot();
+    expect(snapshot.messages).toEqual([replyTarget, sentMessage]);
+  });
+
+  test("marks a pending message as failed when sending errors", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const toasts: string[] = [];
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.setToastNotifier((message) => {
+      toasts.push(message);
+    });
+    controller.attachPersistence(persistence);
+
+    apiClient.connectChannel = () => ({
+      send: async () => {
+        throw new Error("server offline");
+      },
+      close: () => {},
+    });
+
+    controller.send("hello");
+    await flushMicrotasks();
+
+    const snapshot = controller.getSnapshot();
+    expect(snapshot.messages).toHaveLength(1);
+    expect(snapshot.messages[0]).toMatchObject({
+      content: "hello",
+      clientStatus: "failed",
+      clientError: "server offline",
+    });
+    expect(toasts).toEqual(["server offline"]);
+  });
+
+  test("tracks unread mentions and shows a toast while chat is closed", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const toasts: string[] = [];
+    const message: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "hey @Vince can you take a look?",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.setToastNotifier((toast) => {
+      toasts.push(toast);
+    });
+    controller.attachPersistence(persistence);
+
+    (controller as any).mergeMessages([message]);
+
+    expect(controller.getSnapshot().unreadMentionCount).toBe(1);
+    expect(toasts).toEqual(["@bob mentioned you: hey @Vince can you take a look?"]);
+    expect(persistence.getState<{ lastCursor: string | null; lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
+      lastCursor: "m1",
+      lastViewedMessageId: null,
+    });
+  });
+
+  test("marks mentions viewed when a chat view opens", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const toasts: string[] = [];
+    const message: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "hey @vince",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.setToastNotifier((toast) => {
+      toasts.push(toast);
+    });
+    controller.attachPersistence(persistence);
+
+    (controller as any).mergeMessages([message]);
+
+    expect(controller.getSnapshot().unreadMentionCount).toBe(1);
+
+    const detachView = controller.attachView();
+
+    expect(controller.getSnapshot().unreadMentionCount).toBe(0);
+    expect(toasts).toEqual(["@bob mentioned you: hey @vince"]);
+    expect(persistence.getState<{ lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
+      lastViewedMessageId: "m1",
+    });
+    detachView();
+  });
+
+  test("does not keep mentions unread while a chat view is already open", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const toasts: string[] = [];
+    const message: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "hey @vince",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.setToastNotifier((toast) => {
+      toasts.push(toast);
+    });
+    controller.attachPersistence(persistence);
+    const detachView = controller.attachView();
+
+    (controller as any).mergeMessages([message]);
+
+    expect(controller.getSnapshot().unreadMentionCount).toBe(0);
+    expect(toasts).toEqual([]);
+    expect(persistence.getState<{ lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
+      lastViewedMessageId: "m1",
+    });
+
+    detachView();
+  });
+
+  test("recovers from a legacy timestamp cursor by falling back to a full transcript fetch", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const cached: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "cached",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+    };
+    const fullTranscript: ChatMessage[] = [
+      cached,
+      {
+        id: "m2",
+        channelId: "everyone",
+        content: "fresh",
+        replyToId: null,
+        createdAt: "2026-03-28T00:01:00.000Z",
+        user: { id: "u2", username: "bob", displayName: "Bob" },
+      },
+    ];
+
+    persistence.setState("channel:everyone", {
+      draft: "",
+      replyToId: null,
+      lastCursor: "2026-03-28T00:00:00.000Z",
+      lastViewedMessageId: "m1",
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages: [cached],
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+
+    controller.attachPersistence(persistence);
+
+    const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
+    apiClient.getMessages = async (channelId, opts) => {
+      calls.push({ channelId, opts });
+      return opts?.after ? [] : fullTranscript;
+    };
+
+    await controller.refreshMessages();
+
+    expect(calls).toEqual([
+      {
+        channelId: "everyone",
+        opts: { limit: 50, after: "2026-03-28T00:00:00.000Z" },
+      },
+      {
+        channelId: "everyone",
+        opts: { limit: 50 },
+      },
+    ]);
+    expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2"]);
+    expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
+      lastCursor: "m2",
+    });
+  });
 });