gloomberb 0.15.2 → 0.15.4

package/src/renderers/electrobun/bun/desktop/workspace/index.test.ts

@@ -1,147 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { cloneLayout, createDefaultConfig, createPaneInstance, findPaneInstance } from "../../../../../types/config";
-import { addPaneFloating } from "../../../../../plugins/pane-manager";
-import { updatePaneInstance } from "../../../../../pane-settings";
-import { createDesktopWorkspace } from "./index";
-
-describe("desktop workspace", () => {
-  test("popping out a pane persists it into the active layout", () => {
-    const config = createDefaultConfig("/tmp/gloomberb-desktop");
-    const workspace = createDesktopWorkspace(config, null);
-
-    const snapshot = workspace.popOutPane("chat:main", {
-      x: 100,
-      y: 120,
-      width: 800,
-      height: 540,
-    });
-
-    expect(snapshot.config.layout.detached).toEqual([
-      { instanceId: "chat:main", x: 100, y: 120, width: 800, height: 540 },
-    ]);
-    expect(snapshot.config.layouts[snapshot.config.activeLayoutIndex]?.layout.detached).toEqual([
-      { instanceId: "chat:main", x: 100, y: 120, width: 800, height: 540 },
-    ]);
-    expect(snapshot.config.layout.floating.some((entry) => entry.instanceId === "chat:main")).toBe(false);
-  });
-
-  test("docking a detached pane onto a frame edge clears detached placement", () => {
-    const config = createDefaultConfig("/tmp/gloomberb-desktop");
-    const workspace = createDesktopWorkspace(config, null);
-    workspace.popOutPane("chat:main", {
-      x: 100,
-      y: 120,
-      width: 800,
-      height: 540,
-    });
-
-    const snapshot = workspace.dockDetachedPane("chat:main", "left");
-
-    expect(snapshot.config.layout.detached).toHaveLength(0);
-    expect(snapshot.config.layout.dockRoot).not.toBeNull();
-  });
-
-  test("a renderer's older copy of the layout does not move a popped-out window back", () => {
-    const config = createDefaultConfig("/tmp/gloomberb-desktop");
-    const workspace = createDesktopWorkspace(config, null);
-    const popped = workspace.popOutPane("chat:main", { x: 100, y: 120, width: 800, height: 540 });
-    workspace.updateDetachedFrame("chat:main", { x: 220, y: 260, width: 640, height: 480 });
-    const moved = { instanceId: "chat:main", x: 220, y: 260, width: 640, height: 480 };
-
-    // A popped-out window saving the config it hydrated before the move.
-    expect(workspace.replaceConfig(popped.config).config.layout.detached).toEqual([moved]);
-    // The main window syncing state it built before the move, with its tabs
-    // reordered since, so even the active index differs.
-    const otherPane = popped.config.layout.instances.find((instance) => instance.instanceId !== "chat:main")!;
-    const newlyOut = { instanceId: otherPane.instanceId, x: 10, y: 20, width: 700, height: 500 };
-    const synced = workspace.syncMainState({
-      ...popped,
-      config: {
-        ...popped.config,
-        activeLayoutIndex: popped.config.activeLayoutIndex === 0 ? 1 : 0,
-        layout: { ...cloneLayout(popped.config.layout), detached: [...popped.config.layout.detached, newlyOut] },
-      },
-      mainStateRevision: 5,
-    });
-    // A pane the main window newly pops out still opens where it says.
-    expect(synced.config.layout.detached).toEqual([moved, newlyOut]);
-    expect(synced.config.layouts[synced.config.activeLayoutIndex]?.layout.detached).toEqual([moved, newlyOut]);
-  });
-
-  // A popped-out window only rehydrates when its own pane changes, so the rest
-  // of the layout it saves can predate a pane the main window just opened.
-  test("a popped-out window's save keeps panes it has not seen and applies its own pane's edits", () => {
-    const workspace = createDesktopWorkspace(createDefaultConfig("/tmp/gloomberb-desktop"), null);
-    const popped = workspace.popOutPane("chat:main", { x: 100, y: 120, width: 800, height: 540 });
-    const opened = createPaneInstance("news", { instanceId: "news:opened" });
-    workspace.syncMainState({
-      ...popped,
-      config: { ...popped.config, layout: addPaneFloating(popped.config.layout, opened, 120, 40) },
-      mainStateRevision: 1,
-    });
-
-    // Its own pane renamed, and (a popped-out Layouts pane) the open tab too.
-    const saved = workspace.replaceConfigFromDetachedPane("chat:main", {
-      ...popped.config,
-      theme: "green",
-      layout: updatePaneInstance(popped.config.layout, "chat:main", (instance) => ({ ...instance, title: "#general" })),
-      layouts: popped.config.layouts.map((entry, index) => (
-        index === popped.config.activeLayoutIndex ? { ...entry, name: "Trading" } : entry
-      )),
-    });
-
-    expect(findPaneInstance(saved.config.layout, "news:opened")).toBeDefined();
-    expect(findPaneInstance(saved.config.layout, "chat:main")?.title).toBe("#general");
-    expect(saved.config.layouts[saved.config.activeLayoutIndex]?.name).toBe("Trading");
-    expect(saved.config.theme).toBe("green");
-    expect(saved.config.layout.detached.map((entry) => entry.instanceId)).toEqual(["chat:main"]);
-    expect(saved.mainStateRevision).toBe(1);
-  });
-
-  test("docking from the menu remembers the window's frame, an edge drop does not", () => {
-    const config = createDefaultConfig("/tmp/gloomberb-desktop");
-    const workspace = createDesktopWorkspace(config, null);
-    const rested = { x: 220, y: 260, width: 640, height: 480 };
-    workspace.popOutPane("chat:main", { x: 100, y: 120, width: 800, height: 540 });
-    workspace.updateDetachedFrame("chat:main", rested);
-
-    const docked = workspace.dockDetachedPane("chat:main");
-    expect(findPaneInstance(docked.config.layout, "chat:main")?.placementMemory?.detached).toEqual(rested);
-
-    workspace.popOutPane("chat:main", rested);
-    workspace.updateDetachedFrame("chat:main", { x: 1140, y: 300, width: 640, height: 480 });
-    const dropped = workspace.dockDetachedPane("chat:main", "right");
-    expect(findPaneInstance(dropped.config.layout, "chat:main")?.placementMemory?.detached).toEqual(rested);
-  });
-
-  test("ignores main-window state that arrives behind a newer layout revision", () => {
-    const config = createDefaultConfig("/tmp/gloomberb-desktop-layout-revision");
-    const workspace = createDesktopWorkspace(config, null);
-    const initialSnapshot = workspace.getSnapshot();
-    const monitorLayout = config.layouts[1]!;
-
-    const newerSnapshot = {
-      ...initialSnapshot,
-      config: {
-        ...initialSnapshot.config,
-        layout: cloneLayout(monitorLayout.layout),
-        activeLayoutIndex: 1,
-      },
-      paneState: monitorLayout.paneState ?? {},
-      focusedPaneId: monitorLayout.focusedPaneId ?? null,
-      activePanel: monitorLayout.activePanel ?? "left" as const,
-      mainStateRevision: 2,
-    };
-    const staleSnapshot = {
-      ...initialSnapshot,
-      mainStateRevision: 1,
-    };
-
-    workspace.syncMainState(newerSnapshot);
-    const result = workspace.syncMainState(staleSnapshot);
-
-    expect(result.mainStateRevision).toBe(2);
-    expect(result.config.activeLayoutIndex).toBe(1);
-    expect(result.config.layout).toEqual(monitorLayout.layout);
-  });
-});

