gloomberb 0.5.1 → 0.6.1

package/src/react/input.ts

@@ -0,0 +1,61 @@
+import { createContext, createElement, useContext, type ReactNode } from "react";
+
+export interface KeyEventLike {
+  key: string;
+  name?: string;
+  sequence?: string;
+  ctrl: boolean;
+  shift: boolean;
+  alt: boolean;
+  meta: boolean;
+  super?: boolean;
+  readonly defaultPrevented?: boolean;
+  readonly propagationStopped?: boolean;
+  preventDefault(): void;
+  stopPropagation(): void;
+}
+
+export interface ShortcutOptions {
+  enabled?: boolean;
+  scope?: string;
+  phase?: "normal" | "after";
+}
+
+export interface InputHost {
+  useShortcut(
+    handler: (event: KeyEventLike) => void,
+    options?: ShortcutOptions,
+  ): void;
+  useViewport(): { width: number; height: number };
+}
+
+const InputHostContext = createContext<InputHost | null>(null);
+
+export function InputHostProvider({
+  host,
+  children,
+}: {
+  host: InputHost;
+  children: ReactNode;
+}) {
+  return createElement(InputHostContext, { value: host }, children);
+}
+
+function useInputHost(): InputHost {
+  const host = useContext(InputHostContext);
+  if (!host) {
+    throw new Error("Input host hooks must be used inside InputHostProvider");
+  }
+  return host;
+}
+
+export function useShortcut(
+  handler: (event: KeyEventLike) => void,
+  options?: ShortcutOptions,
+): void {
+  useInputHost().useShortcut(handler, options);
+}
+
+export function useViewport(): { width: number; height: number } {
+  return useInputHost().useViewport();
+}

package/src/react/plugins/plugin-slot.tsx

@@ -0,0 +1,21 @@
+import type { GloomSlots } from "../../types/plugin";
+import { getSharedRegistry } from "../../plugins/registry";
+import { createElement } from "react";
+
+export function PluginSlot<K extends keyof GloomSlots>({
+  name,
+  props,
+}: {
+  name: K;
+  props?: GloomSlots[K];
+}) {
+  const registry = getSharedRegistry();
+  if (!registry) return null;
+  if (typeof registry.renderSlot === "function") {
+    return registry.renderSlot(name, props ?? ({} as GloomSlots[K]));
+  }
+  if (registry.Slot) {
+    return createElement(registry.Slot as any, { name, ...(props ?? {}) });
+  }
+  return null;
+}

package/src/react/use-raf-callback.ts

@@ -0,0 +1,44 @@
+import { useCallback, useEffect, useRef } from "react";
+
+type FrameCallback = (timestamp: number) => void;
+
+const animationFrameApi = globalThis as typeof globalThis & {
+  requestAnimationFrame?: (callback: FrameCallback) => number;
+  cancelAnimationFrame?: (id: number) => void;
+};
+
+function requestFrame(callback: FrameCallback): number {
+  if (typeof animationFrameApi.requestAnimationFrame === "function") {
+    return animationFrameApi.requestAnimationFrame(callback);
+  }
+  return setTimeout(() => callback(Date.now()), 16) as unknown as number;
+}
+
+function cancelFrame(id: number): void {
+  if (typeof animationFrameApi.cancelAnimationFrame === "function") {
+    animationFrameApi.cancelAnimationFrame(id);
+    return;
+  }
+  clearTimeout(id as unknown as ReturnType<typeof setTimeout>);
+}
+
+export function useRafCallback(callback: () => void): () => void {
+  const callbackRef = useRef(callback);
+  const frameRef = useRef<number | null>(null);
+  callbackRef.current = callback;
+
+  useEffect(() => () => {
+    if (frameRef.current !== null) {
+      cancelFrame(frameRef.current);
+      frameRef.current = null;
+    }
+  }, []);
+
+  return useCallback(() => {
+    if (frameRef.current !== null) return;
+    frameRef.current = requestFrame(() => {
+      frameRef.current = null;
+      callbackRef.current();
+    });
+  }, []);
+}

