gloomberb 0.9.2 → 0.9.4

package/src/components/layout/pane/sizing.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import { resolvePaneBodyFrame, shouldReservePaneFooter } from "./sizing";
+
+describe("pane sizing", () => {
+  test("lets native pane chrome lay out footer bars in normal flex flow", () => {
+    expect(shouldReservePaneFooter(true, true)).toBe(false);
+
+    const bodyFrame = resolvePaneBodyFrame({
+      width: 80,
+      height: 30,
+      nativePaneChrome: true,
+      footerVisible: true,
+      reserveFooter: false,
+    });
+
+    expect(bodyFrame.height).toBe(28);
+    expect(bodyFrame.layoutProps).toEqual({
+      flexGrow: 1,
+      flexShrink: 1,
+      flexBasis: 0,
+      minWidth: 0,
+      minHeight: 0,
+    });
+  });
+
+  test("keeps terminal pane footer rows reserved for border rendering", () => {
+    expect(shouldReservePaneFooter(false, false)).toBe(true);
+
+    const bodyFrame = resolvePaneBodyFrame({
+      width: 80,
+      height: 30,
+      nativePaneChrome: false,
+      reserveFooter: true,
+    });
+
+    expect(bodyFrame.height).toBe(28);
+    expect(bodyFrame.layoutProps).toEqual({
+      height: 28,
+      flexGrow: 0,
+      flexBasis: undefined,
+    });
+  });
+});

package/src/components/layout/pane/sizing.ts

@@ -4,28 +4,35 @@ const PANE_FOOTER_ROWS = 1;
 
 const NATIVE_PANE_BODY_LAYOUT_PROPS = {
   flexGrow: 1,
+  flexShrink: 1,
   flexBasis: 0,
+  minWidth: 0,
   minHeight: 0,
 } as const;
 