package/src/renderers/electrobun/bun/window/frame.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  DEFAULT_WINDOW_FRAME,
-  DEFAULT_WINDOWS_WINDOW_FRAME,
-  MAIN_WINDOW_MIN_SIZE,
-  constrainWindowFrame,
-  defaultMainWindowFrame,
-  normalizeWindowFrameWithMinimum,
-} from "./frame";
-
-describe("electrobun window frames", () => {
-  test("normalizes partial resize events without clamping usable small windows", () => {
-    const frame = normalizeWindowFrameWithMinimum(
-      { width: 720 },
-      { x: 10, y: 20, width: 1200, height: 800 },
-      MAIN_WINDOW_MIN_SIZE,
-    );
-
-    expect(frame).toEqual({
-      x: 10,
-      y: 20,
-      width: 720,
-      height: 800,
-    });
-  });
-
-  test("clamps only tiny frames to the emergency minimum size", () => {
-    expect(constrainWindowFrame(
-      { x: 0, y: 0, width: 400, height: 300 },
-      MAIN_WINDOW_MIN_SIZE,
-    )).toEqual({
-      x: 0,
-      y: 0,
-      width: 640,
-      height: 400,
-    });
-  });
-
-  test("uses the default frame when no frame data is available", () => {
-    expect(normalizeWindowFrameWithMinimum(null)).toEqual(DEFAULT_WINDOW_FRAME);
-  });
-
-  test("uses a compact default main window frame on Windows", () => {
-    expect(defaultMainWindowFrame("win32")).toEqual(DEFAULT_WINDOWS_WINDOW_FRAME);
-    expect(defaultMainWindowFrame("darwin")).toEqual(DEFAULT_WINDOW_FRAME);
-  });
-});