package/src/renderers/electrobun/bun/application-menu-click.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import { ELECTROBUN_APPLICATION_MENU_ACTION } from "./application-menu";
+import { applicationMenuCommand } from "./application-menu-click";
+
+describe("applicationMenuCommand", () => {
+  test("parses a valid open command bar event", () => {
+    expect(applicationMenuCommand({
+      data: {
+        action: ELECTROBUN_APPLICATION_MENU_ACTION,
+        data: { type: "open-command-bar", query: "DES " },
+      },
+    })).toEqual({ type: "open-command-bar", query: "DES " });
+  });
+
+  test("ignores events for other actions", () => {
+    expect(applicationMenuCommand({
+      data: {
+        action: "gloom.other-action",
+        data: { type: "open-command-bar", query: "DES " },
+      },
+    })).toBeNull();
+  });
+
+  test("ignores unknown command types", () => {
+    expect(applicationMenuCommand({
+      data: {
+        action: ELECTROBUN_APPLICATION_MENU_ACTION,
+        data: { type: "unknown-command" },
+      },
+    })).toBeNull();
+  });
+
+  test("ignores plugin workflow commands without a command id", () => {
+    expect(applicationMenuCommand({
+      data: {
+        action: ELECTROBUN_APPLICATION_MENU_ACTION,
+        data: { type: "open-plugin-workflow" },
+      },
+    })).toBeNull();
+  });
+});

package/src/renderers/electrobun/bun/application-menu-click.ts

@@ -0,0 +1,55 @@
+import type { DesktopApplicationMenuCommand } from "../../../types/desktop-menu";
+import { ELECTROBUN_APPLICATION_MENU_ACTION } from "./application-menu";
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+function applicationMenuClickPayload(event: unknown): Record<string, unknown> | null {
+  const eventRecord = record(event);
+  if (!eventRecord) return null;
+
+  const wrappedPayload = record(eventRecord.data);
+  if (typeof wrappedPayload?.action === "string") {
+    return wrappedPayload;
+  }
+
+  return typeof eventRecord.action === "string" ? eventRecord : null;
+}
+
+function normalizeApplicationMenuCommand(value: unknown): DesktopApplicationMenuCommand | null {
+  const command = record(value);
+  if (!command || typeof command.type !== "string") return null;
+
+  switch (command.type) {
+    case "open-command-bar":
+      if (command.query != null && typeof command.query !== "string") return null;
+      return command.query == null
+        ? { type: "open-command-bar" }
+        : { type: "open-command-bar", query: command.query };
+    case "open-plugin-workflow":
+      return typeof command.commandId === "string" && command.commandId.length > 0
+        ? { type: "open-plugin-workflow", commandId: command.commandId }
+        : null;
+    case "open-url":
+      return typeof command.url === "string" && command.url.length > 0
+        ? { type: "open-url", url: command.url }
+        : null;
+    case "check-for-updates":
+    case "toggle-status-bar":
+    case "layout-undo":
+    case "layout-redo":
+    case "layout-gridlock":
+      return { type: command.type };
+    default:
+      return null;
+  }
+}
+
+export function applicationMenuCommand(event: unknown): DesktopApplicationMenuCommand | null {
+  const payload = applicationMenuClickPayload(event);
+  if (payload?.action !== ELECTROBUN_APPLICATION_MENU_ACTION) return null;
+  return normalizeApplicationMenuCommand(payload.data);
+}

package/src/renderers/electrobun/bun/application-menu.ts

