gloomberb 0.5.0 → 0.6.0

package/src/renderers/electrobun/view/native-renderer.ts

@@ -0,0 +1,110 @@
+/// <reference lib="dom" />
+import type { NativeRendererHost } from "../../../ui";
+import { WEB_CELL_HEIGHT, WEB_CELL_WIDTH } from "./input-host";
+import { hasWebCtrlModifier, normalizeWebKeyName, shouldConsumeWebAppKeyDown, webKeySequence } from "./key-event";
+
+type Listener = (...args: unknown[]) => void;
+type KeypressListener = (event: {
+  name: string;
+  sequence?: string;
+  ctrl?: boolean;
+  option?: boolean;
+  alt?: boolean;
+  meta?: boolean;
+  shift?: boolean;
+  super?: boolean;
+  stopPropagation: () => void;
+  preventDefault: () => void;
+}) => void;
+
+class WebKeyInput {
+  private readonly listeners = new Map<string, Set<KeypressListener>>();
+
+  on(event: string, handler: KeypressListener): void {
+    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
+    this.listeners.get(event)!.add(handler);
+  }
+
+  off(event: string, handler: KeypressListener): void {
+    this.listeners.get(event)?.delete(handler);
+  }
+
+  processPaste(data: Uint8Array): void {
+    const text = new TextDecoder().decode(data);
+    const active = document.activeElement;
+    if (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement) {
+      const start = active.selectionStart ?? active.value.length;
+      const end = active.selectionEnd ?? start;
+      active.value = `${active.value.slice(0, start)}${text}${active.value.slice(end)}`;
+      active.selectionStart = active.selectionEnd = start + text.length;
+      active.dispatchEvent(new Event("input", { bubbles: true }));
+    }
+  }
+
+  emitKeyPress(event: KeyboardEvent): void {
+    const payload = {
+      name: normalizeWebKeyName(event.key),
+      sequence: webKeySequence(event),
+      ctrl: hasWebCtrlModifier(event),
+      option: event.altKey,
+      alt: event.altKey,
+      meta: event.metaKey,
+      shift: event.shiftKey,
+      super: event.metaKey,
+      stopPropagation: () => event.stopPropagation(),
+      preventDefault: () => event.preventDefault(),
+    };
+    const listeners = this.listeners.get("keypress");
+    for (const listener of listeners ?? []) {
+      listener(payload);
+      if (event.defaultPrevented) break;
+    }
+    if (listeners?.size && shouldConsumeWebAppKeyDown(event)) event.preventDefault();
+  }
+}
+
+class WebNativeRenderer implements NativeRendererHost {
+  private readonly listeners = new Map<string, Set<Listener>>();
+  readonly keyInput = new WebKeyInput();
+  capabilities = {};
+  isDestroyed = false;
+
+  get resolution() {
+    return { width: window.innerWidth, height: window.innerHeight };
+  }
+
+  get terminalWidth(): number {
+    return Math.max(1, window.innerWidth / WEB_CELL_WIDTH);
+  }
+
+  get terminalHeight(): number {
+    return Math.max(1, window.innerHeight / WEB_CELL_HEIGHT);
+  }
+
+  on(event: string, handler: Listener): void {
+    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
+    this.listeners.get(event)!.add(handler);
+  }
+
+  off(event: string, handler: Listener): void {
+    this.listeners.get(event)?.delete(handler);
+  }
+
+  emit(event: string): void {
+    for (const listener of this.listeners.get(event) ?? []) listener();
+  }
+
+  requestRender(): void {}
+  registerLifecyclePass(): void {}
+  unregisterLifecyclePass(): void {}
+}
+
+export const webNativeRenderer = new WebNativeRenderer();
+
+window.addEventListener("keydown", (event) => webNativeRenderer.keyInput.emitKeyPress(event));
+window.addEventListener("focus", () => webNativeRenderer.emit("focus"));
+window.addEventListener("blur", () => webNativeRenderer.emit("blur"));
+window.addEventListener("beforeunload", () => {
+  webNativeRenderer.isDestroyed = true;
+  webNativeRenderer.emit("destroy");
+});

package/src/renderers/electrobun/view/native-stubs/chart-kitty-support.ts

@@ -0,0 +1,9 @@
+import type { NativeRendererHost } from "../../../../ui";
+
+export function getCachedKittySupport(_renderer: NativeRendererHost): boolean {
+  return false;
+}
+
+export function ensureKittySupport(_renderer: NativeRendererHost): Promise<boolean> {
+  return Promise.resolve(false);
+}

