gloomberb 0.11.2 → 0.11.3

package/src/plugins/builtin/ticker-detail/data-panes/historical-prices.tsx

@@ -9,7 +9,7 @@ import {
   type DataTableColumn,
   type DataTableKeyEvent,
 } from "../../../../components";
-import type { TimeRange } from "../../../../components/chart/core/types";
+import { TIME_RANGES, type TimeRange } from "../../../../time-series/range";
 import type { PaneProps } from "../../../../types/plugin";
 import type { PricePoint } from "../../../../types/financials";
 import { colors, priceColor } from "../../../../theme/colors";
@@ -33,8 +33,6 @@ export type HistoricalPriceRow = {
   changePercent: number | null;
 };
 
-const HISTORY_RANGES: TimeRange[] = ["1D", "1W", "1M", "3M", "6M", "1Y", "5Y", "ALL"];
-
 function pricePointDate(point: PricePoint): Date | null {
   const value = point.date as Date | string | number;
   const date = value instanceof Date ? value : new Date(value);
@@ -93,8 +91,8 @@ function buildHistoryColumns(width: number): HistoryColumn[] {
 }
 
 function nextHistoryRange(current: TimeRange): TimeRange {
-  const index = HISTORY_RANGES.indexOf(current);
-  return HISTORY_RANGES[(index + 1) % HISTORY_RANGES.length] ?? "1Y";
+  const index = TIME_RANGES.indexOf(current);
+  return TIME_RANGES[(index + 1) % TIME_RANGES.length] ?? "1Y";
 }
 
 export function HistoricalPricesPane({ focused, width, height }: PaneProps) {

package/src/plugins/builtin/ticker-detail/index.tsx

@@ -52,6 +52,7 @@ export const tickerDetailModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 98, height: 30 },
+      tableExport: true,
     },
     {
       id: "quote-monitor",
@@ -72,6 +73,7 @@ export const tickerDetailModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 92, height: 26 },
+      tableExport: true,
     },
     {
       id: "provider-search-results",

package/src/plugins/builtin/treasury-auctions/index.tsx

@@ -59,6 +59,7 @@ export const treasuryAuctionsModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 92, height: 28 },
+      tableExport: true,
       settings: treasuryAuctionsSettings(),
     },
   ],

package/src/plugins/builtin/world-indices/index.tsx