@@ -0,0 +1,118 @@
+import type { ApplicationMenuItemConfig } from "electrobun/bun";
+import type { DesktopApplicationMenuCommand } from "../../../types/desktop-menu";
+
+export const ELECTROBUN_APPLICATION_MENU_ACTION = "gloom.application-menu.select";
+export const GITHUB_ISSUE_URL = "https://github.com/vincelwt/gloomberb/issues/new/choose";
+
+function commandItem(
+  label: string,
+  command: DesktopApplicationMenuCommand,
+  options: { accelerator?: string } = {},
+): ApplicationMenuItemConfig {
+  return {
+    label,
+    action: ELECTROBUN_APPLICATION_MENU_ACTION,
+    data: command,
+    ...(options.accelerator ? { accelerator: options.accelerator } : {}),
+  };
+}
+
+function openCommandBar(label: string, query: string, options?: { accelerator?: string }): ApplicationMenuItemConfig {
+  return commandItem(label, { type: "open-command-bar", query }, options);
+}
+
+export function buildApplicationMenu(): ApplicationMenuItemConfig[] {
+  return [
+    {
+      label: "Gloomberb",
+      submenu: [
+        { role: "about" },
+        { type: "divider" },
+        commandItem("Check for Updates...", { type: "check-for-updates" }),
+        { type: "divider" },
+        { role: "hide" },
+        { role: "hideOthers" },
+        { role: "showAll" },
+        { type: "divider" },
+        { role: "quit" },
+      ],
+    },
+    {
+      label: "File",
+      submenu: [
+        openCommandBar("Search Ticker...", "DES "),
+        { type: "divider" },
+        openCommandBar("New Portfolio...", "New Portfolio"),
+        openCommandBar("New Watchlist...", "New Watchlist"),
+        openCommandBar("Set Portfolio Position...", "Set Portfolio Position"),
+        { type: "divider" },
+        openCommandBar("Add Broker Account...", "Add Broker Account"),
+        { type: "divider" },
+        openCommandBar("Import Config...", "Import Config"),
+        openCommandBar("Export Config...", "Export Config"),
+        { type: "divider" },
+        openCommandBar("Reset All Data...", "Reset All Data"),
+      ],
+    },
+    {
+      label: "Edit",
+      submenu: [
+        { role: "undo" },
+        { role: "redo" },
+        { type: "divider" },
+        { role: "cut" },
+        { role: "copy" },
+        { role: "paste" },
+        { role: "pasteAndMatchStyle" },
+        { role: "delete" },
+        { role: "selectAll" },
+      ],
+    },
+    {
+      label: "View",
+      submenu: [
+        openCommandBar("Open Command Bar", "", { accelerator: "CmdOrCtrl+K" }),
+        { type: "divider" },
+        commandItem("Toggle Status Bar", { type: "toggle-status-bar" }),
+        { type: "divider" },
+        openCommandBar("Change Theme...", "TH "),
+        openCommandBar("Manage Plugins...", "PL "),
+      ],
+    },
+    {
+      label: "Layout",
+      submenu: [
+        openCommandBar("Layout Actions...", "LAY ", { accelerator: "CmdOrCtrl+Shift+L" }),
+        { type: "divider" },
+        commandItem("Undo Layout Change", { type: "layout-undo" }),
+        commandItem("Redo Layout Change", { type: "layout-redo" }),
+        commandItem("Gridlock All Windows", { type: "layout-gridlock" }, { accelerator: "CmdOrCtrl+Shift+G" }),
+        { type: "divider" },
+        commandItem("New Layout...", { type: "open-plugin-workflow", commandId: "new-layout" }),
+        commandItem("Rename Current Layout...", { type: "open-plugin-workflow", commandId: "rename-layout" }),
+        openCommandBar("Duplicate Current Layout", "Duplicate Layout"),
+        openCommandBar("Delete Current Layout...", "Delete Layout"),
+      ],
+    },
+    {
+      label: "Window",
+      submenu: [
+        { role: "minimize" },
+        { role: "zoom" },
+        { type: "divider" },
+        { role: "toggleFullScreen" },
+        { type: "divider" },
+        { role: "close" },
+        { type: "divider" },
+        { role: "bringAllToFront" },
+      ],
+    },
+    {
+      label: "Help",
+      submenu: [
+        openCommandBar("Gloomberb Help", "HELP"),
+        commandItem("Open Issue on GitHub", { type: "open-url", url: GITHUB_ISSUE_URL }),
+      ],
+    },
+  ];
+}

