gloomberb 0.10.0 → 0.10.2

package/src/time-series/hooks.ts

@@ -5,6 +5,7 @@ import { instrumentFromTicker } from "../market-data/request-types";
 import { useAssetData } from "../plugins/runtime";
 import { useAppSelector } from "../state/app/context";
 import type { FredSeriesRequest } from "../data/fred-series";
+import type { TickerRecord } from "../types/ticker";
 import type { ChartSpec } from "./types";
 import {
   useChartResolution,
@@ -22,24 +23,44 @@ async function loadFred(request: FredSeriesRequest) {
   );
 }
 
+export function hydrateChartSpecInstruments(
+  spec: ChartSpec,
+  tickers: ReadonlyMap<string, TickerRecord>,
+): ChartSpec {
+  let changed = false;
+  const series = spec.series.map((entry) => {
+    if (entry.source.kind !== "security" || entry.source.instrument.exchange?.trim()) {
+      return entry;
+    }
+    const symbol = entry.source.instrument.symbol.trim().toUpperCase();
+    const instrument = instrumentFromTicker(tickers.get(symbol), symbol);
+    if (!instrument?.exchange) return entry;
+    changed = true;
+    return {
+      ...entry,
+      source: {
+        ...entry.source,
+        instrument: {
+          ...instrument,
+          ...entry.source.instrument,
+          exchange: instrument.exchange,
+        },
+      },
+    };
+  });
+  return changed ? { ...spec, series } : spec;
+}
+
 export function useResolvedChartSpec(
   spec: ChartSpec,
   options: UseChartResolutionOptions = {},
 ): UseChartResolutionResult {
   const dataProvider = useAssetData();
   const tickers = useAppSelector((state) => state.tickers);
-  const hydratedSpec = useMemo<ChartSpec>(() => ({
-    ...spec,
-    series: spec.series.map((entry) => {
-      if (entry.source.kind !== "security" || entry.source.instrument.exchange) return entry;
-      const symbol = entry.source.instrument.symbol.trim().toUpperCase();
-      const ticker = tickers.get(symbol);
-      const instrument = instrumentFromTicker(ticker, symbol);
-      return instrument
-        ? { ...entry, source: { ...entry.source, instrument: { ...instrument, ...entry.source.instrument } } }
-        : entry;
-    }),
-  }), [spec, tickers]);
+  const hydratedSpec = useMemo(
+    () => hydrateChartSpecInstruments(spec, tickers),
+    [spec, tickers],
+  );
   const sources = useMemo(() => ({ dataProvider, loadFredSeries: loadFred }), [dataProvider]);
   return useChartResolution(hydratedSpec, sources, options);
 }

package/src/time-series/market-resolution.ts

@@ -1,7 +1,7 @@
 import {
   CHART_RESOLUTION_STEP_MS,
   type ManualChartResolution,
-} from "../components/chart/core/resolution";
+} from "./resolution";
 import { isMarketFieldId } from "./field-catalog";
 import type { ChartSeriesSpec, SeriesPeriod } from "./types";
 
@@ -27,7 +27,7 @@ export function isResolutionFineEnoughForMarketPeriod(
 }
 
 /** Returns the finest fetch cadence required by explicit market periods. */