package/src/renderers/electrobun/view/application-menu-bridge.ts

@@ -1,12 +0,0 @@
-import type { DesktopApplicationMenuBridge } from "../../../types/desktop-menu";
-import { onApplicationMenuSelect } from "./backend-rpc";
-
-export function createApplicationMenuBridge(): DesktopApplicationMenuBridge {
-  return {
-    subscribe(listener) {
-      return onApplicationMenuSelect((message) => {
-        listener(message.command);
-      });
-    },
-  };
-}

package/src/renderers/electrobun/view/cli-pane-shot-frame.test.tsx

@@ -1,76 +0,0 @@
-/** @jsxImportSource react */
-import { expect, test } from "bun:test";
-import { act, useState } from "react";
-import { PaneFooterScope, usePaneFooter } from "../../../components/layout/pane/footer";
-import { usePaneNoticeFooter } from "../../../components/use-pane-notice-footer";
-import { UiHostProvider, type RendererHost } from "../../../ui";
-import { createDomUiHost } from "./dom-ui-host";
-import { WebInputHostProvider } from "./input-host";
-import { WebDialogHostProvider } from "./dialog-host";
-import { createDomTestHarness } from "./test-utils";
-import { PaneShotFrame } from "./cli-pane-shot-frame";
-import { nativePaneFooterRows, nativePaneHeaderRows } from "../../../components/layout/pane/sizing";
-
-const { render } = createDomTestHarness({ withUi: false });
-const renderer: RendererHost = {
-  requestExit() {}, async openExternal() {}, async copyText() {},
-  async readText() { return ""; }, notify() {},
-};
-
-function Source({ warning }: { warning: boolean }) {
-  usePaneNoticeFooter({ registrationId: "shot-notice", notices: warning ? ["Source publication date unavailable."] : [], focused: true });
-  usePaneFooter("shot-actions", () => ({
-    info: [{ id: "loading", parts: [{ text: "Loading a normal source" }] }],
-    hints: [{ id: "refresh", key: "r", label: "efresh", onPress() {} }],
-  }), []);
-  return <div>Research data</div>;
-}
-
-test("pane screenshots retain warnings, optionally preserve source status and reclaim empty footers", async () => {
-  const ui = createDomUiHost();
-  let update: (value: { warning: boolean; active: boolean; preserveStatus?: boolean }) => void = () => {};
-  function Harness() {
-    const [state, setState] = useState<{ warning: boolean; active: boolean; preserveStatus?: boolean }>({ warning: false, active: true });
-    update = setState;
-    return <UiHostProvider ui={ui} renderer={renderer}>
-      <WebInputHostProvider><WebDialogHostProvider>
-        <PaneShotFrame paneId="shot" title="Research" width={40} height={24} preserveStatus={state.preserveStatus}>
-          {(frame) => <div data-body-height={frame.height}>
-            <PaneFooterScope active={state.active}><Source warning={state.warning} /></PaneFooterScope>
-          </div>}
-        </PaneShotFrame>
-      </WebDialogHostProvider></WebInputHostProvider>
-    </UiHostProvider>;
-  }
-  const root = await render(<Harness />);
-  const bodyHeight = () => Number(root.querySelector("[data-body-height]")?.getAttribute("data-body-height"));
-  // 24 rows less the desktop header, and less the footer row when one shows.
-  const withoutFooter = 24 - nativePaneHeaderRows();
-  const withFooter = withoutFooter - nativePaneFooterRows();
-  expect(root.textContent).toContain("Research data");
-  expect(root.querySelector('[data-gloom-role="pane-footer"]')).toBeNull();
-  expect(bodyHeight()).toBeCloseTo(withoutFooter);
-
-  await act(async () => update({ warning: true, active: true }));
-  expect(root.querySelector('button[aria-label="Data warnings"] svg')).not.toBeNull();
-  expect(root.querySelector('[data-gloom-role="pane-footer"]')).not.toBeNull();
-  expect(root.textContent).not.toContain("Source publication date unavailable.");
-  expect(root.textContent).not.toContain("Loading a normal source");
-  expect(root.querySelector('[data-gloom-role="pane-hint"]')).toBeNull();
-  expect(bodyHeight()).toBeCloseTo(withFooter);
-
-  await act(async () => update({ warning: true, active: false }));
-  expect(root.querySelector('[data-gloom-role="pane-footer"]')).toBeNull();
-  expect(bodyHeight()).toBeCloseTo(withoutFooter);
-
-  await act(async () => update({ warning: true, active: true }));
-  expect(root.querySelector('button[aria-label="Data warnings"]')).not.toBeNull();
-  await act(async () => update({ warning: false, active: true }));
-  expect(root.querySelector('[data-gloom-role="pane-footer"]')).toBeNull();
-  expect(bodyHeight()).toBeCloseTo(withoutFooter);
-
-  await act(async () => update({ warning: false, active: true, preserveStatus: true }));
-  expect(root.textContent).toContain("Loading a normal source");
-  expect(root.querySelector('[data-gloom-role="pane-hint"]')).toBeNull();
-  expect(bodyHeight()).toBeCloseTo(withFooter);
-});