package/src/renderers/electrobun/bun/context-menu-click.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+import { ELECTROBUN_CONTEXT_MENU_ACTION } from "../shared/protocol";
+import { contextMenuSelectionMessage } from "./context-menu-click";
+
+describe("contextMenuSelectionMessage", () => {
+  test("extracts custom menu selections encoded in the native action string", () => {
+    expect(contextMenuSelectionMessage({
+      name: "context-menu-clicked",
+      data: {
+        action: `${ELECTROBUN_CONTEXT_MENU_ACTION}:ctx%3A1:pane%3Asettings`,
+      },
+    }, ELECTROBUN_CONTEXT_MENU_ACTION)).toEqual({
+      requestId: "ctx:1",
+      itemId: "pane:settings",
+    });
+  });
+
+  test("extracts custom menu selections from Electrobun event wrappers", () => {
+    expect(contextMenuSelectionMessage({
+      name: "context-menu-clicked",
+      data: {
+        action: ELECTROBUN_CONTEXT_MENU_ACTION,
+        data: {
+          requestId: "ctx:1",
+          itemId: "pane:settings",
+        },
+      },
+    }, ELECTROBUN_CONTEXT_MENU_ACTION)).toEqual({
+      requestId: "ctx:1",
+      itemId: "pane:settings",
+    });
+  });
+
+  test("also accepts a bare native menu payload", () => {
+    expect(contextMenuSelectionMessage({
+      action: ELECTROBUN_CONTEXT_MENU_ACTION,
+      data: {
+        requestId: "ctx:2",
+        itemId: "pane:close",
+      },
+    }, ELECTROBUN_CONTEXT_MENU_ACTION)).toEqual({
+      requestId: "ctx:2",
+      itemId: "pane:close",
+    });
+  });
+
+  test("ignores nonmatching and malformed native menu selections", () => {
+    expect(contextMenuSelectionMessage({
+      data: {
+        action: "other",
+        data: {
+          requestId: "ctx:3",
+          itemId: "pane:close",
+        },
+      },
+    }, ELECTROBUN_CONTEXT_MENU_ACTION)).toBeNull();
+
+    expect(contextMenuSelectionMessage({
+      data: {
+        action: ELECTROBUN_CONTEXT_MENU_ACTION,
+        data: {
+          requestId: "ctx:3",
+        },
+      },
+    }, ELECTROBUN_CONTEXT_MENU_ACTION)).toBeNull();
+  });
+});

package/src/renderers/electrobun/bun/context-menu-click.ts

@@ -0,0 +1,61 @@
+export interface ContextMenuSelectionMessage {
+  requestId: string;
+  itemId: string;
+}
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+function contextMenuClickPayload(event: unknown): Record<string, unknown> | null {
+  const eventRecord = record(event);
+  if (!eventRecord) return null;
+
+  const wrappedPayload = record(eventRecord.data);
+  if (typeof wrappedPayload?.action === "string") {
+    return wrappedPayload;
+  }
+
+  return typeof eventRecord.action === "string" ? eventRecord : null;
+}
+
+function decodeActionSelection(action: string, expectedAction: string): ContextMenuSelectionMessage | null {
+  const prefix = `${expectedAction}:`;
+  if (!action.startsWith(prefix)) return null;
+
+  const [requestId, itemId] = action.slice(prefix.length).split(":").map((part) => {
+    try {
+      return decodeURIComponent(part);
+    } catch {
+      return "";
+    }
+  });
+  if (!requestId || !itemId) return null;
+
+  return { requestId, itemId };
+}
+
+export function contextMenuSelectionMessage(
+  event: unknown,
+  expectedAction: string,
+): ContextMenuSelectionMessage | null {
+  const payload = contextMenuClickPayload(event);
+  if (typeof payload?.action !== "string") return null;
+
+  const actionMessage = decodeActionSelection(payload.action, expectedAction);
+  if (actionMessage) return actionMessage;
+
+  if (payload.action !== expectedAction) return null;
+
+  const data = record(payload.data);
+  if (typeof data?.requestId !== "string" || typeof data.itemId !== "string") {
+    return null;
+  }
+
+  return {
+    requestId: data.requestId,
+    itemId: data.itemId,
+  };
+}