package/src/renderers/electrobun/view/native-stubs/chart-surface-manager.ts

@@ -0,0 +1,25 @@
+export interface NativePaneLayer {
+  paneId: string;
+  zIndex: number;
+}
+
+export interface NativeOccluder {
+  id: string;
+  paneId?: string | null;
+  rect: { x: number; y: number; width: number; height: number };
+  zIndex: number;
+}
+
+export class NativeSurfaceManager {
+  setWindowState(): void {}
+  upsertSurface(): void {}
+  updateSurfaceGeometry(): void {}
+  removeSurface(): void {}
+  destroy(): void {}
+}
+
+const manager = new NativeSurfaceManager();
+
+export function getNativeSurfaceManager(): NativeSurfaceManager {
+  return manager;
+}

package/src/renderers/electrobun/view/native-stubs/chart-surface-sync.ts

@@ -0,0 +1 @@
+export function syncCachedNativeSurface(): void {}

package/src/renderers/electrobun/view/notes-files.ts

@@ -0,0 +1,56 @@
+import { NOTES_FILES_CAPABILITY_ID } from "../../../capabilities";
+import { backendRequest } from "./backend-rpc";
+
+export interface QuickNoteEntry {
+  id: string;
+  title: string;
+  updatedAt?: number;
+}
+
+export class NotesFiles {
+  constructor(private readonly dataDir: string) {}
+
+  private invoke<T>(operationId: string, payload: Record<string, unknown> = {}): Promise<T> {
+    return backendRequest<T>("capability.invoke", {
+      capabilityId: NOTES_FILES_CAPABILITY_ID,
+      operationId,
+      payload: {
+        dataDir: this.dataDir,
+        ...payload,
+      },
+    });
+  }
+
+  async load(symbol: string): Promise<string> {
+    return this.invoke<string>("load", {
+      symbol,
+    });
+  }
+
+  async save(symbol: string, notes: string): Promise<void> {
+    await this.invoke("save", {
+      symbol,
+      notes,
+    });
+  }
+
+  async delete(symbol: string): Promise<void> {
+    await this.invoke("delete", {
+      symbol,
+    });
+  }
+
+  async loadQuickNotesIndex(): Promise<QuickNoteEntry[]> {
+    return this.invoke<QuickNoteEntry[]>("loadQuickNotesIndex");
+  }
+
+  async saveQuickNotesIndex(entries: QuickNoteEntry[]): Promise<void> {
+    await this.invoke("saveQuickNotesIndex", {
+      entries,
+    });
+  }
+
+  quickNoteKey(id: string): string {
+    return `__note-${id}__`;
+  }
+}

package/src/renderers/electrobun/view/resource-store.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import { DesktopMemoryResourceStore } from "./resource-store";
+
+describe("DesktopMemoryResourceStore", () => {
+  test("returns persisted resource records with values", () => {
+    const store = new DesktopMemoryResourceStore();
+    const key = {
+      namespace: "plugins:prediction-markets",
+      kind: "catalog",
+      entityKey: "polymarket:all:all",
+      sourceKey: "remote",
+    };
+
+    const saved = store.set(key, [{ key: "polymarket:abc" }], {
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+      fetchedAt: Date.now(),
+    });
+    const loaded = store.get<typeof saved.value>(key);
+
+    expect(saved.value).toEqual([{ key: "polymarket:abc" }]);
+    expect(loaded?.value).toEqual([{ key: "polymarket:abc" }]);
+    expect(loaded?.sourceKey).toBe("remote");
+  });
+
+  test("returns expired records only when requested", () => {
+    const store = new DesktopMemoryResourceStore();
+    const key = {
+      namespace: "plugins:prediction-markets",
+      kind: "catalog",
+      entityKey: "kalshi:all:all",
+      sourceKey: "remote",
+    };
+
+    store.set(key, ["expired"], {
+      cachePolicy: { staleMs: -2, expireMs: -1 },
+      fetchedAt: Date.now(),
+    });
+
+    expect(store.get(key)).toBeNull();
+    expect(store.get<string[]>(key, { allowExpired: true })?.value).toEqual([
+      "expired",
+    ]);
+  });
+});

package/src/renderers/electrobun/view/resource-store.ts