package/src/renderers/electrobun/view/cli-pane-shot-health.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createCliPaneShotConnectionHealth } from "./cli-pane-shot-health";
-
-describe("CLI pane shot connection health", () => {
-  test("seeds stable request, socket, and error rows", () => {
-    const sources = createCliPaneShotConnectionHealth(1_000).getSnapshot().sources;
-
-    expect(sources.map((source) => source.id)).toEqual([
-      "gloom-cloud-http",
-      "gloom-cloud-socket",
-      "gloom-cloud-fred",
-      "asset-data.yahoo",
-    ]);
-    expect(sources.map((source) => ({
-      status: source.status,
-      operation: source.lastOperation,
-      latency: source.lastLatencyMs,
-    }))).toEqual([
-      { status: "connected", operation: "GET /market/quotes", latency: 84 },
-      { status: "connected", operation: null, latency: null },
-      { status: "idle", operation: null, latency: null },
-      { status: "error", operation: "getPriceHistory", latency: 240 },
-    ]);
-  });
-});

package/src/renderers/electrobun/view/context-menu.test.ts

@@ -1,146 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { contextMenuDivider, type ContextMenuItem } from "../../../types/context-menu";
-import { ELECTROBUN_CONTEXT_MENU_ACTION } from "../shared/protocol";
-import {
-  DesktopContextMenuActionScope,
-  prepareDesktopContextMenu,
-  type DesktopContextMenuSelectMessage,
-} from "./context-menu";
-
-describe("Electrobun desktop context menu serialization", () => {
-  test("preserves roles, dividers, submenu state, accelerators, and checked state", () => {
-    const items: ContextMenuItem[] = [
-      { type: "role", role: "copy", label: "Copy", accelerator: "CmdOrCtrl+C" },
-      contextMenuDivider(),
-      {
-        id: "tools",
-        label: "Tools",
-        enabled: true,
-        checked: true,
-        accelerator: "CmdOrCtrl+T",
-        tooltip: "Open tools",
-        submenu: [
-          { id: "nested", label: "Nested", enabled: false },
-        ],
-      },
-    ];
-
-    const prepared = prepareDesktopContextMenu(items, "request-1");
-
-    expect(prepared.menu).toEqual([
-      {
-        type: "normal",
-        label: "Copy",
-        role: "copy",
-        enabled: undefined,
-        checked: undefined,
-        hidden: undefined,
-        tooltip: undefined,
-        accelerator: "CmdOrCtrl+C",
-      },
-      { type: "divider" },
-      {
-        type: "normal",
-        label: "Tools",
-        tooltip: "Open tools",
-        enabled: true,
-        checked: true,
-        hidden: undefined,
-        accelerator: "CmdOrCtrl+T",
-        action: undefined,
-        data: undefined,
-        submenu: [
-          {
-            type: "normal",
-            label: "Nested",
-            tooltip: undefined,
-            enabled: false,
-            checked: undefined,
-            hidden: undefined,
-            accelerator: undefined,
-            action: undefined,
-            data: undefined,
-            submenu: undefined,
-          },
-        ],
-      },
-    ]);
-    expect(prepared.actions.size).toBe(0);
-  });
-
-  test("custom action items get request-scoped action data and roles do not register callbacks", () => {
-    const action = () => {};
-    const prepared = prepareDesktopContextMenu([
-      { type: "role", role: "paste" },
-      { id: "open", label: "Open", onSelect: action },
-    ], "request-2");
-
-    expect(prepared.menu[0]).toMatchObject({ role: "paste" });
-    expect(prepared.menu[1]).toMatchObject({
-      action: `${ELECTROBUN_CONTEXT_MENU_ACTION}:request-2:open`,
-      data: { requestId: "request-2", itemId: "open" },
-    });
-    expect(prepared.actions.get("open")).toBe(action);
-    expect(prepared.actions.size).toBe(1);
-  });
-});
-
-describe("DesktopContextMenuActionScope", () => {
-  test("selection messages call the matching callback once", () => {
-    let listener: ((message: DesktopContextMenuSelectMessage) => void) | null = null;
-    let disposeCount = 0;
-    let runCount = 0;
-    const scope = new DesktopContextMenuActionScope(
-      (_requestId, nextListener) => {
-        listener = nextListener;
-        return () => {
-          disposeCount += 1;
-        };
-      },
-      1000,
-      (() => 1) as never,
-      (() => {}) as never,
-    );
-
-    scope.bind("request-3", new Map([["item", () => { runCount += 1; }]]));
-    const emitSelection = listener as ((message: DesktopContextMenuSelectMessage) => void) | null;
-    expect(emitSelection).toBeTruthy();
-    emitSelection?.({ requestId: "request-3", itemId: "item" });
-    emitSelection?.({ requestId: "request-3", itemId: "item" });
-
-    expect(runCount).toBe(1);
-    expect(disposeCount).toBe(1);
-  });
-
-  test("stale callbacks are cleaned up after the timeout", () => {
-    let listener: ((message: DesktopContextMenuSelectMessage) => void) | null = null;
-    let timeoutCallback: (() => void) | null = null;
-    let disposeCount = 0;
-    let runCount = 0;
-    const scope = new DesktopContextMenuActionScope(
-      (_requestId, nextListener) => {
-        listener = nextListener;
-        return () => {
-          disposeCount += 1;
-        };
-      },
-      1000,
-      ((callback: () => void) => {
-        timeoutCallback = callback;
-        return 1;
-      }) as never,
-      (() => {}) as never,
-    );
-
-    scope.bind("request-4", new Map([["item", () => { runCount += 1; }]]));
-    const expireSelection = timeoutCallback as (() => void) | null;
-    const emitSelection = listener as ((message: DesktopContextMenuSelectMessage) => void) | null;
-    expect(expireSelection).toBeTruthy();
-    expect(emitSelection).toBeTruthy();
-    expireSelection?.();
-    emitSelection?.({ requestId: "request-4", itemId: "item" });
-
-    expect(disposeCount).toBe(1);
-    expect(runCount).toBe(0);
-  });
-});