-export function finestExplicitMarketPeriodResolution(
+function finestExplicitMarketPeriodResolution(
   series: readonly ChartSeriesSpec[],
 ): ManualChartResolution | null {
   let finest: ManualChartResolution | null = null;

package/src/time-series/market.ts

@@ -41,7 +41,7 @@ interface AggregatedPricePoint {
 }
 
 /** Aggregates OHLCV correctly: first open, max high, min low, last close, summed volume. */
-export function aggregatePriceHistory(
+function aggregatePriceHistory(
   points: readonly PricePoint[],
   period: SeriesPeriod,
 ): PricePoint[] {

package/src/time-series/range.ts

@@ -0,0 +1,9 @@
+export type TimeRange = "1D" | "1W" | "1M" | "3M" | "6M" | "1Y" | "5Y" | "ALL";
+export type ChartResolution = "auto" | "1m" | "5m" | "15m" | "30m" | "45m" | "1h" | "1d" | "1wk" | "1mo";
+
+export interface ChartDateWindow {
+  start: Date | null;
+  end: Date | null;
+}
+
+export const TIME_RANGES: TimeRange[] = ["1D", "1W", "1M", "3M", "6M", "1Y", "5Y", "ALL"];

package/src/{components/chart/core → time-series}/resolution.ts

@@ -1,5 +1,5 @@
-import type { ChartResolution, TimeRange } from "./types";
-import { TIME_RANGES } from "./types";
+import type { ChartResolution, TimeRange } from "./range";
+import { TIME_RANGES } from "./range";
 import { isDateWindowWithinTimeRange } from "./date-window";
 
 export type ManualChartResolution = Exclude<ChartResolution, "auto">;
@@ -71,10 +71,6 @@ export const CHART_RESOLUTION_STEP_MS: Record<ManualChartResolution, number> = {
   "1mo": 30 * 24 * 60 * 60_000,
 };
 
-export function getChartResolutionStepMs(resolution: ChartResolution): number | null {
-  return resolution === "auto" ? null : CHART_RESOLUTION_STEP_MS[resolution];
-}
-
 const CHART_RESOLUTION_POINTS_PER_DAY: Record<ManualChartResolution, number> = {
   "1m": 390,
   "5m": 78,
@@ -88,22 +84,6 @@ const CHART_RESOLUTION_POINTS_PER_DAY: Record<ManualChartResolution, number> = {
 };
 
 const TIME_RANGE_INDEX = new Map(TIME_RANGE_ORDER.map((range, index) => [range, index]));
-const RANGE_PRESETS_BY_RESOLUTION = TIME_RANGE_ORDER.reduce<Record<ManualChartResolution, TimeRange[]>>((acc, range) => {
-  const resolution = RANGE_PRESET_RESOLUTION[range];
-  acc[resolution] ??= [];
-  acc[resolution].push(range);
-  return acc;
-}, {
-  "1m": [],
-  "5m": [],
-  "15m": [],
-  "30m": [],
-  "45m": [],
-  "1h": [],
-  "1d": [],
-  "1wk": [],
-  "1mo": [],
-});
 
 function getTimeRangeIndex(range: TimeRange): number {
   return TIME_RANGE_INDEX.get(range) ?? 0;
@@ -133,14 +113,6 @@ export function getPresetResolution(range: TimeRange): ManualChartResolution {
   return RANGE_PRESET_RESOLUTION[range];
 }
 
-function getManualResolutionOrderIndex(resolution: ManualChartResolution): number {
-  return CHART_RESOLUTION_ORDER.indexOf(resolution);
-}
-
-function getPresetBufferRange(range: TimeRange): TimeRange {
-  return RANGE_PRELOAD_BUFFER[range];
-}
-
 export function getNextBufferRange(range: TimeRange): TimeRange {
   return RANGE_PRELOAD_BUFFER[range];
 }
@@ -201,12 +173,6 @@ export function intersectChartResolutionSupport(
   }));
 }
 
-export function buildChartResolutionSupportMap(
-  support: readonly ChartResolutionSupport[],
-): ReadonlyMap<ManualChartResolution, TimeRange> {
-  return new Map(normalizeChartResolutionSupport(support).map((entry) => [entry.resolution, entry.maxRange] as const));
-}
-
 export function getSupportMaxRange(
   support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
   resolution: ManualChartResolution,
@@ -221,11 +187,7 @@ function minTimeRange(left: TimeRange, right: TimeRange): TimeRange {
   return compareTimeRange(left, right) <= 0 ? left : right;
 }
 
-export function maxTimeRange(left: TimeRange, right: TimeRange): TimeRange {
-  return compareTimeRange(left, right) >= 0 ? left : right;
-}
-
-export function isTimeRangeAtOrBelow(candidate: TimeRange, maxRange: TimeRange): boolean {
+function isTimeRangeAtOrBelow(candidate: TimeRange, maxRange: TimeRange): boolean {
   return compareTimeRange(candidate, maxRange) <= 0;
 }
 
@@ -255,43 +217,6 @@ export function isRangePresetSupported(
   return maxRange !== null && isTimeRangeAtOrBelow(range, maxRange);
 }
 
-export function getWidestPresetForResolution(
-  resolution: ManualChartResolution,
-  maxRange: TimeRange,
-): TimeRange {
-  const presets = RANGE_PRESETS_BY_RESOLUTION[resolution] ?? [];
-  const supported = presets.filter((range) => isTimeRangeAtOrBelow(range, maxRange));
-  if (supported.length > 0) {
-    return supported[supported.length - 1]!;
-  }
-  const fallback = TIME_RANGE_ORDER.filter((range) => isTimeRangeAtOrBelow(range, maxRange));
-  return fallback[fallback.length - 1] ?? "1D";
-}
-
-export function getBestSupportedResolutionForPreset(
-  range: TimeRange,
-  support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
-  preferredResolution = getPresetResolution(range),
-): ManualChartResolution | null {
-  const supportedResolutions = CHART_RESOLUTION_ORDER
-    .filter((resolution): resolution is ManualChartResolution => resolution !== "auto")
-    .filter((resolution) => {
-      const maxRange = getSupportMaxRange(support, resolution);
-      return maxRange !== null && isTimeRangeAtOrBelow(range, maxRange);
-    });
-
-  if (supportedResolutions.length === 0) return null;
-  if (supportedResolutions.includes(preferredResolution)) return preferredResolution;
-
-  const preferredIndex = getManualResolutionOrderIndex(preferredResolution);
-  const coarserResolution = supportedResolutions.find((resolution) => (
-    getManualResolutionOrderIndex(resolution) > preferredIndex
-  ));
-  if (coarserResolution) return coarserResolution;
-
-  return supportedResolutions[supportedResolutions.length - 1] ?? null;
-}
-
 export function getBestSupportedResolutionForVisibleWindow(
   window: { start: Date | null; end: Date | null } | null,
   support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
@@ -322,27 +247,3 @@ export function getBestSupportedResolutionForVisibleWindow(
 
   return supportedResolutions[0] ?? null;
 }
-
-export function getNextFallbackResolution(
-  range: TimeRange,
-  currentResolution: ManualChartResolution,
-  support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
-): ChartResolution | null {
-  const currentIndex = getManualResolutionOrderIndex(currentResolution);
-  const nextResolution = CHART_RESOLUTION_ORDER
-    .filter((resolution): resolution is ManualChartResolution => resolution !== "auto")
-    .find((resolution) => (
-      getManualResolutionOrderIndex(resolution) > currentIndex
-      && (() => {
-        const maxRange = getSupportMaxRange(support, resolution);
-        return maxRange !== null && isTimeRangeAtOrBelow(range, maxRange);
-      })()
-    ));
-
-  return nextResolution ?? "auto";
-}
-
-export function getCompatibleBufferRange(presetRange: TimeRange, maxRange: TimeRange | null): TimeRange {
-  const preloadRange = getPresetBufferRange(presetRange);
-  return maxRange ? clampTimeRangeToMaxRange(preloadRange, maxRange) : preloadRange;
-}

package/src/time-series/resolve.test.ts

@@ -111,6 +111,145 @@ describe("resolveChartSpecData", () => {
     ]);
   });
 
+  test("keeps the snapshot exchange when a newer quote omits it", async () => {
+    const historyExchanges: string[] = [];
+    const source = {
+      kind: "security" as const,
+      instrument: { symbol: "SNDK" },
+      fieldId: "market.ohlcv",
+    };
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => ({
+        ...emptyFinancials(),
+        quote: {
+          symbol: "SNDK",
+          price: 1_240,
+          currency: "USD",
+          change: 20,
+          changePercent: 1.64,
+          lastUpdated: Date.parse("2026-07-30T15:25:00Z"),
+          listingExchangeName: "XNAS",
+        },
+      }),
+      getPriceHistoryForResolution: async (_symbol, exchange) => {
+        historyExchanges.push(exchange);
+        return [{
+          date: new Date("2026-07-30T15:20:00Z"),
+          open: 1_235,
+          high: 1_242,
+          low: 1_233,
+          close: 1_240,
+        }];
+      },
+    });
+    const spec: ChartSpec = {
+      version: CHART_SPEC_VERSION,
+      viewport: { range: "1D", resolution: "5m" },
+      panels: [{ id: "main" }],
+      series: [{
+        id: "price",
+        source,
+        style: "candles",
+        transform: "raw",
+        axis: "left",
+        panelId: "main",
+        interpolation: "none",
+      }],
+      studies: [],
+    };
+
+    const result = await resolveChartSpecData(spec, {
+      dataProvider: provider,
+      now: new Date("2026-07-30T15:30:00Z"),
+      quoteOverrides: new Map([[
+        chartQuoteOverrideKeyForSource(source),
+        {
+          symbol: "SNDK",
+          price: 1_245,
+          currency: "USD",
+          change: 25,
+          changePercent: 2.05,
+          lastUpdated: Date.parse("2026-07-30T15:26:00Z"),
+        },
+      ]]),
+      loadFredSeries: async () => fredLoad(),
+    });
+
+    expect(result.errors).toEqual([]);
+    expect(historyExchanges).toEqual(["XNAS"]);
+    expect(result.series[0]?.points.at(-1)?.date.toISOString())
+      .toBe("2026-07-30T15:26:00.000Z");
+  });
+
+  test("resolves the exchange before selecting an adaptive Auto resolution", async () => {
+    const supportExchanges: string[] = [];
+    const historyRequests: Array<{ exchange: string; resolution: string }> = [];
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => ({
+        ...emptyFinancials(),
+        quote: {
+          symbol: "SNDK",
+          price: 1_240,
+          currency: "USD",
+          change: 20,
+          changePercent: 1.64,
+          lastUpdated: Date.parse("2026-07-30T15:25:00Z"),
+          listingExchangeName: "XNAS",
+        },
+      }),
+      getChartResolutionSupport: (_symbol, exchange) => {
+        supportExchanges.push(exchange);
+        return exchange === "XNAS"
+          ? [{ resolution: "5m", maxRange: "1W" }]
+          : [{ resolution: "1d", maxRange: "5Y" }];
+      },
+      getDetailedPriceHistory: async (_symbol, exchange, _start, _end, resolution) => {
+        historyRequests.push({ exchange, resolution });
+        return [{ date: new Date("2026-07-30T15:20:00Z"), close: 1_240 }];
+      },
+    });
+    const spec: ChartSpec = {
+      version: CHART_SPEC_VERSION,
+      viewport: { range: "1D", resolution: "auto" },
+      panels: [{ id: "main" }],
+      series: [{
+        id: "price",
+        source: {
+          kind: "security",
+          instrument: { symbol: "SNDK" },
+          fieldId: "market.close",
+        },
+        style: "line",
+        transform: "raw",
+        axis: "left",
+        panelId: "main",
+        interpolation: "none",
+      }],
+      studies: [],
+    };
+
+    const result = await resolveChartSpecData(
+      spec,
+      {
+        dataProvider: provider,
+        now: new Date("2026-07-30T15:30:00Z"),
+        loadFredSeries: async () => fredLoad(),
+      },
+      new ChartResolveCache(),
+      {
+        autoViewport: {
+          start: new Date("2026-07-30T09:30:00Z"),
+          end: new Date("2026-07-30T15:30:00Z"),
+        },
+        targetPointCount: 100,
+      },
+    );
+
+    expect(result.errors).toEqual([]);
+    expect(supportExchanges).toEqual(["XNAS"]);
+    expect(historyRequests).toEqual([{ exchange: "XNAS", resolution: "5m" }]);
+  });
+
   test("uses provider-default history as a valid fallback for Auto resolution", async () => {
     let genericHistoryCalls = 0;
     const provider = createTestDataProvider({
@@ -186,7 +325,7 @@ describe("resolveChartSpecData", () => {
     expect(requests).toEqual([{ range: "1W", resolution: "5m" }]);
   });
 
-  test("adapts Auto to a zoomed historical window without changing the authored viewport", async () => {
+  test("keeps Auto zoom selection while loading a separately panned history window", async () => {
     const detailedRequests: Array<{
       start: string;
       end: string;
@@ -238,6 +377,10 @@ describe("resolveChartSpecData", () => {
       new ChartResolveCache(),
       {
         autoViewport: {
+          start: new Date("2025-03-10T00:00:00.000Z"),
+          end: new Date("2025-03-17T00:00:00.000Z"),
+        },
+        requestViewport: {
           start: new Date("2025-01-10T00:00:00.000Z"),
           end: new Date("2025-01-17T00:00:00.000Z"),
         },
@@ -258,6 +401,64 @@ describe("resolveChartSpecData", () => {
     });
   });
 
+  test("keeps percent transforms and studies defined in a panned history window", async () => {
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => emptyFinancials(),
+      getDetailedPriceHistory: async () => [
+        { date: new Date("2024-10-15T16:00:00.000Z"), close: 100 },
+        { date: new Date("2024-10-16T16:00:00.000Z"), close: 110 },
+      ],
+    });
+    const spec: ChartSpec = {
+      version: CHART_SPEC_VERSION,
+      viewport: { range: "3M", resolution: "1d" },
+      panels: [{ id: "main" }],
+      series: [{
+        id: "price",
+        source: {
+          kind: "security",
+          instrument: { symbol: "TEST", exchange: "NASDAQ" },
+          fieldId: "market.close",
+        },
+        style: "line",
+        transform: "percent",
+        axis: "left",
+        panelId: "main",
+        interpolation: "none",
+      }],
+      studies: [{
+        id: "sma",
+        kind: "sma",
+        inputSeriesIds: ["price"],
+        parameters: { period: 2 },
+        panelId: "main",
+        axis: "left",
+      }],
+    };
+
+    const result = await resolveChartSpecData(
+      spec,
+      {
+        dataProvider: provider,
+        now: new Date("2025-04-01T00:00:00.000Z"),
+        loadFredSeries: async () => fredLoad(),
+      },
+      new ChartResolveCache(),
+      {
+        requestViewport: {
+          start: new Date("2024-10-10T00:00:00.000Z"),
+          end: new Date("2024-10-17T00:00:00.000Z"),
+        },
+      },
+    );
+
+    expect(result.errors).toEqual([]);
+    expect(result.bufferedSeries?.find((series) => series.id === "price")?.points.map((point) => point.value))
+      .toEqual([0, 10]);
+    expect(result.bufferedSeries?.find((series) => series.id === "sma")?.points.map((point) => point.value))
+      .toEqual([5]);
+  });
+
   test("resolves unrelated price, filed fundamental, and economic series on one chart", async () => {
     const provider = createTestDataProvider({
       getTickerFinancials: async (symbol) => symbol === "MSFT"
@@ -747,6 +948,7 @@ describe("resolveChartSpecData", () => {
     expect(result.series[0]?.points.map((point) => point.value)).toEqual([15, 25]);
     expect(result.legendSeries?.find((series) => series.id === "price")?.timeBasis)
       .toMatchObject({ kind: "market", timeZone: "America/New_York" });
+    expect(result.timelineSeries?.map((series) => series.id)).toEqual(["price"]);
     expect(result.series[0]?.timeBasis)
       .toMatchObject({ kind: "market", timeZone: "America/New_York" });
   });