@@ -0,0 +1,106 @@
+import type {
+  CachedResourceRecord,
+  GetResourceOptions,
+  ListResourceOptions,
+  ResourceCacheKey,
+  SetResourceOptions,
+} from "../../../data/resource-store";
+
+const DEFAULT_RESOURCE_SCHEMA_VERSION = 1;
+
+function normalizeVariantKey(value: string | undefined): string {
+  return value ?? "";
+}
+
+function normalizeSourceKey(value: string | undefined): string {
+  return value ?? "";
+}
+
+function buildMapKey(key: ResourceCacheKey): string {
+  return [
+    key.namespace,
+    key.kind,
+    key.entityKey,
+    normalizeVariantKey(key.variantKey),
+    normalizeSourceKey(key.sourceKey),
+  ].join("\u0000");
+}
+
+function isExpired(record: CachedResourceRecord): boolean {
+  return record.expiresAt < Date.now();
+}
+
+function isStale(record: CachedResourceRecord): boolean {
+  return record.staleAt < Date.now();
+}
+
+export class DesktopMemoryResourceStore {
+  private readonly records = new Map<string, CachedResourceRecord>();
+
+  get<T>(key: ResourceCacheKey, options: GetResourceOptions = {}): CachedResourceRecord<T> | null {
+    const record = this.records.get(buildMapKey(key)) as CachedResourceRecord<T> | undefined;
+    if (!record) return null;
+    if (!options.allowExpired && isExpired(record)) return null;
+    if (options.schemaVersion != null && record.schemaVersion !== options.schemaVersion) {
+      this.delete(key);
+      return null;
+    }
+    if (options.touch !== false) {
+      record.lastAccessedAt = Date.now();
+    }
+    record.stale = isStale(record);
+    record.expired = isExpired(record);
+    return record;
+  }
+
+  list<T>(
+    key: Pick<ResourceCacheKey, "namespace" | "kind" | "entityKey">,
+    options: ListResourceOptions = {},
+  ): CachedResourceRecord<T>[] {
+    const allowedVariantKeys = options.variantKeys ? new Set(options.variantKeys.map(normalizeVariantKey)) : null;
+    const allowedSourceKeys = options.sourceKeys ? new Set(options.sourceKeys.map(normalizeSourceKey)) : null;
+    const records = [...this.records.values()].filter((record) => {
+      if (record.namespace !== key.namespace || record.kind !== key.kind || record.entityKey !== key.entityKey) return false;
+      if (!options.allowExpired && isExpired(record)) return false;
+      if (allowedVariantKeys && !allowedVariantKeys.has(record.variantKey)) return false;
+      if (allowedSourceKeys && !allowedSourceKeys.has(record.sourceKey)) return false;
+      if (options.schemaVersion != null && record.schemaVersion !== options.schemaVersion) return false;
+      return true;
+    });
+    return records
+      .sort((left, right) => right.lastAccessedAt - left.lastAccessedAt)
+      .map((record) => this.get<T>(record, options))
+      .filter((record): record is CachedResourceRecord<T> => record != null);
+  }
+
+  set<T>(
+    key: ResourceCacheKey,
+    value: T,
+    options: SetResourceOptions,
+  ): CachedResourceRecord<T> {
+    const now = options.fetchedAt ?? Date.now();
+    const record: CachedResourceRecord<T> = {
+      namespace: key.namespace,
+      kind: key.kind,
+      entityKey: key.entityKey,
+      variantKey: normalizeVariantKey(key.variantKey),
+      sourceKey: normalizeSourceKey(key.sourceKey),
+      value,
+      schemaVersion: options.schemaVersion ?? DEFAULT_RESOURCE_SCHEMA_VERSION,
+      provenance: options.provenance ?? null,
+      fetchedAt: now,
+      staleAt: now + options.cachePolicy.staleMs,
+      expiresAt: now + options.cachePolicy.expireMs,
+      lastAccessedAt: now,
+      sizeBytes: 0,
+      stale: false,
+      expired: false,
+    };
+    this.records.set(buildMapKey(record), record);
+    return record;
+  }
+
+  delete(key: ResourceCacheKey): void {
+    this.records.delete(buildMapKey(key));
+  }
+}

package/src/renderers/electrobun/view/rpc-codec.ts