package/src/renderers/electrobun/view/data-table/frozen-column.test.tsx

@@ -1,73 +0,0 @@
-/** @jsxImportSource react */
-import { expect, test } from "bun:test";
-import { act, createRef, useState } from "react";
-import { DataTableView } from "../../../../components/data-table/view";
-import { AppContext, createInitialState } from "../../../../state/app/context";
-import { createDefaultConfig } from "../../../../types/config";
-import { UiHostProvider, useRendererHost, useUiHost } from "../../../../ui";
-import type { ScrollBoxRenderable } from "../../../../ui/host";
-import { WEB_CELL_WIDTH, WebInputHostProvider } from "../input-host";
-import { createDomTestHarness } from "../test-utils";
-import { WebDataTable } from ".";
-
-const { window: testWindow, render } = createDomTestHarness();
-
-test("DOM fixed axis fits covered values with ellipses and preserves selection, scrolling and ordinary tables", async () => {
-  const bodyRef = createRef<ScrollBoxRenderable>();
-  const headerRef = createRef<ScrollBoxRenderable>();
-  const state = createInitialState(createDefaultConfig("/tmp/gloom-dom-frozen"));
-  let setFrozen: (value: boolean) => void = () => {};
-  const selections: string[] = [];
-  function Harness() {
-    const ui = useUiHost(); const renderer = useRendererHost();
-    const [frozen, updateFrozen] = useState(true); setFrozen = updateFrozen;
-    return <UiHostProvider ui={{ ...ui, DataTable: WebDataTable }} renderer={renderer}>
-      <WebInputHostProvider><AppContext value={{ state, dispatch: () => {} }}>
-        <DataTableView focused freezeFirstColumn={frozen} scrollRef={bodyRef} headerScrollRef={headerRef}
-          items={["JPY", "EUR"]}
-          columns={[{ id: "base", label: "", width: 5 }, ...["USD", "EUR", "GBP", "JPY", "CHF", "CAD", "AUD", "NZD"].map(id => ({ id, label: id, width: 10, align: "right" as const }))]}
-          selection={{ kind: "index", selectedIndex: 0, onChange: (_, item) => selections.push(item) }}
-          sortColumnId={null} sortDirection="asc" onHeaderClick={() => {}}
-          getItemKey={(row) => row} renderCell={(row, column) => ({ text: column.id === "base" ? row : "0.0053333" })}
-          emptyStateTitle="No rows" virtualize={false} />
-      </AppContext></WebInputHostProvider>
-    </UiHostProvider>;
-  }
-  const container = await render(<Harness />);
-  const body = container.querySelector('[data-gloom-role="data-table-body-scroll"]') as HTMLElement;
-  Object.defineProperty(body, "clientWidth", { configurable: true, value: 48 * WEB_CELL_WIDTH });
-  Object.defineProperty(body, "scrollWidth", { configurable: true, value: 96 * WEB_CELL_WIDTH });
-  const rows = Array.from(container.querySelectorAll('[data-gloom-role="data-table-row"], [data-gloom-role="data-table-header-row"]')) as HTMLElement[];
-  // happy-dom has no layout engine. The measured cells model the actual fixed
-  // first column and scrolled grid; text remains rendered by WebDataTable.
-  for (const row of rows) Array.from(row.children).forEach((cell, index) => {
-    cell.getBoundingClientRect = () => {
-      const left = index === 0 ? WEB_CELL_WIDTH : (7 + (index - 1) * 11) * WEB_CELL_WIDTH - body.scrollLeft;
-      const width = (index === 0 ? 5 : 10) * WEB_CELL_WIDTH;
-      return { left, right: left + width, width, x: left, top: 0, bottom: 18, height: 18, y: 0, toJSON: () => ({}) };
-    };
-  });
-  const scroll = async () => { await act(async () => { body.dispatchEvent(new testWindow.Event("scroll") as unknown as Event); }); };
-  await act(async () => { body.dispatchEvent(new testWindow.KeyboardEvent("keydown", { key: "ArrowRight", ctrlKey: true, bubbles: true, cancelable: true }) as unknown as Event); });
-  await scroll();
-  expect(bodyRef.current?.scrollLeft).toBe(24);
-  expect(headerRef.current?.scrollLeft).toBe(24);
-  for (const row of rows) {
-    const cells = Array.from(row.children) as HTMLElement[];
-    expect(cells[0]!.style.position).toBe("sticky");
-    expect(cells[0]!.style.left).toBe("8px");
-    expect(cells[3]!.style.paddingLeft).toBe("16px");
-    expect((cells[3]!.firstElementChild as HTMLElement).style.textOverflow).toBe("ellipsis");
-  }
-  const axis = rows[2]!.children[0] as HTMLElement;
-  await act(async () => { axis.dispatchEvent(new testWindow.MouseEvent("mousedown", { bubbles: true, cancelable: true }) as unknown as Event); });
-  expect(selections).toContain("EUR");
-  body.scrollLeft = 48 * WEB_CELL_WIDTH; await scroll();
-  expect(bodyRef.current?.scrollLeft).toBe(48);
-  expect(rows[1]!.textContent).toContain("JPY");
-  body.scrollLeft = 0; await scroll();
-  expect((rows[1]!.children[3] as HTMLElement).style.paddingLeft).toBe("0px");
-  await act(async () => setFrozen(false));
-  expect((rows[1]!.children[0] as HTMLElement).style.position).toBe("");
-  expect((rows[1]!.children[3] as HTMLElement).style.paddingLeft).toBe("");
-});

