gloomberb 0.10.2 → 0.10.4

package/src/plugins/builtin/shared/cloud-upgrade.ts

@@ -1 +1,132 @@
+import { useCallback, useEffect, useMemo } from "react";
+import type { PaneFooterSegment } from "../../../components";
+import { tf } from "../../../i18n";
+import { useAppLanguage } from "../../../i18n/react";
+import { useShortcut } from "../../../react/input";
+import { useRendererHost } from "../../../ui";
+import { getSharedRegistry } from "../../registry";
+import { requestAccountManagementTab } from "../account-management/navigation";
+import { usePlanAccess, type PlanAccess } from "./plan-access";
+
 export const CLOUD_UPGRADE_URL = "https://gloom.sh/cloud?upgrade=pro";
+
+/**
+ * The renderer host only exists inside React, so UI that uses it publishes an
+ * opener here for the command bar, which runs outside the tree.
+ */
+let cloudUpgradeOpener: ((url: string) => void) | null = null;
+
+/** Opens the checkout page when any cloud UI has published an opener. */
+export function openCloudUpgradeUrl(): boolean {
+  if (!cloudUpgradeOpener) return false;
+  cloudUpgradeOpener(CLOUD_UPGRADE_URL);
+  return true;
+}
+
+/** Opens the Pro checkout page in the user's browser. */
+export function useCloudUpgradeAction(): () => void {
+  const rendererHost = useRendererHost();
+  const openUpgrade = useCallback(() => {
+    void rendererHost.openExternal(CLOUD_UPGRADE_URL);
+  }, [rendererHost]);
+  useEffect(() => {
+    cloudUpgradeOpener = (url) => { void rendererHost.openExternal(url); };
+  }, [rendererHost]);
+  return openUpgrade;
+}
+
+/** Opens the account pane on its Pro tab, where plan and billing live. */
+export function useCloudPlanAction(): () => void {
+  return useCallback(() => {
+    requestAccountManagementTab("pro");
+    getSharedRegistry()?.showPane("account-management");
+  }, []);
+}
+
+export interface CloudAccessFooterOptions {
+  /** Compact delay the free tier gets on this pane's data, e.g. "15m" or "12h". */
+  delayLabel: string;
+  focused: boolean;
+  /** Pane-unique shortcut scope. Omit to render the CTA without a `u` binding. */
+  shortcutScope?: string;
+  /** Set false while the pane happens to show data that is not cloud-delayed. */
+  degraded?: boolean;
+  segmentId?: string;
+}
+
+export interface CloudAccessFooter {
+  access: PlanAccess;
+  /** Null while the account already pays for Pro, or when nothing is degraded. */
+  segment: PaneFooterSegment | null;
+  openUpgrade: () => void;
+}
+
+/**
+ * One compact footer status for cloud data entitlements: the delay free accounts
+ * get on this pane, or the remaining trial days while Pro is on loan. Panes keep
+ * ownership of their own richer states (e.g. options stream coverage) and only
+ * render this segment when it is non-null.
+ */
+export function useCloudAccessFooter({
+  delayLabel,
+  degraded = true,
+  focused,
+  segmentId = "cloud-access",
+  shortcutScope,
+}: CloudAccessFooterOptions): CloudAccessFooter {
+  const language = useAppLanguage();
+  const access = usePlanAccess();
+  const openUpgrade = useCloudUpgradeAction();
+  const openPlan = useCloudPlanAction();
+
+  const showTrial = access.isTrialActive;
+  const showUpgrade = !showTrial && !access.hasProAccess && degraded;
+  const bindsShortcut = !!shortcutScope && showUpgrade && focused;
+
+  useShortcut(
+    (event) => {
+      const key = (event.name ?? event.key ?? "").toLowerCase();
+      if (!bindsShortcut || key !== "u") return;
+      event.stopPropagation();
+      event.preventDefault();
+      openUpgrade();
+    },
+    { scope: shortcutScope ?? "cloud-access:upgrade", enabled: bindsShortcut },
+  );
+
+  const segment = useMemo<PaneFooterSegment | null>(() => {
+    if (showTrial) {
+      return {
+        id: segmentId,
+        onPress: openPlan,
+        parts: [{
+          text: tf("Pro trial · {days}d left", { days: access.trialDaysLeft }),
+          tone: "positive",
+        }],
+      };
+    }
+    if (!showUpgrade) return null;
+    return {
+      id: segmentId,
+      onPress: openUpgrade,
+      parts: [{
+        text: shortcutScope
+          ? tf("{delay} delayed · u upgrade", { delay: delayLabel })
+          : tf("{delay} delayed · upgrade", { delay: delayLabel }),
+        tone: "warning",
+      }],
+    };
+  }, [
+    access.trialDaysLeft,
+    delayLabel,
+    language,
+    openPlan,
+    openUpgrade,
+    segmentId,
+    shortcutScope,
+    showTrial,
+    showUpgrade,
+  ]);
+
+  return { access, openUpgrade, segment };
+}

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

