gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/shared/auto-refresh.ts

@@ -1,97 +0,0 @@
-import { useEffect, useRef, useState } from "react";
-import { usePaneVisible } from "../../../state/app/activity";
-import { useAppSelector } from "../../../state/app/context";
-import { formatRelativeAge } from "../../../utils/relative-time";
-
-/** The label only changes once a minute, so a coarse tick is enough. */
-export const AGE_TICK_MS = 30_000;
-
-/**
- * How old a pane's data is, as a footer-ready label that keeps ageing on its
- * own. Returns null before the first successful load so callers can leave the
- * footer empty instead of claiming a freshness they do not have. The clock
- * rests while the pane cannot be seen and catches up when it can.
- */
-export function useUpdatedAgo(lastUpdated: number | null): string | null {
-  const visible = usePaneVisible();
-  const [now, setNow] = useState(() => Date.now());
-
-  useEffect(() => {
-    if (!lastUpdated || !visible) return;
-    setNow(Date.now());
-    const timer = setInterval(() => setNow(Date.now()), AGE_TICK_MS);
-    return () => clearInterval(timer);
-  }, [lastUpdated, visible]);
-
-  return lastUpdated ? formatRelativeAge(lastUpdated, now) : null;
-}
-
-export interface AutoRefreshOptions {
-  /**
-   * Cadence for a pane whose data moves faster than research data, such as a
-   * delayed curve during its session. Omitted, or not a positive number, the
-   * pane follows the refresh interval the user configured.
-   */
-  intervalMs?: number | null;
-}
-
-/**
- * When the next automatic refresh is due: one interval after the newer of the
- * last good data and the last attempt this hook made. Counting from the last
- * attempt is what stops a dead endpoint from turning into a retry storm.
- */
-function nextAutoRefreshAt(
-  lastUpdated: number | null,
-  lastAttemptAt: number,
-  intervalMs: number,
-): number {
-  return Math.max(lastUpdated ?? Number.NEGATIVE_INFINITY, lastAttemptAt) + intervalMs;
-}
-
-/**
- * Re-pull a pane once its data is one interval old, so network panes follow
- * the one cadence the user already configured instead of each hardcoding its
- * own. Callers that know their data moves faster pass `intervalMs`.
- *
- * Each refresh is scheduled from `lastUpdated` rather than on a free-running
- * timer, so data never ages to twice the interval. The clock rests while the
- * pane cannot be seen (the app is hidden or the pane is covered) and, once it
- * can, data that came due meanwhile refreshes at once. Pass `null` for data
- * that has never loaded or that the pane already treats as stale: the hook
- * then retries one interval after its last attempt. Mounting counts as an
- * attempt, because a pane loads its data on mount.
- */
-export function useAutoRefresh(
-  lastUpdated: number | null,
-  refresh: () => void,
-  options: AutoRefreshOptions = {},
-): void {
-  const intervalMinutes = useAppSelector((state) => state.config.refreshIntervalMinutes);
-  const visible = usePaneVisible();
-  const refreshRef = useRef(refresh);
-  refreshRef.current = refresh;
-  const lastAttemptRef = useRef(Date.now());
-  const intervalMs = options.intervalMs != null && options.intervalMs > 0
-    ? options.intervalMs
-    : intervalMinutes > 0 ? intervalMinutes * 60_000 : 0;
-
-  useEffect(() => {
-    if (!(intervalMs > 0) || !visible) return;
-    let timer: ReturnType<typeof setTimeout> | null = null;
-    const schedule = () => {
-      const delay = nextAutoRefreshAt(lastUpdated, lastAttemptRef.current, intervalMs) - Date.now();
-      timer = setTimeout(() => {
-        timer = null;
-        lastAttemptRef.current = Date.now();
-        refreshRef.current();
-        // A successful load moves `lastUpdated` and reschedules through the
-        // effect; a failed one waits a full interval from this attempt.
-        schedule();
-      }, Math.max(0, delay));
-    };
-    schedule();
-    return () => {
-      if (timer) clearTimeout(timer);
-    };
-  }, [intervalMs, lastUpdated, visible]);
-}

package/src/plugins/builtin/shared/live-streaming.ts