@@ -129,6 +129,7 @@ export const worldIndicesModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 96, height: 32 },
+      tableExport: true,
       // Resolved per open so the dialog shows the full board until the user
       // saves a narrower selection.
       settings: (context) => ({

package/src/plugins/builtin/world-venue-map/index.ts

@@ -0,0 +1,27 @@
+import type { PluginModule } from "../plugin-module";
+import { WORLD_VENUE_MAP_PANE_ID, WorldVenueMapPane } from "./pane";
+
+export const worldVenueMapModule: PluginModule = {
+  panes: [
+    {
+      id: WORLD_VENUE_MAP_PANE_ID,
+      name: "World Venue Map",
+      icon: "M",
+      component: WorldVenueMapPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 124, height: 36 },
+    },
+  ],
+  paneTemplates: [
+    {
+      id: "world-venue-map-pane",
+      paneId: WORLD_VENUE_MAP_PANE_ID,
+      label: "World Venue Map",
+      description: "Live trading venue status, local time, and exchange locations around the world.",
+      keywords: ["world", "map", "venue", "venues", "exchange", "mic", "market hours", "open markets"],
+      shortcut: { prefix: "MAP" },
+      createInstance: () => ({ placement: "floating" }),
+    },
+  ],
+};

package/src/plugins/builtin/world-venue-map/map.tsx

@@ -0,0 +1,337 @@
+import { createElement, useMemo, useRef } from "react";
+import type { CloudWorldVenuePayload } from "../../../api-client";
+import { ChartSurface, Text, useNativeRenderer, useUiHost } from "../../../ui";
+import { useThemeColors } from "../../../theme/theme-context";
+import { resolveNativeBitmapSize, shouldRenderNativeBitmap } from "../../../components/chart/native/bitmap-support";
+import { drawCircle, drawLine, fillOpaque, parseHex } from "../../../components/chart/native/raster/primitives";
+import type { NativeChartBitmap } from "../../../components/chart/native/chart-rasterizer";
+import { getLocalPlotPointer, type ChartMouseEvent } from "../../../components/chart/core/pointer";
+import {
+  closestWorldVenueCluster,
+  clusterWorldVenues,
+  projectWorldPoint,
+  type WorldVenueCluster,
+} from "./model";
+import { WORLD_OUTLINES } from "./world-outlines";
+
+interface WorldVenueMapProps {
+  venues: readonly CloudWorldVenuePayload[];
+  selectedMic: string | null;
+  width: number;
+  height: number;
+  onSelect: (venue: CloudWorldVenuePayload) => void;
+}
+
+function clusterVenue(cluster: WorldVenueCluster, selectedMic: string | null): CloudWorldVenuePayload {
+  return cluster.venues.find((venue) => venue.mic === selectedMic)
+    ?? cluster.venues.find((venue) => venue.isOpen)
+    ?? cluster.venues[0]!;
+}
+
+function isSelectedCluster(cluster: WorldVenueCluster, selectedMic: string | null): boolean {
+  return cluster.venues.some((venue) => venue.mic === selectedMic);
+}
+
+function drawWorldOutlines(
+  pixels: Uint8Array,
+  width: number,
+  height: number,
+  color: ReturnType<typeof parseHex>,
+  thickness: number,
+) {
+  for (const outline of WORLD_OUTLINES) {
+    for (let index = 1; index < outline.length; index += 1) {
+      const previous = outline[index - 1]!;
+      const current = outline[index]!;
+      if (previous[1] < -60 || current[1] < -60) continue;
+      const from = projectWorldPoint(previous[0], previous[1], width, height);
+      const to = projectWorldPoint(current[0], current[1], width, height);
+      if (Math.abs(to.x - from.x) > width / 2) continue;
+      drawLine(pixels, width, height, from.x, from.y, to.x, to.y, color, thickness);
+    }
+  }
+}
+
+const DIGITS: Record<string, readonly string[]> = {
+  "0": ["111", "101", "101", "101", "111"],
+  "1": ["010", "110", "010", "010", "111"],
+  "2": ["111", "001", "111", "100", "111"],
+  "3": ["111", "001", "111", "001", "111"],
+  "4": ["101", "101", "111", "001", "001"],
+  "5": ["111", "100", "111", "001", "111"],
+  "6": ["111", "100", "111", "101", "111"],
+  "7": ["111", "001", "010", "010", "010"],
+  "8": ["111", "101", "111", "101", "111"],
+  "9": ["111", "101", "111", "001", "111"],
+};
+
+function drawClusterCount(
+  bitmap: NativeChartBitmap,
+  x: number,
+  y: number,
+  count: number,
+  color: ReturnType<typeof parseHex>,
+  scale: number,
+) {
+  const value = String(count);
+  const glyphWidth = 3 * scale;
+  const gap = scale;
+  const totalWidth = value.length * glyphWidth + (value.length - 1) * gap;
+  const left = Math.round(x - (totalWidth - 1) / 2);
+  const top = Math.round(y - (5 * scale - 1) / 2);
+  for (let digitIndex = 0; digitIndex < value.length; digitIndex += 1) {
+    const glyph = DIGITS[value[digitIndex]!]!;
+    for (let row = 0; row < glyph.length; row += 1) {
+      for (let column = 0; column < 3; column += 1) {
+        if (glyph[row]![column] !== "1") continue;
+        const x0 = left + digitIndex * (glyphWidth + gap) + column * scale;
+        const y0 = top + row * scale;
+        for (let dy = 0; dy < scale; dy += 1) {
+          for (let dx = 0; dx < scale; dx += 1) {
+            const pixelX = x0 + dx;
+            const pixelY = y0 + dy;
+            if (pixelX < 0 || pixelY < 0 || pixelX >= bitmap.width || pixelY >= bitmap.height) continue;
+            const offset = (pixelY * bitmap.width + pixelX) * 4;
+            bitmap.pixels[offset] = color.r;
+            bitmap.pixels[offset + 1] = color.g;
+            bitmap.pixels[offset + 2] = color.b;
+            bitmap.pixels[offset + 3] = color.a;
+          }
+        }
+      }
+    }
+  }
+}
+
+function renderWorldBitmap(
+  venues: readonly CloudWorldVenuePayload[],
+  selectedMic: string | null,
+  width: number,
+  height: number,
+  colors: ReturnType<typeof useThemeColors>,
+): NativeChartBitmap {
+  const bitmap = { width, height, pixels: new Uint8Array(width * height * 4) };
+  fillOpaque(bitmap.pixels, parseHex(colors.bg));
+  drawWorldOutlines(bitmap.pixels, width, height, parseHex(colors.textDim, 0.62), Math.max(1, width / 900));
+
+  const clusters = clusterWorldVenues(venues, width, height);
+  for (const cluster of clusters) {
+    const selected = isSelectedCluster(cluster, selectedMic);
+    const radius = Math.max(3, Math.min(14, 3 + Math.sqrt(cluster.venues.length) * 1.7));
+    if (selected) {
+      drawCircle(bitmap.pixels, width, height, cluster.x, cluster.y, radius + 2.5, parseHex(colors.selectedText));
+    }
+    drawCircle(
+      bitmap.pixels,
+      width,
+      height,
+      cluster.x,
+      cluster.y,
+      radius,
+      parseHex(cluster.isOpen ? colors.positive : colors.textMuted),
+    );
+    if (cluster.venues.length > 1) {
+      drawClusterCount(bitmap, cluster.x, cluster.y, cluster.venues.length, parseHex(colors.bg), width >= 700 ? 2 : 1);
+    }
+  }
+  return bitmap;
+}
+
+function renderAsciiMap(
+  venues: readonly CloudWorldVenuePayload[],
+  selectedMic: string | null,
+  width: number,
+  height: number,
+  cellAspect: number,
+): string[] {
+  const grid = Array.from({ length: height }, () => Array.from({ length: width }, () => " "));
+  for (const outline of WORLD_OUTLINES) {
+    for (const coordinate of outline) {
+      const point = projectWorldPoint(coordinate[0], coordinate[1], width, height, cellAspect);
+      const x = Math.round(point.x);
+      const y = Math.round(point.y);
+      if (grid[y]?.[x] === " ") grid[y]![x] = ".";
+    }
+  }
+  for (const cluster of clusterWorldVenues(venues, width, height, cellAspect)) {
+    const x = Math.round(cluster.x);
+    const y = Math.round(cluster.y);
+    grid[y]![x] = isSelectedCluster(cluster, selectedMic)
+      ? "@"
+      : cluster.venues.length > 1
+        ? String(Math.min(cluster.venues.length, 9))
+        : cluster.isOpen ? "O" : "o";
+  }
+  return grid.map((row) => row.join(""));
+}
+
+function TerminalWorldVenueMap(props: WorldVenueMapProps) {
+  const colors = useThemeColors();
+  const renderer = useNativeRenderer();
+  const surfaceRef = useRef<any>(null);
+  const { nativeCharts, cellWidthPx = 8, cellHeightPx = 18, pixelRatio = 1 } = useUiHost().capabilities ?? {};
+  const rendererCapabilities = renderer.capabilities;
+  const rendererResolution = renderer.resolution;
+  const rendererTerminalWidth = renderer.terminalWidth;
+  const rendererTerminalHeight = renderer.terminalHeight;
+  const bitmap = useMemo(() => {
+    if (!shouldRenderNativeBitmap(renderer, nativeCharts === true)) return null;
+    const size = resolveNativeBitmapSize({
+      width: props.width,
+      height: props.height,
+      resolution: rendererResolution,
+      terminalWidth: rendererTerminalWidth,
+      terminalHeight: rendererTerminalHeight,
+      cellWidthPx,
+      cellHeightPx,
+      pixelRatio,
+    });
+    return renderWorldBitmap(props.venues, props.selectedMic, size.pixelWidth, size.pixelHeight, colors);
+  }, [
+    cellHeightPx,
+    cellWidthPx,
+    colors,
+    nativeCharts,
+    pixelRatio,
+    props.height,
+    props.selectedMic,
+    props.venues,
+    props.width,
+    renderer,
+    rendererCapabilities,
+    rendererResolution,
+    rendererTerminalHeight,
+    rendererTerminalWidth,
+  ]);
+  const cellAspect = cellHeightPx / Math.max(cellWidthPx, 1);
+  const clusters = useMemo(
+    () => clusterWorldVenues(props.venues, props.width, props.height, cellAspect),
+    [cellAspect, props.height, props.venues, props.width],
+  );
+  const ascii = useMemo(
+    () => renderAsciiMap(props.venues, props.selectedMic, props.width, props.height, cellAspect),
+    [cellAspect, props.height, props.selectedMic, props.venues, props.width],
+  );
+
+  const selectAt = (event: ChartMouseEvent) => {
+    const pointer = getLocalPlotPointer(event, surfaceRef.current, renderer);
+    if (!pointer) return;
+    const cluster = closestWorldVenueCluster(clusters, pointer.cellX, pointer.cellY, 4);
+    if (cluster) props.onSelect(clusterVenue(cluster, props.selectedMic));
+  };
+
+  return (
+    <ChartSurface
+      ref={surfaceRef}
+      width={props.width}
+      height={props.height}
+      flexDirection="column"
+      bitmaps={bitmap ? [bitmap] : null}
+      onMouseDown={selectAt}
+      data-gloom-role="world-venue-map"
+      aria-label="World venue map"
+    >
+      {ascii.map((line, index) => <Text key={index} fg={colors.textDim}>{line}</Text>)}
+    </ChartSurface>
+  );
+}
+
+function DesktopWorldVenueMap(props: WorldVenueMapProps) {
+  const colors = useThemeColors();
+  // Desktop rows are roughly twice as tall as they are wide. Matching the SVG
+  // view box to those pixels lets the contained world projection keep its shape.
+  const plotHeight = props.height * 2.12;
+  const clusters = useMemo(
+    () => clusterWorldVenues(props.venues, props.width, plotHeight),
+    [plotHeight, props.venues, props.width],
+  );
+
+  const outlinePath = (outline: (typeof WORLD_OUTLINES)[number]) => {
+    let drawing = false;
+    let previousLongitude: number | null = null;
+    return outline.map(([longitude, latitude]) => {
+      if (latitude < -60 || (previousLongitude != null && Math.abs(longitude - previousLongitude) > 180)) {
+        drawing = false;
+        previousLongitude = longitude;
+        return "";
+      }
+      const point = projectWorldPoint(longitude, latitude, props.width, plotHeight);
+      previousLongitude = longitude;
+      const command = drawing ? "L" : "M";
+      drawing = true;
+      return `${command}${point.x.toFixed(2)} ${point.y.toFixed(2)}`;
+    }).join(" ");
+  };
+
+  return (
+    <svg
+      viewBox={`0 0 ${props.width} ${plotHeight}`}
+      width="100%"
+      height="100%"
+      role="img"
+      aria-label="World venue map"
+      style={{ display: "block", background: colors.bg }}
+    >
+      {WORLD_OUTLINES.map((outline, index) => (
+        <path
+          key={index}
+          d={outlinePath(outline)}
+          fill="none"
+          stroke={colors.textDim}
+          strokeOpacity="0.64"
+          strokeWidth="0.55"
+          vectorEffect="non-scaling-stroke"
+        />
+      ))}
+      {clusters.map((cluster) => {
+        const selected = isSelectedCluster(cluster, props.selectedMic);
+        const venue = clusterVenue(cluster, props.selectedMic);
+        const radius = Math.max(0.55, Math.min(1.5, 0.45 + Math.sqrt(cluster.venues.length) * 0.22));
+        return (
+          <g
+            key={cluster.id}
+            role="button"
+            tabIndex={0}
+            aria-label={`${cluster.venues.length} venues near ${venue.city}`}
+            style={{ cursor: "pointer" }}
+            onMouseDown={(event) => {
+              event.stopPropagation();
+              props.onSelect(venue);
+            }}
+            onKeyDown={(event) => {
+              if (event.key === "Enter" || event.key === " ") props.onSelect(venue);
+            }}
+          >
+            <title>{`${cluster.venues.length} venue${cluster.venues.length === 1 ? "" : "s"} near ${venue.city}: ${cluster.venues.map((item) => `${item.mic} ${item.name}`).join(", ")}`}</title>
+            <circle
+              cx={cluster.x}
+              cy={cluster.y}
+              r={radius + (selected ? 0.24 : 0)}
+              fill={cluster.isOpen ? colors.positive : colors.textMuted}
+              stroke={selected ? colors.selectedText : colors.bg}
+              strokeWidth={selected ? 0.35 : 0.16}
+              vectorEffect="non-scaling-stroke"
+            />
+            {cluster.venues.length > 1 ? createElement("text", {
+              x: cluster.x,
+              y: cluster.y,
+              fill: colors.bg,
+              dy: "0.34em",
+              fontSize: Math.max(0.62, Math.min(0.95, radius * 0.78)),
+              fontWeight: "700",
+              fontFamily: "inherit",
+              textAnchor: "middle",
+              pointerEvents: "none",
+            }, cluster.venues.length) : null}
+          </g>
+        );
+      })}
+    </svg>
+  );
+}
+
+export function WorldVenueMap(props: WorldVenueMapProps) {
+  return useUiHost().kind === "desktop-web"
+    ? <DesktopWorldVenueMap {...props} />
+    : <TerminalWorldVenueMap {...props} />;
+}

package/src/plugins/builtin/world-venue-map/model.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import type { CloudWorldVenuePayload } from "../../../api-client";
+import {
+  clusterWorldVenues,
+  filterWorldVenues,
+  projectWorldPoint,
+  venueRemainingSeconds,
+} from "./model";
+
+function venue(overrides: Partial<CloudWorldVenuePayload>): CloudWorldVenuePayload {
+  return {
+    mic: "XNYS",
+    name: "NYSE",
+    title: "New York Stock Exchange",
+    country: "United States",
+    countryCode: "US",
+    city: "New York",
+    timezone: "America/New_York",
+    latitude: 40.7127,
+    longitude: -74.006,
+    isOpen: false,
+    ...overrides,
+  };
+}
+
+describe("world venue map model", () => {
+  test("projects, clusters, filters, and advances server countdowns", () => {
+    expect(projectWorldPoint(-180, 85, 361, 146)).toEqual({ x: 0, y: 0 });
+    expect(projectWorldPoint(180, -60, 361, 146)).toEqual({ x: 360, y: 145 });
+
+    const tallTopLeft = projectWorldPoint(-180, 85, 101, 101);
+    const tallBottomRight = projectWorldPoint(180, -60, 101, 101);
+    expect(tallTopLeft.x).toBe(0);
+    expect(tallBottomRight.x).toBe(100);
+    expect(100 / (tallBottomRight.y - tallTopLeft.y)).toBeCloseTo(360 / 145);
+
+    const terminalTopLeft = projectWorldPoint(-180, 85, 101, 51, 2);
+    const terminalBottomRight = projectWorldPoint(180, -60, 101, 51, 2);
+    expect(100 / ((terminalBottomRight.y - terminalTopLeft.y) * 2)).toBeCloseTo(360 / 145);
+
+    const rows = [
+      venue({ mic: "XNYS", timeToOpenSeconds: 3_600 }),
+      venue({ mic: "XASE", name: "NYSE American", isOpen: true, timeToCloseSeconds: 7_200 }),
+      venue({ mic: "XLON", name: "London Stock Exchange", title: "London Stock Exchange", city: "London", country: "United Kingdom", countryCode: "GB", longitude: -0.1278, latitude: 51.5074 }),
+    ];
+
+    const clusters = clusterWorldVenues(rows, 80, 24);
+    expect(clusters.find((cluster) => cluster.venues.some((item) => item.mic === "XNYS"))?.venues).toHaveLength(2);
+    expect(filterWorldVenues(rows, "london").map((item) => item.mic)).toEqual(["XLON"]);
+    expect(filterWorldVenues(rows, "")[0]?.mic).toBe("XASE");
+    expect(venueRemainingSeconds(rows[0]!, 1_000, 61_000)).toBe(3_540);
+  });
+});

package/src/plugins/builtin/world-venue-map/model.ts

@@ -0,0 +1,147 @@
+import type { CloudWorldVenuePayload } from "../../../api-client";
+
+export interface WorldMapPoint {
+  x: number;
+  y: number;
+}
+
+export interface WorldVenueCluster extends WorldMapPoint {
+  id: string;
+  venues: CloudWorldVenuePayload[];
+  isOpen: boolean;
+}
+
+const MAX_LATITUDE = 85;
+const MIN_LATITUDE = -60;
+
+export function projectWorldPoint(
+  longitude: number,
+  latitude: number,
+  width: number,
+  height: number,
+  yUnitAspect = 1,
+): WorldMapPoint {
+  const availableWidth = Math.max(width - 1, 0);
+  const availableHeight = Math.max(height - 1, 0);
+  const unitAspect = Math.max(yUnitAspect, Number.EPSILON);
+  const effectiveHeight = availableHeight * unitAspect;
+  const latitudeSpan = MAX_LATITUDE - MIN_LATITUDE;
+  const scale = Math.min(availableWidth / 360, effectiveHeight / latitudeSpan);
+  const mapWidth = 360 * scale;
+  const mapHeight = latitudeSpan * scale;
+  const clampedLatitude = Math.max(MIN_LATITUDE, Math.min(MAX_LATITUDE, latitude));
+
+  return {
+    x: (availableWidth - mapWidth) / 2 + (longitude + 180) * scale,
+    y: ((effectiveHeight - mapHeight) / 2 + (MAX_LATITUDE - clampedLatitude) * scale) / unitAspect,
+  };
+}
+
+export function clusterWorldVenues(
+  venues: readonly CloudWorldVenuePayload[],
+  width: number,
+  height: number,
+  yUnitAspect = 1,
+): WorldVenueCluster[] {
+  const buckets = new Map<string, CloudWorldVenuePayload[]>();
+  const cellWidth = Math.max(4, Math.round(width / 18));
+  const cellHeight = Math.max(2, Math.round(height / 12));
+
+  for (const venue of venues) {
+    const point = projectWorldPoint(venue.longitude, venue.latitude, width, height, yUnitAspect);
+    const key = `${Math.floor(point.x / cellWidth)}:${Math.floor(point.y / cellHeight)}`;
+    const bucket = buckets.get(key) ?? [];
+    bucket.push(venue);
+    buckets.set(key, bucket);
+  }
+
+  return [...buckets.entries()].map(([id, grouped]) => {
+    const point = grouped.reduce(
+      (sum, venue) => {
+        const projected = projectWorldPoint(venue.longitude, venue.latitude, width, height, yUnitAspect);
+        return { x: sum.x + projected.x, y: sum.y + projected.y };
+      },
+      { x: 0, y: 0 },
+    );
+    return {
+      id,
+      x: point.x / grouped.length,
+      y: point.y / grouped.length,
+      venues: grouped,
+      isOpen: grouped.some((venue) => venue.isOpen),
+    };
+  });
+}
+
+export function filterWorldVenues(
+  venues: readonly CloudWorldVenuePayload[],
+  query: string,
+): CloudWorldVenuePayload[] {
+  const normalized = query.trim().toLocaleLowerCase();
+  return venues
+    .filter((venue) => !normalized || [
+      venue.mic,
+      venue.name,
+      venue.title,
+      venue.city,
+      venue.country,
+      venue.countryCode,
+    ].some((value) => value.toLocaleLowerCase().includes(normalized)))
+    .sort((left, right) => Number(right.isOpen) - Number(left.isOpen)
+      || left.name.localeCompare(right.name)
+      || left.mic.localeCompare(right.mic));
+}
+
+export function closestWorldVenueCluster(
+  clusters: readonly WorldVenueCluster[],
+  x: number,
+  y: number,
+  maxDistance: number,
+): WorldVenueCluster | null {
+  let closest: WorldVenueCluster | null = null;
+  let distance = maxDistance;
+  for (const cluster of clusters) {
+    const next = Math.hypot(cluster.x - x, cluster.y - y);
+    if (next <= distance) {
+      closest = cluster;
+      distance = next;
+    }
+  }
+  return closest;
+}
+
+const localTimeFormatters = new Map<string, Intl.DateTimeFormat>();
+
+export function formatVenueLocalTime(timezone: string, now: number): string {
+  let formatter = localTimeFormatters.get(timezone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-GB", {
+      timeZone: timezone,
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23",
+    });
+    localTimeFormatters.set(timezone, formatter);
+  }
+  return formatter.format(now);
+}
+
+export function venueRemainingSeconds(
+  venue: CloudWorldVenuePayload,
+  checkedAt: number,
+  now: number,
+): number | null {
+  const source = venue.isOpen ? venue.timeToCloseSeconds : venue.timeToOpenSeconds;
+  if (source == null) return null;
+  return Math.max(0, source - Math.floor((now - checkedAt) / 1_000));
+}
+
+export function formatVenueCountdown(seconds: number | null): string {
+  if (seconds == null) return "";
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.ceil(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainder = minutes % 60;
+  return remainder ? `${hours}h ${remainder}m` : `${hours}h`;
+}