@@ -0,0 +1,42 @@
+const DATE_MARKER = "__gloomDate";
+const MAP_MARKER = "__gloomMap";
+
+export function encodeRpcValue(value: unknown): unknown {
+  if (value instanceof Date) {
+    return { [DATE_MARKER]: value.toISOString() };
+  }
+  if (value instanceof Map) {
+    return { [MAP_MARKER]: [...value.entries()].map(([key, entry]) => [key, encodeRpcValue(entry)]) };
+  }
+  if (Array.isArray(value)) {
+    return value.map(encodeRpcValue);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>).map(([key, entry]) => [key, encodeRpcValue(entry)]),
+    );
+  }
+  return value;
+}
+
+export function decodeRpcValue<T = unknown>(value: unknown): T {
+  if (Array.isArray(value)) {
+    return value.map((entry) => decodeRpcValue(entry)) as T;
+  }
+  if (value && typeof value === "object") {
+    const record = value as Record<string, unknown>;
+    if (typeof record[DATE_MARKER] === "string") {
+      return new Date(record[DATE_MARKER]) as T;
+    }
+    if (Array.isArray(record[MAP_MARKER])) {
+      return new Map(record[MAP_MARKER].map((entry) => {
+        const pair = entry as [unknown, unknown];
+        return [pair[0], decodeRpcValue(pair[1])];
+      })) as T;
+    }
+    return Object.fromEntries(
+      Object.entries(record).map(([key, entry]) => [key, decodeRpcValue(entry)]),
+    ) as T;
+  }
+  return value as T;
+}

package/src/renderers/electrobun/view/scrollbar-activity.ts

@@ -0,0 +1,23 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+const SCROLLBAR_ACTIVITY_TIMEOUT_MS = 700;
+
+export function useScrollbarActivity() {
+  const [active, setActive] = useState(false);
+  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const markScrollbarActive = useCallback(() => {
+    setActive(true);
+    if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    timeoutRef.current = setTimeout(() => {
+      timeoutRef.current = null;
+      setActive(false);
+    }, SCROLLBAR_ACTIVITY_TIMEOUT_MS);
+  }, []);
+
+  useEffect(() => () => {
+    if (timeoutRef.current) clearTimeout(timeoutRef.current);
+  }, []);
+
+  return [active, markScrollbarActive] as const;
+}

package/src/renderers/electrobun/view/toast-host.tsx

@@ -0,0 +1,65 @@
+/// <reference lib="dom" />
+/** @jsxImportSource react */
+import { useCallback, useMemo, useState, type ReactNode } from "react";
+import { ToastHostProvider, type ToastHost, type ToastOptions } from "../../../ui/toast";
+
+interface ToastEntry {
+  id: number;
+  body: string;
+  type: "info" | "success" | "error";
+  action?: ToastOptions["action"];
+}
+
+let nextToastId = 1;
+
+export function WebToastHostProvider({ children }: { children: ReactNode }) {
+  const [toasts, setToasts] = useState<ToastEntry[]>([]);
+
+  const dismiss = useCallback((id: string | number) => {
+    setToasts((current) => current.filter((toast) => toast.id !== id));
+  }, []);
+
+  const push = useCallback((type: ToastEntry["type"], body: string, options?: ToastOptions) => {
+    const id = nextToastId++;
+    setToasts((current) => [...current, { id, type, body, action: options?.action }].slice(-6));
+    if (options?.duration !== 0) {
+      setTimeout(() => dismiss(id), options?.duration ?? 4500);
+    }
+    return id;
+  }, [dismiss]);
+
+  const host = useMemo<ToastHost>(() => ({
+    Viewport() {
+      return (
+        <div className="gloom-toast-viewport">
+          {toasts.map((toast) => (
+            <div key={toast.id} className={`gloom-toast gloom-toast-${toast.type}`}>
+              <div>{toast.body}</div>
+              {toast.action && (
+                <button
+                  className="gloom-toast-action"
+                  onClick={() => {
+                    toast.action?.onClick();
+                    dismiss(toast.id);
+                  }}
+                >
+                  {toast.action.label}
+                </button>
+              )}
+            </div>
+          ))}
+        </div>
+      );
+    },
+    success: (body, options) => push("success", body, options),
+    error: (body, options) => push("error", body, options),
+    info: (body, options) => push("info", body, options),
+    dismiss,
+  }), [dismiss, push, toasts]);
+
+  return (
+    <ToastHostProvider host={host}>
+      {children}
+    </ToastHostProvider>
+  );
+}