@@ -1,60 +0,0 @@
-import { useAppSelector, usePaneInstanceId } from "../../../state/app/context";
-import { findPaneInstance, type LayoutConfig } from "../../../types/config";
-import type {
-  PaneQuickSettingDef,
-  PaneSettingField,
-  PaneSettingsDef,
-} from "../../../types/plugin";
-
-export const LIVE_STREAMING_SETTING_KEY = "liveStreaming";
-
-export const LIVE_STREAMING_QUICK_SETTING: PaneQuickSettingDef = {
-  type: "toggle",
-  key: LIVE_STREAMING_SETTING_KEY,
-  icon: "zap",
-};
-
-export const LIVE_STREAMING_SETTING_FIELD: PaneSettingField = {
-  type: "toggle",
-  key: LIVE_STREAMING_SETTING_KEY,
-  label: "Live streaming",
-  description: "Stream quote updates continuously. Turn off to refresh quotes once per minute. Follow panes inherit their source pane's setting.",
-};
-
-export function withLiveStreamingSetting(
-  settingsDef: PaneSettingsDef,
-  settings: Record<string, unknown> | undefined,
-): PaneSettingsDef {
-  return {
-    ...settingsDef,
-    values: {
-      ...settingsDef.values,
-      [LIVE_STREAMING_SETTING_KEY]: settings?.[LIVE_STREAMING_SETTING_KEY] !== false,
-    },
-    fields: [
-      ...settingsDef.fields.filter((field) => field.key !== LIVE_STREAMING_SETTING_KEY),
-      LIVE_STREAMING_SETTING_FIELD,
-    ],
-  };
-}
-
-export function resolveLiveStreamingSetting(
-  layout: LayoutConfig,
-  paneId: string,
-  seen = new Set<string>(),
-): boolean {
-  if (seen.has(paneId)) return false;
-
-  const pane = findPaneInstance(layout, paneId);
-  if (!pane) return true;
-  if (pane.settings?.[LIVE_STREAMING_SETTING_KEY] === false) return false;
-  if (pane.binding?.kind !== "follow") return true;
-
-  seen.add(paneId);
-  return resolveLiveStreamingSetting(layout, pane.binding.sourceInstanceId, seen);
-}
-
-export function useLiveStreamingSetting(): boolean {
-  const paneId = usePaneInstanceId();
-  return useAppSelector((state) => resolveLiveStreamingSetting(state.config.layout, paneId));
-}

package/src/plugins/builtin/shared/pane-footer.ts