package/src/renderers/electrobun/bun/context-menu-normalize.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import { ELECTROBUN_CONTEXT_MENU_ACTION } from "../shared/protocol";
+import { getContextMenuRequestId, normalizeContextMenuItems } from "./context-menu-normalize";
+
+describe("normalizeContextMenuItems", () => {
+  test("keeps encoded custom actions and discovers their request id", () => {
+    const menu = normalizeContextMenuItems([
+      {
+        label: "Settings",
+        action: `${ELECTROBUN_CONTEXT_MENU_ACTION}:ctx%3A1:settings`,
+      },
+    ]);
+
+    expect(menu).toEqual([
+      {
+        type: "normal",
+        label: "Settings",
+        tooltip: undefined,
+        enabled: true,
+        checked: false,
+        hidden: false,
+        accelerator: undefined,
+        action: `${ELECTROBUN_CONTEXT_MENU_ACTION}:ctx%3A1:settings`,
+      },
+    ]);
+    expect(getContextMenuRequestId(menu)).toBe("ctx:1");
+  });
+
+  test("keeps legacy custom actions that carry request data separately", () => {
+    const menu = normalizeContextMenuItems([
+      {
+        label: "Pop Out",
+        action: ELECTROBUN_CONTEXT_MENU_ACTION,
+        data: {
+          requestId: "ctx:2",
+          itemId: "pop-out",
+        },
+      },
+    ]);
+
+    expect(menu).toMatchObject([
+      {
+        action: ELECTROBUN_CONTEXT_MENU_ACTION,
+        data: {
+          requestId: "ctx:2",
+          itemId: "pop-out",
+        },
+      },
+    ]);
+    expect(getContextMenuRequestId(menu)).toBe("ctx:2");
+  });
+});

package/src/renderers/electrobun/bun/context-menu-normalize.ts

@@ -0,0 +1,67 @@
+import { ELECTROBUN_CONTEXT_MENU_ACTION } from "../shared/protocol";
+import { contextMenuSelectionMessage } from "./context-menu-click";
+
+function normalizeText(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+export function normalizeContextMenuItems(value: unknown, depth = 0): unknown[] {
+  if (!Array.isArray(value) || depth > 4) return [];
+
+  const items: unknown[] = [];
+  for (const rawItem of value) {
+    const item = record(rawItem);
+    if (!item) continue;
+    if (item.type === "divider" || item.type === "separator") {
+      items.push({ type: "divider" });
+      continue;
+    }
+
+    const submenu = normalizeContextMenuItems(item.submenu, depth + 1);
+    const role = normalizeText(item.role);
+    const action = normalizeText(item.action);
+    const data = record(item.data);
+    const customAction = contextMenuSelectionMessage({ action, data }, ELECTROBUN_CONTEXT_MENU_ACTION) !== null;
+
+    if (!role && !customAction && submenu.length === 0 && !normalizeText(item.label)) continue;
+    items.push({
+      type: "normal",
+      label: normalizeText(item.label),
+      tooltip: normalizeText(item.tooltip),
+      enabled: item.enabled === false ? false : true,
+      checked: item.checked === true,
+      hidden: item.hidden === true,
+      accelerator: normalizeText(item.accelerator),
+      ...(role ? { role } : {}),
+      ...(customAction ? {
+        action,
+        ...(data ? { data } : {}),
+      } : {}),
+      ...(submenu.length > 0 ? { submenu } : {}),
+    });
+  }
+
+  return items;
+}
+
+export function getContextMenuRequestId(items: unknown[]): string | null {
+  for (const item of items) {
+    const recordItem = record(item);
+    if (!recordItem) continue;
+    const message = contextMenuSelectionMessage(recordItem, ELECTROBUN_CONTEXT_MENU_ACTION);
+    if (message) {
+      return message.requestId;
+    }
+    if (Array.isArray(recordItem.submenu)) {
+      const submenuRequestId = getContextMenuRequestId(recordItem.submenu);
+      if (submenuRequestId) return submenuRequestId;
+    }
+  }
+  return null;
+}