-export function shouldReservePaneFooter(nativePaneChrome: boolean | undefined, showFooter: boolean): boolean {
-  return !nativePaneChrome || showFooter;
+export function shouldReservePaneFooter(nativePaneChrome: boolean | undefined, _showFooter: boolean): boolean {
+  return !nativePaneChrome;
 }
 
 function resolvePaneBodyHeight({
   height,
   nativePaneChrome,
+  footerVisible,
   reserveFooter = true,
   headerRows = PANE_HEADER_ROWS,
 }: {
   height: number;
   nativePaneChrome?: boolean;
+  footerVisible?: boolean;
   reserveFooter?: boolean;
   headerRows?: number;
 }): number {
   const finiteHeight = Number.isFinite(height) ? height : 1;
   const normalizedHeight = nativePaneChrome ? finiteHeight : Math.max(1, Math.floor(finiteHeight));
-  return Math.max(1, normalizedHeight - headerRows - (reserveFooter ? PANE_FOOTER_ROWS : 0));
+  const footerRows = nativePaneChrome
+    ? footerVisible ? PANE_FOOTER_ROWS : 0
+    : reserveFooter ? PANE_FOOTER_ROWS : 0;
+  return Math.max(1, normalizedHeight - headerRows - footerRows);
 }
 
 function getPaneBodyLayoutProps(nativePaneChrome: boolean | undefined, bodyHeight: number | undefined) {
@@ -41,17 +48,19 @@ export function resolvePaneBodyFrame({
   width,
   height,
   nativePaneChrome,
+  footerVisible,
   reserveFooter = true,
   headerRows = PANE_HEADER_ROWS,
 }: {
   width?: number;
   height?: number;
   nativePaneChrome?: boolean;
+  footerVisible?: boolean;
   reserveFooter?: boolean;
   headerRows?: number;
 }) {
   const bodyHeight = typeof height === "number"
-    ? resolvePaneBodyHeight({ height, nativePaneChrome, reserveFooter, headerRows })
+    ? resolvePaneBodyHeight({ height, nativePaneChrome, footerVisible, reserveFooter, headerRows })
     : undefined;
   return {
     width: typeof width === "number" ? resolvePaneBodyWidth(width, nativePaneChrome) : undefined,

package/src/components/layout/shell/active-drag.ts

@@ -4,6 +4,7 @@ import {
   getRememberedFloatingRect,
   resizeSplitAtPath,
   simulateDrop,
+  type DockGeometryOptions,
   type DockLeafLayout,
   type DropTarget,
   type LayoutBounds,
@@ -32,6 +33,7 @@ interface UseShellActiveDragOptions {
   bounds: LayoutBounds;
   contentHeight: number;
   dispatch: Dispatch<AppAction>;
+  dockGeometryOptions: DockGeometryOptions;
   dockLeafLayouts: DockLeafLayout[];
   dragRuntime: ShellDragRuntimeState;
   focusPane: (paneId: string) => void;
@@ -51,6 +53,7 @@ export function useShellActiveDrag({
   bounds,
   contentHeight,
   dispatch,
+  dockGeometryOptions,
   dockLeafLayouts,
   dragRuntime,
   focusPane,
@@ -117,7 +120,7 @@ export function useShellActiveDrag({
           const hoveredCell = hoveredOverlay.cells.find((cell) => pointInRect(cell.rect, hitX, hitShellY));
           if (hoveredCell) {
             const target: DropTarget = { kind: "leaf", targetId: hoveredOverlay.targetId, position: hoveredCell.position };
-            const simulation = simulateDrop(baseLayout, drag.paneId, target, bounds);
+            const simulation = simulateDrop(baseLayout, drag.paneId, target, bounds, dockGeometryOptions);
             if (simulation.previewRect) {
               updateDockPreview({ kind: "dock", target, rect: simulation.previewRect });
             } else {
@@ -199,6 +202,7 @@ export function useShellActiveDrag({
     bounds,
     contentHeight,
     dispatch,
+    dockGeometryOptions,
     dividerPreviewRef,
     dockLeafLayouts,
     dockPreviewRef,

package/src/components/layout/shell/cursor-occlusion.ts

@@ -0,0 +1,196 @@
+import { useEffect, useRef, type RefObject } from "react";
+import { useNativeRenderer, type NativeCursorState, type NativePostProcessFn } from "../../../ui";
+import type { FloatingRect, LayoutBounds, ResolvedPane } from "../../../plugins/pane-manager";
+import { constrainFloatingRectToBounds } from "./drag";
+
+interface VisibleFloatingPane {
+  pane: ResolvedPane;
+  rect: FloatingRect;
+}
+
+export interface ShellCursorOcclusionRect extends LayoutBounds {
+  paneId: string;
+  zIndex: number;
+}
+
+interface ResolveShellCursorOcclusionRectsOptions {
+  contentHeight: number;
+  dragFloatingRect: { paneId: string; rect: FloatingRect } | null;
+  nativePaneChrome: boolean;
+  overlayOpen: boolean;
+  transientFocusActive: boolean;
+  visibleFloatingPanes: readonly VisibleFloatingPane[];
+  width: number;
+}
+
+export function resolveShellCursorOcclusionRects({
+  contentHeight,
+  dragFloatingRect,
+  nativePaneChrome,
+  overlayOpen,
+  transientFocusActive,
+  visibleFloatingPanes,
+  width,
+}: ResolveShellCursorOcclusionRectsOptions): ShellCursorOcclusionRect[] {
+  if (nativePaneChrome || overlayOpen || transientFocusActive || visibleFloatingPanes.length === 0) {
+    return [];
+  }
+
+  return visibleFloatingPanes.map(({ pane, rect }) => {
+    const paneId = pane.instance.instanceId;
+    const visibleRect = dragFloatingRect?.paneId === paneId
+      ? constrainFloatingRectToBounds(dragFloatingRect.rect, width, contentHeight)
+      : rect;
+    return {
+      paneId,
+      zIndex: pane.floating?.zIndex ?? 50,
+      x: Math.floor(visibleRect.x),
+      y: Math.floor(visibleRect.y),
+      width: Math.max(0, Math.ceil(visibleRect.width)),
+      height: Math.max(0, Math.ceil(visibleRect.height)),
+    };
+  });
+}
+
+function readRenderableBounds(renderable: unknown): LayoutBounds | null {
+  if (!renderable || typeof renderable !== "object") return null;
+  const record = renderable as Record<string, unknown>;
+  const getRect = record.getBoundingClientRect;
+  if (typeof getRect === "function") {
+    const rect = getRect.call(renderable) as Partial<LayoutBounds> | null | undefined;
+    if (
+      rect
+      && typeof rect.x === "number"
+      && typeof rect.y === "number"
+      && typeof rect.width === "number"
+      && typeof rect.height === "number"
+    ) {
+      return rect as LayoutBounds;
+    }
+  }
+
+  const absoluteBounds = record.absoluteBounds as Partial<LayoutBounds> | null | undefined;
+  if (
+    absoluteBounds
+    && typeof absoluteBounds.x === "number"
+    && typeof absoluteBounds.y === "number"
+    && typeof absoluteBounds.width === "number"
+    && typeof absoluteBounds.height === "number"
+  ) {
+    return absoluteBounds as LayoutBounds;
+  }
+
+  const x = typeof record.screenX === "number"
+    ? record.screenX
+    : typeof record.absoluteX === "number"
+      ? record.absoluteX
+      : typeof record.x === "number"
+        ? record.x
+        : null;
+  const y = typeof record.screenY === "number"
+    ? record.screenY
+    : typeof record.absoluteY === "number"
+      ? record.absoluteY
+      : typeof record.y === "number"
+        ? record.y
+        : null;
+  const width = typeof record.width === "number" ? record.width : null;
+  const height = typeof record.height === "number" ? record.height : null;
+  if (x == null || y == null || width == null || height == null) return null;
+  return { x, y, width, height };
+}
+
+function readRenderablePaneId(renderable: unknown): string | null {
+  let current = renderable;
+  while (current && typeof current === "object") {
+    const record = current as Record<string, unknown>;
+    const paneId = record["data-gloom-pane-id"];
+    if (typeof paneId === "string") return paneId;
+    current = record.parent;
+  }
+  return null;
+}
+
+function rectContainsCursor(rect: LayoutBounds, cursor: NativeCursorState): boolean {
+  return cursor.x >= rect.x
+    && cursor.x < rect.x + rect.width
+    && cursor.y >= rect.y
+    && cursor.y < rect.y + rect.height;
+}
+
+function toTerminalRect(shellBounds: LayoutBounds, rect: ShellCursorOcclusionRect): ShellCursorOcclusionRect {
+  return {
+    ...rect,
+    x: Math.floor(shellBounds.x + rect.x + 1),
+    y: Math.floor(shellBounds.y + rect.y + 1),
+  };
+}
+
+function resolveCursorOwnerZIndex(
+  cursorOwnerPaneId: string | null,
+  rects: readonly ShellCursorOcclusionRect[],
+): number {
+  if (!cursorOwnerPaneId) return Number.NEGATIVE_INFINITY;
+  return rects.find((rect) => rect.paneId === cursorOwnerPaneId)?.zIndex ?? 0;
+}
+
+function shouldHideCursor({
+  cursor,
+  cursorOwnerPaneId,
+  terminalRects,
+}: {
+  cursor: NativeCursorState;
+  cursorOwnerPaneId: string | null;
+  terminalRects: readonly ShellCursorOcclusionRect[];
+}): boolean {
+  const ownerZIndex = resolveCursorOwnerZIndex(cursorOwnerPaneId, terminalRects);
+  return terminalRects.some((rect) => {
+    if (rect.paneId === cursorOwnerPaneId) return false;
+    if (rect.zIndex <= ownerZIndex) return false;
+    return rectContainsCursor(rect, cursor);
+  });
+}
+
+export function useShellCursorOcclusionGuard({
+  occlusionRects,
+  shellRef,
+}: {
+  occlusionRects: readonly ShellCursorOcclusionRect[];
+  shellRef: RefObject<unknown>;
+}) {
+  const nativeRenderer = useNativeRenderer();
+  const stateRef = useRef({ occlusionRects, shellRef });
+  stateRef.current = { occlusionRects, shellRef };
+
+  useEffect(() => {
+    if (
+      !nativeRenderer.addPostProcessFn
+      || !nativeRenderer.removePostProcessFn
+      || !nativeRenderer.getCursorState
+      || !nativeRenderer.setCursorPosition
+    ) {
+      return;
+    }
+
+    const guardCursor: NativePostProcessFn = () => {
+      const cursor = nativeRenderer.getCursorState?.();
+      if (!cursor?.visible) return;
+      const shellBounds = readRenderableBounds(stateRef.current.shellRef.current);
+      if (!shellBounds) return;
+
+      const terminalRects = stateRef.current.occlusionRects.map((rect) => toTerminalRect(shellBounds, rect));
+      if (terminalRects.length === 0) return;
+
+      const cursorOwnerPaneId = readRenderablePaneId(nativeRenderer.currentFocusedEditor);
+      if (!shouldHideCursor({ cursor, cursorOwnerPaneId, terminalRects })) return;
+      nativeRenderer.setCursorPosition?.(0, 0, false);
+    };
+
+    nativeRenderer.addPostProcessFn(guardCursor);
+    nativeRenderer.requestRender();
+    return () => {
+      nativeRenderer.removePostProcessFn?.(guardCursor);
+      nativeRenderer.requestRender();
+    };
+  }, [nativeRenderer]);
+}

package/src/components/layout/shell/drag/runtime.ts

@@ -6,8 +6,10 @@ import {
   type MutableRefObject,
   type SetStateAction,
 } from "react";
+import { useRafCallback } from "../../../../react/use-raf-callback";
 import {
   type DockDividerLayout,
+  type DockGeometryOptions,
   type DockLeafLayout,
   type FloatingRect,
   type LayoutBounds,
@@ -84,24 +86,40 @@ export interface ShellDragRuntimeState {
 
 export function useShellDragRuntimeState({
   contentHeight,
+  throttleFloatingPreview = false,
   width,
 }: {
   contentHeight: number;
+  throttleFloatingPreview?: boolean;
   width: number;
 }): ShellDragRuntimeState {
   const dragRef = useRef<DragMode | null>(null);
   const [dragFloatingRect, setDragFloatingRect] = useState<{ paneId: string; rect: FloatingRect } | null>(null);
+  const pendingDragFloatingRectRef = useRef<{ paneId: string; rect: FloatingRect } | null>(null);
   const [dragCursor, setDragCursor] = useState<{ x: number; y: number } | null>(null);
   const [dividerPreview, setDividerPreview] = useState<DividerPreviewState | null>(null);
   const [dockPreview, setDockPreview] = useState<DragPreview | null>(null);
   const dividerPreviewRef = useRef<DividerPreviewState | null>(null);
   const dockPreviewRef = useRef<DragPreview | null>(null);
+  const flushDragFloatingRect = useRafCallback(() => {
+    setDragFloatingRect(pendingDragFloatingRectRef.current);
+  });
 
   const updateDragFloatingRect = useCallback((next: { paneId: string; rect: FloatingRect } | null) => {
-    setDragFloatingRect(next
+    const constrainedNext = next
       ? { paneId: next.paneId, rect: constrainFloatingRectToBounds(next.rect, width, contentHeight) }
-      : null);
-  }, [contentHeight, width]);
+      : null;
+    pendingDragFloatingRectRef.current = constrainedNext;
+    if (!next) {
+      setDragFloatingRect(null);
+      return;
+    }
+    if (!throttleFloatingPreview) {
+      setDragFloatingRect(constrainedNext);
+      return;
+    }
+    flushDragFloatingRect();
+  }, [contentHeight, flushDragFloatingRect, throttleFloatingPreview, width]);
 
   const updateDividerPreview = useCallback((next: DividerPreviewState | null) => {
     dividerPreviewRef.current = next;
@@ -146,6 +164,7 @@ interface UseShellPointerRuntimeOptions {
   closePaneMenu: () => void;
   contentHeight: number;
   dispatch: Dispatch<AppAction>;
+  dockGeometryOptions: DockGeometryOptions;
   dockDividerLayouts: DockDividerLayout[];
   dockLeafLayouts: DockLeafLayout[];
   dragRuntime: ShellDragRuntimeState;
@@ -166,6 +185,7 @@ interface UseShellPointerRuntimeOptions {
   setHoveredMenuItemId: Dispatch<SetStateAction<string | null>>;
   setMenuState: Dispatch<SetStateAction<ActionMenuState | null>>;
   snapGuides: ReturnType<typeof makeSnapGuides>;
+  transientFocusActive: boolean;
   updateWindowModePreviewLayout: (nextLayout: LayoutConfig, paneId?: string) => void;
   visibleFloatingPanes: VisibleFloatingPane[];
   visibleLayout: LayoutConfig;
@@ -179,6 +199,7 @@ export function useShellPointerRuntime({
   closePaneMenu,
   contentHeight,
   dispatch,
+  dockGeometryOptions,
   dockDividerLayouts,
   dockLeafLayouts,
   dragRuntime,
@@ -195,6 +216,7 @@ export function useShellPointerRuntime({
   setHoveredMenuItemId,
   setMenuState,
   snapGuides,
+  transientFocusActive,
   updateWindowModePreviewLayout,
   visibleFloatingPanes,
   visibleLayout,
@@ -206,6 +228,7 @@ export function useShellPointerRuntime({
     bounds,
     contentHeight,
     dispatch,
+    dockGeometryOptions,
     dockLeafLayouts,
     focusPane,
     dragRuntime,
@@ -237,6 +260,7 @@ export function useShellPointerRuntime({
     selectWindowModePane,
     setHoveredMenuItemId,
     setMenuState,
+    transientFocusActive,
     visibleFloatingPanes,
     width,
     windowMode,
@@ -254,6 +278,7 @@ export function useShellPointerRuntime({
     selectWindowModePane,
     setHoveredMenuItemId,
     setMenuState,
+    transientFocusActive,
     windowMode,
   });
 

package/src/components/layout/shell/fullscreen.ts

@@ -0,0 +1,10 @@
+import { isPaneInLayout } from "../../../plugins/pane-manager";
+import { cloneLayout, type LayoutConfig } from "../../../types/config";
+
+export function resolvePaneFocusSourceLayout(
+  layout: LayoutConfig,
+  paneId: string | null,
+): LayoutConfig | null {
+  if (!paneId || !isPaneInLayout(layout, paneId)) return null;
+  return cloneLayout(layout);
+}