@@ -1,93 +0,0 @@
-import { useMemo } from "react";
-// Deep imports on purpose: the components barrel re-exports this module for
-// plugins, and importing the barrel back would make a cycle.
-import { usePaneFooter, type PaneFooterSegment, type PaneHint } from "../../../components/layout/pane/footer";
-import { useExternalLinkFooter } from "../../../components/use-external-link-footer";
-
-const EMPTY_STATUS_INFO: PaneFooterSegment[] = [];
-
-// `r` refreshes every pane, so it is global product knowledge and deliberately
-// has no per-pane footer hint. Do not reintroduce one. See PR #589.
-
-function buildPaneStatusInfo({
-  loading = false,
-  error,
-  info = EMPTY_STATUS_INFO,
-}: {
-  loading?: boolean;
-  error?: string | null;
-  info?: readonly PaneFooterSegment[];
-}): PaneFooterSegment[] {
-  return [
-    ...info,
-    ...(loading ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
-    ...(error ? [{ id: "error", parts: [{ text: error, tone: "warning" as const }] }] : []),
-  ];
-}
-
-export function usePaneStatusFooter({
-  registrationId,
-  loading = false,
-  error,
-  info = EMPTY_STATUS_INFO,
-  hints,
-  enabled = true,
-}: {
-  registrationId: string;
-  loading?: boolean;
-  error?: string | null;
-  info?: readonly PaneFooterSegment[];
-  hints?: PaneHint[];
-  enabled?: boolean;
-}) {
-  const statusInfo = useMemo(
-    () => buildPaneStatusInfo({ loading, error, info }),
-    [error, info, loading],
-  );
-  usePaneFooter(
-    registrationId,
-    () => enabled && (statusInfo.length > 0 || (hints?.length ?? 0) > 0)
-      ? { info: statusInfo, hints }
-      : null,
-    [enabled, hints, registrationId, statusInfo],
-  );
-}
-
-export function usePaneStatusLinkFooter({
-  registrationId,
-  focused,
-  url,
-  source,
-  label,
-  loading = false,
-  error,
-  info = EMPTY_STATUS_INFO,
-  hints,
-  showOpenHint = false,
-}: {
-  registrationId: string;
-  focused: boolean;
-  url: string | null | undefined;
-  source?: string | null;
-  label?: string;
-  loading?: boolean;
-  error?: string | null;
-  info?: readonly PaneFooterSegment[];
-  hints?: PaneHint[];
-  showOpenHint?: boolean;
-}) {
-  const statusInfo = useMemo(
-    () => buildPaneStatusInfo({ loading, error, info }),
-    [error, info, loading],
-  );
-  return useExternalLinkFooter({
-    registrationId,
-    focused,
-    url,
-    source,
-    label,
-    info: statusInfo,
-    hints,
-    showHint: showOpenHint,
-  });
-}

package/src/plugins/builtin/shared/plan-access.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { resolvePlanAccess, type PlanAccessUser } from "./plan-access";
-
-const NOW = Date.parse("2026-08-04T12:00:00.000Z");
-const HOUR = 60 * 60 * 1000;
-const DAY = 24 * HOUR;
-
-function user(overrides: Partial<PlanAccessUser> = {}): PlanAccessUser {
-  return { emailVerified: true, plan: "free", ...overrides };
-}
-
-describe("plan access", () => {
-  test("rounds trial days up so the final hours still read as a day left", () => {
-    const cases: Array<[number, number]> = [
-      [7 * DAY, 7],
-      [6 * DAY + HOUR, 7],
-      [DAY, 1],
-      [HOUR, 1],
-      [60_000, 1],
-    ];
-    for (const [remaining, expected] of cases) {
-      const access = resolvePlanAccess(
-        user({ trialEndsAt: new Date(NOW + remaining).toISOString(), effectivePlan: "pro" }),
-        NOW,
-      );
-      expect(access.isTrialActive).toBe(true);
-      expect(access.hasProAccess).toBe(true);
-      expect(access.trialDaysLeft).toBe(expected);
-    }
-  });
-
-  test("drops Pro access the moment the trial clock runs out, even on a stale effectivePlan", () => {
-    const lapsed = resolvePlanAccess(
-      user({ trialEndsAt: new Date(NOW - 1).toISOString(), effectivePlan: "pro" }),
-      NOW,
-    );
-    expect(lapsed).toMatchObject({ hasProAccess: false, isTrialActive: false, trialDaysLeft: 0 });
-  });
-
-  test("treats plan pro with a live trialEndsAt as a card-backed trial, not a paying pro", () => {
-    // The server only sends trialEndsAt while the subscription is actually
-    // trialing, so plan "pro" + trialEndsAt = Stripe trial in progress.
-    const trialing = resolvePlanAccess(
-      user({ plan: "pro", effectivePlan: "pro", trialEndsAt: new Date(NOW + DAY).toISOString() }),
-      NOW,
-    );
-    expect(trialing).toMatchObject({
-      hasProAccess: true,
-      isPayingPro: false,
-      isTrialActive: true,
-      trialDaysLeft: 1,
-    });
-  });
-
-  test("treats plan pro without trialEndsAt as a paying pro", () => {
-    const paid = resolvePlanAccess(user({ plan: "pro", effectivePlan: "pro" }), NOW);
-    expect(paid).toMatchObject({ hasProAccess: true, isPayingPro: true, isTrialActive: false });
-  });
-
-  test("requires a verified email and falls back to the legacy plan field", () => {
-    expect(resolvePlanAccess(
-      user({ emailVerified: false, effectivePlan: "pro", trialEndsAt: new Date(NOW + DAY).toISOString() }),
-      NOW,
-    ).hasProAccess).toBe(false);
-    // Sessions from a server without effectivePlan still resolve.
-    expect(resolvePlanAccess({ emailVerified: true, plan: "pro" }, NOW).hasProAccess).toBe(true);
-    expect(resolvePlanAccess(null, NOW)).toMatchObject({ signedIn: false, hasProAccess: false });
-  });
-});

package/src/plugins/builtin/shared/plan-access.ts

@@ -1,109 +0,0 @@
-import { useSyncExternalStore } from "react";
-import { apiClient } from "../../../api-client";
-
-/**
- * Minimum shape the plan helpers need. Both `AuthUser` (from `/auth/get-session`)
- * and `AccountProfile` (from `/account/profile`) satisfy it.
- */
-export interface PlanAccessUser {
-  emailVerified?: boolean;
-  plan?: "free" | "pro" | null;
-  /** Server-computed entitlement: "pro" while a trial runs or a subscription is active. */
-  effectivePlan?: "free" | "pro" | null;
-  /** ISO timestamp the free Pro trial ends; null once it lapsed or never started. */
-  trialEndsAt?: string | null;
-}
-
-export interface PlanAccess {
-  signedIn: boolean;
-  /** Signed in *and* verified, i.e. account-gated cloud features will answer. */
-  emailVerified: boolean;
-  /** Real-time entitlement right now: paying subscriber or an active trial. */
-  hasProAccess: boolean;
-  /** Paying subscriber, i.e. an upgrade CTA is no longer relevant. */
-  isPayingPro: boolean;
-  isTrialActive: boolean;
-  /** Whole days remaining, rounded up; 1 on the final day, 0 when no trial runs. */
-  trialDaysLeft: number;
-  trialEndsAt: Date | null;
-}
-
-/** Delay the cloud applies to free-tier equity and options quotes. */
-export const CLOUD_QUOTE_DELAY_MINUTES = 15;
-/** Delay the cloud applies to free-tier news wire articles. */
-export const CLOUD_NEWS_DELAY_HOURS = 12;
-
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-
-export function resolveTrialEndsAt(user: PlanAccessUser | null | undefined): Date | null {
-  if (!user?.trialEndsAt) return null;
-  const endsAt = new Date(user.trialEndsAt);
-  return Number.isNaN(endsAt.getTime()) ? null : endsAt;
-}
-
-export function isTrialActive(user: PlanAccessUser | null | undefined, now = Date.now()): boolean {
-  if (user?.emailVerified !== true) return false;
-  // Card-backed trials run as plan "pro" with a trialing subscription; the server
-  // only sends `trialEndsAt` while the subscription is actually in its trial.
-  const endsAt = resolveTrialEndsAt(user);
-  return !!endsAt && endsAt.getTime() > now;
-}
-
-export function trialDaysLeft(user: PlanAccessUser | null | undefined, now = Date.now()): number {
-  const endsAt = resolveTrialEndsAt(user);
-  if (!endsAt) return 0;
-  const remainingMs = endsAt.getTime() - now;
-  if (remainingMs <= 0) return 0;
-  return Math.max(1, Math.ceil(remainingMs / MS_PER_DAY));
-}
-
-/**
- * Whether the account is entitled to real-time cloud data. `effectivePlan` is the
- * server's answer, but the trial clock is re-checked locally so a session captured
- * before the trial lapsed cannot keep claiming Pro. Sessions from older servers
- * (no `effectivePlan`) fall back to the legacy verified-and-paid check.
- */
-export function hasProAccess(user: PlanAccessUser | null | undefined, now = Date.now()): boolean {
-  if (user?.emailVerified !== true) return false;
-  if (user.plan === "pro") return true;
-  if (isTrialActive(user, now)) return true;
-  return user.effectivePlan === "pro" && !user.trialEndsAt;
-}
-
-export function resolvePlanAccess(
-  user: PlanAccessUser | null | undefined,
-  now = Date.now(),
-): PlanAccess {
-  const trialActive = isTrialActive(user, now);
-  return {
-    signedIn: !!user,
-    emailVerified: user?.emailVerified === true,
-    hasProAccess: hasProAccess(user, now),
-    isPayingPro: user?.emailVerified === true && user.plan === "pro" && !trialActive,
-    isTrialActive: trialActive,
-    trialDaysLeft: trialActive ? trialDaysLeft(user, now) : 0,
-    trialEndsAt: resolveTrialEndsAt(user),
-  };
-}
-
-function planAccessKey(): string {
-  const user = apiClient.getCurrentUser();
-  if (!user) return "anonymous";
-  return [
-    user.id,
-    user.emailVerified === true ? "verified" : "unverified",
-    user.plan ?? "",
-    user.effectivePlan ?? "",
-    user.trialEndsAt ?? "",
-  ].join(":");
-}
-
-/** Plan state of the signed-in cloud session, refreshed whenever the session changes. */
-export function usePlanAccess(): PlanAccess {
-  useSyncExternalStore(
-    (onChange) => apiClient.subscribeCurrentUser(onChange),
-    planAccessKey,
-    planAccessKey,
-  );
-  return resolvePlanAccess(apiClient.getCurrentUser());
-}

package/src/plugins/builtin/shared/public-pane.test.ts

@@ -1,12 +0,0 @@
-import { expect, test } from "bun:test";
-import { createPublicPaneShare } from "./public-pane";
-
-test("default public pane shares restore no user-owned state", () => {
-  const adapter = createPublicPaneShare("World Equity Indices");
-  expect(adapter.serialize({
-    pane: { instanceId: "world", paneId: "world-indices", settings: { symbols: ["private"] } },
-    paneState: { selectedIndex: 2 },
-  })).toEqual({ title: "World Equity Indices", data: {} });
-  expect(adapter.restore({})).toEqual({});
-  expect(adapter.restore({ token: "secret" })).toBeNull();
-});

package/src/plugins/builtin/shared/read-state.ts

@@ -1,104 +0,0 @@
-import { useCallback, useMemo } from "react";
-import { usePluginState } from "../../runtime";
-
-export const DEFAULT_MAX_READ_IDS = 2_000;
-
-export interface PersistedReadIdAdapter<TState> {
-  getIds(state: TState): readonly unknown[] | undefined;
-  withIds(state: TState, ids: string[]): TState;
-  maxIds?: number;
-}
-
-interface UsePersistedReadIdsOptions<TState> {
-  key: string;
-  fallback: TState;
-  schemaVersion: number;
-  adapter: PersistedReadIdAdapter<TState>;
-}
-
-function normalizeReadId(readId: unknown): string {
-  return typeof readId === "string" ? readId.trim() : "";
-}
-
-function sameStringArray(left: readonly string[], right: readonly unknown[]): boolean {
-  if (left.length !== right.length) return false;
-  return left.every((value, index) => value === right[index]);
-}
-
-function normalizeReadIds(
-  readIds: readonly unknown[] | undefined,
-  maxIds = DEFAULT_MAX_READ_IDS,
-): string[] {
-  const seen = new Set<string>();
-  const normalizedIds: string[] = [];
-
-  for (const rawId of readIds ?? []) {
-    const readId = normalizeReadId(rawId);
-    if (!readId || seen.has(readId)) continue;
-    seen.add(readId);
-    normalizedIds.push(readId);
-    if (normalizedIds.length >= maxIds) break;
-  }
-
-  return normalizedIds;
-}
-
-function markReadId(
-  readIds: readonly unknown[] | undefined,
-  readId: string,
-  maxIds = DEFAULT_MAX_READ_IDS,
-): string[] {
-  const normalizedId = normalizeReadId(readId);
-  const current = normalizeReadIds(readIds, maxIds);
-  if (!normalizedId) return current;
-
-  return [
-    normalizedId,
-    ...current.filter((currentId) => currentId !== normalizedId),
-  ].slice(0, maxIds);
-}
-
-export function normalizePersistedReadIdState<TState>(
-  state: TState,
-  adapter: PersistedReadIdAdapter<TState>,
-): TState {
-  const current = adapter.getIds(state);
-  const ids = normalizeReadIds(current, adapter.maxIds);
-  return Array.isArray(current) && sameStringArray(ids, current)
-    ? state
-    : adapter.withIds(state, ids);
-}
-
-export function markPersistedReadId<TState>(
-  state: TState,
-  readId: string,
-  adapter: PersistedReadIdAdapter<TState>,
-): TState {
-  const current = adapter.getIds(state);
-  const ids = markReadId(current, readId, adapter.maxIds);
-  return Array.isArray(current) && sameStringArray(ids, current)
-    ? state
-    : adapter.withIds(state, ids);
-}
-
-export function usePersistedReadIds<TState>({
-  key,
-  fallback,
-  schemaVersion,
-  adapter,
-}: UsePersistedReadIdsOptions<TState>) {
-  const [state, setState] = usePluginState<TState>(key, fallback, { schemaVersion });
-  const normalizedState = useMemo(
-    () => normalizePersistedReadIdState(state, adapter),
-    [adapter, state],
-  );
-  const readIds = useMemo(
-    () => new Set(normalizeReadIds(adapter.getIds(normalizedState), adapter.maxIds)),
-    [adapter, normalizedState],
-  );
-  const markRead = useCallback((readId: string) => {
-    setState((current) => markPersistedReadId(current, readId, adapter));
-  }, [adapter, setState]);
-
-  return { readIds, markRead };
-}