package/src/renderers/electrobun/view/data-table/horizontal-navigation.test.tsx

@@ -1,82 +0,0 @@
-/** @jsxImportSource react */
-import { expect, test } from "bun:test";
-import { act, createRef, useState } from "react";
-import { DataTableView } from "../../../../components/data-table/view";
-import { AppContext, createInitialState } from "../../../../state/app/context";
-import { createDefaultConfig } from "../../../../types/config";
-import { UiHostProvider, useRendererHost, useUiHost } from "../../../../ui";
-import type { ScrollBoxRenderable } from "../../../../ui/host";
-import { WEB_CELL_WIDTH, WebInputHostProvider } from "../input-host";
-import { createDomTestHarness } from "../test-utils";
-import { WebDataTable } from ".";
-
-const { window: testWindow, render } = createDomTestHarness();
-
-test("DOM table handles expose horizontal extent to shared keyboard navigation", async () => {
-  const bodyRef = createRef<ScrollBoxRenderable>();
-  const headerRef = createRef<ScrollBoxRenderable>();
-  const state = createInitialState(createDefaultConfig("/tmp/gloom-dom-horizontal"));
-  let setFocused: (value: boolean) => void = () => {};
-  function Harness() {
-    const ui = useUiHost();
-    const renderer = useRendererHost();
-    const [focused, updateFocused] = useState(true);
-    setFocused = updateFocused;
-    return <UiHostProvider ui={{ ...ui, DataTable: WebDataTable }} renderer={renderer}>
-      <WebInputHostProvider><AppContext value={{ state, dispatch: () => {} }}>
-        <DataTableView focused={focused} scrollRef={bodyRef} headerScrollRef={headerRef}
-          items={[{ symbol: "ALPH", value: "$100M" }]}
-          columns={[{ id: "symbol", label: "TICKER", width: 60 }, { id: "value", label: "VALUE", width: 40 }]}
-          selection={{ kind: "index", selectedIndex: 0, onChange: () => {} }}
-          sortColumnId={null} sortDirection="asc" onHeaderClick={() => {}}
-          getItemKey={(row) => row.symbol} renderCell={(row, column) => ({ text: column.id === "symbol" ? row.symbol : row.value })}
-          emptyStateTitle="No rows" virtualize={false} />
-      </AppContext></WebInputHostProvider>
-    </UiHostProvider>;
-  }
-  const container = await render(<Harness />);
-  const body = container.querySelector('[data-gloom-role="data-table-body-scroll"]') as HTMLElement;
-  // happy-dom has no layout engine; supply measured browser pixel dimensions.
-  Object.defineProperty(body, "clientWidth", { configurable: true, value: 40 * WEB_CELL_WIDTH });
-  Object.defineProperty(body, "scrollWidth", { configurable: true, value: 100 * WEB_CELL_WIDTH });
-  const press = async (key: string, options: { ctrlKey?: boolean; shiftKey?: boolean; target?: HTMLElement } = {}) => {
-    const event = new testWindow.KeyboardEvent("keydown", { key, bubbles: true, cancelable: true, ctrlKey: options.ctrlKey ?? true, shiftKey: options.shiftKey });
-    await act(async () => { (options.target ?? body).dispatchEvent(event as unknown as Event); });
-    return event.defaultPrevented;
-  };
-  expect(await press("ArrowRight")).toBe(true);
-  expect(body.scrollLeft).toBe(20 * WEB_CELL_WIDTH);
-  expect(bodyRef.current?.scrollWidth).toBe(100);
-  expect(headerRef.current?.scrollWidth).toBe(100);
-  expect(headerRef.current?.scrollLeft).toBe(bodyRef.current?.scrollLeft);
-  await press("ArrowRight");
-  await press("ArrowRight");
-  expect(body.scrollLeft).toBe(60 * WEB_CELL_WIDTH);
-  await press("ArrowRight");
-  expect(body.scrollLeft).toBe(60 * WEB_CELL_WIDTH);
-  expect(await press("ArrowLeft")).toBe(true);
-  expect(body.scrollLeft).toBe(40 * WEB_CELL_WIDTH);
-  expect(headerRef.current?.scrollLeft).toBe(40);
-  await press("ArrowRight", { ctrlKey: false });
-  expect(body.scrollLeft).toBe(40 * WEB_CELL_WIDTH);
-  await press("ArrowRight", { shiftKey: true });
-  expect(body.scrollLeft).toBe(40 * WEB_CELL_WIDTH);
-  // Shift+arrows scroll too: macOS takes Ctrl+arrows for Spaces.
-  expect(await press("ArrowLeft", { ctrlKey: false, shiftKey: true })).toBe(true);
-  expect(body.scrollLeft).toBe(20 * WEB_CELL_WIDTH);
-  await press("ArrowRight", { ctrlKey: false, shiftKey: true });
-  expect(body.scrollLeft).toBe(40 * WEB_CELL_WIDTH);
-  const input = testWindow.document.createElement("input") as unknown as HTMLInputElement;
-  container.appendChild(input);
-  expect(await press("ArrowRight", { target: input })).toBe(false);
-  expect(body.scrollLeft).toBe(40 * WEB_CELL_WIDTH);
-  await act(async () => setFocused(false));
-  await press("ArrowRight");
-  expect(body.scrollLeft).toBe(40 * WEB_CELL_WIDTH);
-  await act(async () => setFocused(true));
-  body.scrollLeft = 0;
-  Object.defineProperty(body, "scrollWidth", { configurable: true, value: 40 * WEB_CELL_WIDTH });
-  expect(bodyRef.current?.scrollWidth).toBe(40);
-  await press("ArrowRight");
-  expect(body.scrollLeft).toBe(0);
-});