@@ -0,0 +1,60 @@
+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/plan-access.test.ts

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,109 @@
+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/ticker-detail/chart-tab-switch.test.tsx

@@ -236,7 +236,7 @@ describe("Ticker detail chart tab switching", () => {
 
     await flushFrames();
     const chartTabFrame = testSetup.captureCharFrame();
-    expect(chartTabFrame).toContain("Latest");
+    expect(chartTabFrame).toContain("AAPL:XNAS Price");
     expect(chartTabFrame).toContain("5Y");
     expect(chartTabFrame).toContain("AUTO");
     expect(chartTabFrame).not.toContain("AAPL -");

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

@@ -19,6 +19,10 @@ import {
   getTickerResearchPaneSettings,
 } from "./settings";
 import { formatTickerListInput } from "../../../tickers/list";
+import {
+  LIVE_STREAMING_QUICK_SETTING,
+  withLiveStreamingSetting,
+} from "../shared/live-streaming";
 
 function hasStatementFinancials(financials: TickerFinancials | null | undefined): boolean {
   return (financials?.annualStatements.length ?? 0) > 0 || (financials?.quarterlyStatements.length ?? 0) > 0;
@@ -50,7 +54,11 @@ export const tickerDetailModule: PluginModule = {
       component: TickerResearchPane,
       defaultPosition: "right",
       defaultMode: "floating",
-      settings: (context) => buildTickerResearchSettingsDef(getTickerResearchPaneSettings(context.settings)),
+      quickSettings: [LIVE_STREAMING_QUICK_SETTING],
+      settings: (context) => withLiveStreamingSetting(
+        buildTickerResearchSettingsDef(getTickerResearchPaneSettings(context.settings)),
+        context.settings,
+      ),
     },
     {
       id: "financial-analysis",
@@ -69,7 +77,8 @@ export const tickerDetailModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 72, height: 10 },
-      settings: buildQuoteMonitorSettingsDef(),
+      quickSettings: [LIVE_STREAMING_QUICK_SETTING],
+      settings: (context) => withLiveStreamingSetting(buildQuoteMonitorSettingsDef(), context.settings),
     },
     {
       id: "historical-prices",

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

@@ -11,10 +11,10 @@ import {
   usePaneStateValue,
   usePaneTicker,
 } from "../../../state/app/context";
-import { useQuoteStreaming } from "../../../state/hooks/quote-streaming";
+import { useQuoteUpdates } from "../../../state/hooks/quote-streaming";
 import { getCollectionName, getCollectionTickerCount } from "../../../state/selectors";
 import { getSharedRegistry } from "../../registry";
-import { EmptyState, PaneFooterScope, Tabs } from "../../../components";
+import { EmptyState, PaneFooterScope, Tabs, usePaneFooter } from "../../../components";
 import { useThrottledCommitValue } from "../../../react/use-throttled-commit-value";
 import { resolveOptionsTarget } from "../../../utils/options";
 import {
@@ -22,6 +22,9 @@ import {
   getTickerResearchPaneSettings,
   resolveLockedTabId,
 } from "./settings";
+import { useLiveStreamingSetting } from "../shared/live-streaming";
+import { useCloudAccessFooter } from "../shared/cloud-upgrade";
+import { CLOUD_QUOTE_DELAY_MINUTES } from "../shared/plan-access";
 
 const TICKER_RESEARCH_TAB_COMMIT_DELAY_MS = 120;
 
@@ -61,6 +64,7 @@ export function TickerResearchPane({ focused, width, height }: PaneProps) {
   const config = useAppSelector((state) => state.config);
   const paneInstance = usePaneInstance();
   const { ticker, financials } = usePaneTicker();
+  const liveStreaming = useLiveStreamingSetting();
   const streamingTarget = quoteSubscriptionTargetFromTicker(ticker, ticker?.metadata.ticker, "provider");
   const streamingTargets = useMemo(() => (
     streamingTarget
@@ -80,7 +84,7 @@ export function TickerResearchPane({ focused, width, height }: PaneProps) {
     streamingTarget?.context?.brokerInstanceId,
     streamingTarget?.context?.instrument,
   ]);
-  useQuoteStreaming(streamingTargets);
+  useQuoteUpdates(streamingTargets, { liveStreaming });
 
   const { collectionId } = usePaneCollection();
   const [committedActiveTabId, setCommittedActiveTabId] = usePaneStateValue<string>("activeTabId", "overview");
@@ -100,6 +104,20 @@ export function TickerResearchPane({ focused, width, height }: PaneProps) {
   const collectionTickerCount = useAppSelector((state) => getCollectionTickerCount(state, collectionId));
   const collectionName = useAppSelector((state) => getCollectionName(state, collectionId));
 
+  // Cloud quotes are delayed on the free tier; a broker feed can still be live.
+  const cloudAccess = useCloudAccessFooter({
+    delayLabel: tf("{count}m", { count: CLOUD_QUOTE_DELAY_MINUTES }),
+    degraded: financials?.quote?.dataSource !== "live",
+    focused,
+    segmentId: "ticker-research-access",
+    shortcutScope: "ticker-research:upgrade",
+  });
+  usePaneFooter(
+    "ticker-research-access",
+    () => cloudAccess.segment ? { info: [cloudAccess.segment], order: -1 } : null,
+    [cloudAccess.segment],
+  );
+
   const disabledPlugins = config.disabledPlugins;
   const registry = getSharedRegistry();
   const tickerResearchTabsSnapshot = useRegistryTickerResearchTabsSnapshot(registry);

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

@@ -5,13 +5,14 @@ import { TICKER_RESEARCH_PANE_ID } from "../../../../types/config";
 import type { QuoteSubscriptionTarget } from "../../../../types/data-provider";
 import { quoteSubscriptionTargetFromTicker } from "../../../../market-data/request-types";
 import { useAppSelector, usePaneInstance, usePaneTicker } from "../../../../state/app/context";
-import { useQuoteStreaming } from "../../../../state/hooks/quote-streaming";
+import { useQuoteUpdates } from "../../../../state/hooks/quote-streaming";
 import { usePluginAppActions, usePluginTickerActions } from "../../../runtime";
 import { colors } from "../../../../theme/colors";
 import { EmptyState } from "../../../../components";
 import { getQuoteMonitorPaneSettings } from "../settings";
 import { useShortcut } from "../../../../react/input";
 import { QuoteMonitorCard } from "./card";
+import { useLiveStreamingSetting } from "../../shared/live-streaming";
 
 function chunkSymbols(symbols: string[], columns: number): string[][] {
   const rows: string[][] = [];
@@ -58,6 +59,7 @@ function resolveGridColumnCount(symbolCount: number, width: number, height: numb
 export function QuoteMonitorPane({ paneId, focused, width, height }: PaneProps) {
   const pane = usePaneInstance();
   const { symbol: fallbackSymbol, ticker: fallbackTicker } = usePaneTicker();
+  const liveStreaming = useLiveStreamingSetting();
   const settings = useMemo(
     () => getQuoteMonitorPaneSettings(pane?.settings, fallbackSymbol),
     [fallbackSymbol, pane?.settings],
@@ -77,7 +79,7 @@ export function QuoteMonitorPane({ paneId, focused, width, height }: PaneProps)
     }
     return targets;
   }, [fallbackSymbol, fallbackTicker, symbols, tickersBySymbol]);
-  useQuoteStreaming(streamingTargets);
+  useQuoteUpdates(streamingTargets, { liveStreaming });
   const { pinTicker } = usePluginTickerActions();
   const { openPaneSettings } = usePluginAppActions();
   const { nativePaneChrome } = useUiCapabilities();

package/src/plugins/registry/index.test.ts

@@ -414,6 +414,57 @@ describe("PluginRegistry pane settings", () => {
     expect(descriptor?.pluginId).toBe("news");
     expect(descriptor?.context.settings.breakingNewsNotificationsEnabled).toBe(true);
   });
+
+  test("resolves and applies toggle-backed pane quick settings", async () => {
+    const registry = createRegistry();
+    const config = createDefaultConfig("/tmp/gloomberb-pane-quick-settings-test");
+    config.layout = {
+      dockRoot: { kind: "pane", instanceId: "test-pane:main" },
+      instances: [{
+        instanceId: "test-pane:main",
+        paneId: "test-pane",
+        binding: { kind: "none" },
+        settings: {},
+      }],
+      floating: [],
+      detached: [],
+    };
+    registry.getConfigFn = () => config;
+    registry.getLayoutFn = () => config.layout;
+
+    await registry.register(plugin("quotes", (ctx) => {
+      ctx.registerPane({
+        id: "test-pane",
+        name: "Test Pane",
+        defaultPosition: "right",
+        component: () => null,
+        quickSettings: [{ type: "toggle", key: "liveStreaming", icon: "zap" }],
+        settings: {
+          values: { liveStreaming: true },
+          fields: [{
+            key: "liveStreaming",
+            label: "Live streaming",
+            type: "toggle",
+          }],
+        },
+      });
+    }));
+
+    const applied: Array<{ key: string; value: unknown }> = [];
+    registry.applyPaneSettingValueFn = async (_paneId, field, value) => {
+      applied.push({ key: field.key, value });
+    };
+
+    expect(registry.resolvePaneQuickSettings("test-pane:main")).toMatchObject([{
+      key: "liveStreaming",
+      icon: "zap",
+      label: "Live streaming",
+      value: true,
+    }]);
+
+    await registry.togglePaneQuickSetting("test-pane:main", "liveStreaming");
+    expect(applied).toEqual([{ key: "liveStreaming", value: false }]);
+  });
 });
 
 describe("PluginRegistry broker runtime", () => {

package/src/plugins/registry/index.ts

@@ -42,7 +42,9 @@ import {
 } from "../runtime";
 import type { PaneRuntimeState } from "../../core/state/app/state";
 import {
+  resolveRegistryPaneQuickSettings,
   resolveRegistryPaneSettings,
+  type ResolvedRegistryPaneQuickSetting,
   type ResolvedRegistryPaneSettings,
 } from "./pane-settings";
 import { RegistrySlots } from "./slots";
@@ -363,6 +365,16 @@ export class PluginRegistry implements PluginRuntimeAccess {
     return this.resolvePaneSettings(paneId) !== null;
   }
 
+  resolvePaneQuickSettings(paneId: string): ResolvedRegistryPaneQuickSetting[] {
+    return resolveRegistryPaneQuickSettings(this.resolvePaneSettings(paneId));
+  }
+
+  async togglePaneQuickSetting(paneId: string, key: string): Promise<void> {
+    const quickSetting = this.resolvePaneQuickSettings(paneId).find((setting) => setting.key === key);
+    if (!quickSetting) return;
+    await this.applyPaneSettingValueFn(paneId, quickSetting.field, !quickSetting.value);
+  }
+
   getCommandPluginId(commandId: string): string | undefined {
     return this.contributions.commandOwners.get(commandId);
   }

package/src/plugins/registry/pane-settings.ts

@@ -7,6 +7,8 @@ import { getPaneSettings } from "../../pane-settings";
 import type { AppConfig, LayoutConfig, PaneInstanceConfig } from "../../types/config";
 import type {
   PaneDef,
+  PaneQuickSettingDef,
+  PaneSettingField,
   PaneSettingsContext,
   PaneSettingsDef,
 } from "../../types/plugin";
@@ -21,6 +23,33 @@ export interface ResolvedRegistryPaneSettings {
   context: PaneSettingsContext;
 }
 
+export interface ResolvedRegistryPaneQuickSetting extends PaneQuickSettingDef {
+  label: string;
+  description?: string;
+  value: boolean;
+  field: PaneSettingField & { type: "toggle" };
+}
+
+export function resolveRegistryPaneQuickSettings(
+  resolved: ResolvedRegistryPaneSettings | null,
+): ResolvedRegistryPaneQuickSetting[] {
+  if (!resolved?.paneDef.quickSettings?.length) return [];
+
+  return resolved.paneDef.quickSettings.flatMap((quickSetting) => {
+    const field = resolved.settingsDef.fields.find((candidate) => (
+      candidate.key === quickSetting.key && candidate.type === "toggle"
+    ));
+    if (!field || field.type !== "toggle") return [];
+    return [{
+      ...quickSetting,
+      label: quickSetting.label ?? field.label,
+      description: field.description,
+      value: resolved.context.settings[quickSetting.key] === true,
+      field,
+    }];
+  });
+}
+
 export function resolveRegistryPaneSettings({
   config,
   getConfigState,