gloomberb 0.7.5 → 0.8.0

package/src/plugins/pane-manager/docking.ts

@@ -0,0 +1,202 @@
+import type { LayoutConfig, PaneInstanceConfig } from "../../types/config";
+import { findPaneInstance } from "../../types/config";
+import {
+  buildSplitAroundNode,
+  clampRatio,
+  findDockLeaf,
+  getNodeAtPath,
+  replaceNodeAtPath,
+  type DockTarget,
+  type LayoutBounds,
+} from "./dock-tree";
+import type { DropTarget, LeafDropPosition, LayoutSimulation } from "./types";
+import { getLeafRect } from "./queries";
+import { detachPane, ensurePaneInstance, finalizeLayout } from "./layout-state";
+
+function insertRelativeToSubtreePath(
+  layout: LayoutConfig,
+  instanceId: string,
+  targetPath: Array<0 | 1>,
+  position: DockTarget["position"],
+): LayoutConfig {
+  const base = detachPane(layout, instanceId);
+  if (!base.dockRoot) {
+    return finalizeLayout({ ...base, dockRoot: { kind: "pane", instanceId } });
+  }
+
+  let candidatePath = [...targetPath];
+  let targetNode = getNodeAtPath(base.dockRoot, candidatePath);
+  while (!targetNode && candidatePath.length > 0) {
+    candidatePath = candidatePath.slice(0, -1);
+    targetNode = getNodeAtPath(base.dockRoot, candidatePath);
+  }
+
+  if (!targetNode) {
+    return finalizeLayout({
+      ...base,
+      dockRoot: buildSplitAroundNode(base.dockRoot, instanceId, position),
+    });
+  }
+
+  const replacement = buildSplitAroundNode(targetNode, instanceId, position);
+  return finalizeLayout({
+    ...base,
+    dockRoot: replaceNodeAtPath(base.dockRoot, candidatePath, replacement),
+  });
+}
+
+function normalizeDropPosition(position: LeafDropPosition): "left" | "right" | "top" | "bottom" | "center" {
+  switch (position) {
+    case "top-left":
+    case "top-right":
+      return "top";
+    case "bottom-left":
+    case "bottom-right":
+      return "bottom";
+    default:
+      return position;
+  }
+}
+
+function insertRelativeToLeaf(layout: LayoutConfig, instanceId: string, targetId: string, position: DockTarget["position"]): LayoutConfig {
+  if (instanceId === targetId) return layout;
+  const base = detachPane(layout, instanceId);
+  const targetLeaf = findDockLeaf(base, targetId);
+  if (!targetLeaf || !base.dockRoot) return layout;
+  const targetNode = getNodeAtPath(base.dockRoot, targetLeaf.path);
+  if (!targetNode) return layout;
+  return finalizeLayout({
+    ...base,
+    dockRoot: replaceNodeAtPath(base.dockRoot, targetLeaf.path, buildSplitAroundNode(targetNode, instanceId, position)),
+  });
+}
+
+export function insertAtRootEdge(layout: LayoutConfig, instanceId: string, edge: "left" | "right" | "top" | "bottom"): LayoutConfig {
+  const base = detachPane(layout, instanceId);
+  if (!base.dockRoot) {
+    return finalizeLayout({ ...base, dockRoot: { kind: "pane", instanceId } });
+  }
+  return finalizeLayout({
+    ...base,
+    dockRoot: buildSplitAroundNode(base.dockRoot, instanceId, edge === "top" ? "above" : edge === "bottom" ? "below" : edge),
+  });
+}
+
+function dockAtTarget(layout: LayoutConfig, instanceId: string, target: DockTarget): LayoutConfig {
+  return insertRelativeToLeaf(layout, instanceId, target.relativeTo, target.position);
+}
+
+export function dockPane(layout: LayoutConfig, instanceId: string, target?: DockTarget): LayoutConfig {
+  if (target) return dockAtTarget(layout, instanceId, target);
+
+  const instance = findPaneInstance(layout, instanceId);
+  const dockedMemory = instance?.placementMemory?.docked;
+  if (dockedMemory?.position && dockedMemory.path && dockedMemory.path.length > 0) {
+    return insertRelativeToSubtreePath(layout, instanceId, dockedMemory.path.slice(0, -1), dockedMemory.position);
+  }
+  if (dockedMemory?.anchorInstanceId && dockedMemory.position && findDockLeaf(layout, dockedMemory.anchorInstanceId)) {
+    return insertRelativeToLeaf(layout, instanceId, dockedMemory.anchorInstanceId, dockedMemory.position);
+  }
+  if (!layout.dockRoot) {
+    return finalizeLayout({ ...detachPane(layout, instanceId), dockRoot: { kind: "pane", instanceId } });
+  }
+  return insertAtRootEdge(layout, instanceId, "right");
+}
+
+export function applyDrop(layout: LayoutConfig, draggedId: string, dropTarget: DropTarget): LayoutConfig {
+  if (dropTarget.kind === "frame") {
+    return insertAtRootEdge(layout, draggedId, dropTarget.edge);
+  }
+
+  const normalized = normalizeDropPosition(dropTarget.position);
+  if (normalized === "center") {
+    return swapPanes(layout, draggedId, dropTarget.targetId);
+  }
+  const direction = normalized === "top" ? "above" : normalized === "bottom" ? "below" : normalized;
+  return insertRelativeToLeaf(layout, draggedId, dropTarget.targetId, direction);
+}
+
+export function simulateDrop(layout: LayoutConfig, draggedId: string, dropTarget: DropTarget, bounds: LayoutBounds): LayoutSimulation {
+  const nextLayout = applyDrop(layout, draggedId, dropTarget);
+  return {
+    layout: nextLayout,
+    previewRect: getLeafRect(nextLayout, draggedId, bounds),
+  };
+}
+
+export function swapPanes(layout: LayoutConfig, firstId: string, secondId: string): LayoutConfig {
+  if (firstId === secondId) return layout;
+  const firstLeaf = findDockLeaf(layout, firstId);
+  const secondLeaf = findDockLeaf(layout, secondId);
+  const firstFloating = layout.floating.find((entry) => entry.instanceId === firstId);
+  const secondFloating = layout.floating.find((entry) => entry.instanceId === secondId);
+  if (!firstLeaf && !firstFloating) return layout;
+  if (!secondLeaf && !secondFloating) return layout;
+
+  if (firstLeaf && secondLeaf && layout.dockRoot) {
+    const firstNode = getNodeAtPath(layout.dockRoot, firstLeaf.path);
+    const secondNode = getNodeAtPath(layout.dockRoot, secondLeaf.path);
+    if (!firstNode || !secondNode || firstNode.kind !== "pane" || secondNode.kind !== "pane") return layout;
+    const withFirst = replaceNodeAtPath(layout.dockRoot, firstLeaf.path, { kind: "pane", instanceId: secondId });
+    const withSecond = replaceNodeAtPath(withFirst, secondLeaf.path, { kind: "pane", instanceId: firstId });
+    return finalizeLayout({ ...layout, dockRoot: withSecond });
+  }
+
+  if (firstFloating && secondFloating) {
+    return finalizeLayout({
+      ...layout,
+      floating: layout.floating.map((entry) => {
+        if (entry.instanceId === firstId) return { ...secondFloating, instanceId: firstId };
+        if (entry.instanceId === secondId) return { ...firstFloating, instanceId: secondId };
+        return entry;
+      }),
+    });
+  }
+
+  const dockedId = firstLeaf ? firstId : secondId;
+  const floatingId = firstFloating ? firstId : secondId;
+  const dockedLeaf = firstLeaf ?? secondLeaf!;
+  const floatingEntry = firstFloating ?? secondFloating!;
+  const base = layout.dockRoot && dockedLeaf
+    ? replaceNodeAtPath(layout.dockRoot, dockedLeaf.path, { kind: "pane", instanceId: floatingId })
+    : layout.dockRoot;
+
+  return finalizeLayout({
+    ...layout,
+    dockRoot: base,
+    floating: [
+      ...layout.floating.filter((entry) => entry.instanceId !== floatingId),
+      {
+        instanceId: dockedId,
+        x: floatingEntry.x,
+        y: floatingEntry.y,
+        width: floatingEntry.width,
+        height: floatingEntry.height,
+        zIndex: floatingEntry.zIndex,
+      },
+    ],
+  });
+}
+
+export function resizeSplitAtPath(layout: LayoutConfig, path: Array<0 | 1>, ratio: number): LayoutConfig {
+  const target = getNodeAtPath(layout.dockRoot, path);
+  if (!target || target.kind !== "split" || !layout.dockRoot) return layout;
+  return finalizeLayout({
+    ...layout,
+    dockRoot: replaceNodeAtPath(layout.dockRoot, path, {
+      ...target,
+      ratio: clampRatio(ratio),
+    }),
+  });
+}
+
+export function addPaneToLayout(layout: LayoutConfig, instance: PaneInstanceConfig, target: DockTarget): LayoutConfig {
+  const withInstance = ensurePaneInstance(layout, instance);
+  if (!withInstance.dockRoot) {
+    return finalizeLayout({
+      ...withInstance,
+      dockRoot: { kind: "pane", instanceId: instance.instanceId },
+    });
+  }
+  return dockAtTarget(withInstance, instance.instanceId, target);
+}

package/src/plugins/pane-manager/floating-actions.ts

@@ -0,0 +1,158 @@
+import type {
+  FloatingPlacementMemory,
+  LayoutConfig,
+  PaneInstanceConfig,
+} from "../../types/config";
+import type { PaneDef } from "../../types/plugin";
+import { createPaneInstance, findPaneInstance } from "../../types/config";
+import {
+  clampFloatingRect,
+  clampFloatingRectWithinBounds,
+  defaultFloatingRect,
+  maxFloatingZ,
+  MIN_FLOAT_HEIGHT,
+  MIN_FLOAT_WIDTH,
+  updateFloatingPane,
+  type FloatingRect,
+} from "./floating";
+import type { LayoutBounds } from "./dock-tree";
+import type { FloatingResizeCorner } from "./types";
+import { detachPane, ensurePaneInstance, finalizeLayout } from "./layout-state";
+
+export function detachPaneToFrame(
+  layout: LayoutConfig,
+  instanceId: string,
+  rect: Pick<LayoutConfig["detached"][number], "x" | "y" | "width" | "height">,
+): LayoutConfig {
+  const base = detachPane(layout, instanceId);
+  return finalizeLayout({
+    ...base,
+    detached: [
+      ...base.detached.filter((entry) => entry.instanceId !== instanceId),
+      {
+        instanceId,
+        x: Math.max(0, Math.round(rect.x)),
+        y: Math.max(0, Math.round(rect.y)),
+        width: Math.max(1, Math.round(rect.width)),
+        height: Math.max(1, Math.round(rect.height)),
+      },
+    ],
+  });
+}
+
+export function floatAtRect(layout: LayoutConfig, instanceId: string, rect: FloatingRect): LayoutConfig {
+  const base = detachPane(layout, instanceId);
+  return finalizeLayout({
+    ...base,
+    floating: [
+      ...base.floating.filter((entry) => entry.instanceId !== instanceId),
+      {
+        instanceId,
+        x: rect.x,
+        y: rect.y,
+        width: rect.width,
+        height: rect.height,
+        zIndex: rect.zIndex ?? maxFloatingZ(layout) + 1,
+      },
+    ],
+  });
+}
+
+export function moveFloatingPane(
+  layout: LayoutConfig,
+  instanceId: string,
+  deltaX: number,
+  deltaY: number,
+  bounds: LayoutBounds,
+): LayoutConfig {
+  const floating = layout.floating.find((entry) => entry.instanceId === instanceId);
+  if (!floating) return layout;
+  const rect = clampFloatingRectWithinBounds({
+    ...floating,
+    x: floating.x + deltaX,
+    y: floating.y + deltaY,
+  }, bounds);
+  return finalizeLayout(updateFloatingPane(layout, instanceId, rect));
+}
+
+export function resizeFloatingPaneFromCorner(
+  layout: LayoutConfig,
+  instanceId: string,
+  corner: FloatingResizeCorner,
+  deltaX: number,
+  deltaY: number,
+  bounds: LayoutBounds,
+): LayoutConfig {
+  const floating = layout.floating.find((entry) => entry.instanceId === instanceId);
+  if (!floating) return layout;
+
+  let left = floating.x;
+  let top = floating.y;
+  let right = floating.x + floating.width;
+  let bottom = floating.y + floating.height;
+
+  if (corner === "top-left" || corner === "bottom-left") {
+    left = Math.max(bounds.x, Math.min(left + deltaX, right - MIN_FLOAT_WIDTH));
+  } else {
+    right = Math.min(bounds.x + bounds.width, Math.max(right + deltaX, left + MIN_FLOAT_WIDTH));
+  }
+
+  if (corner === "top-left" || corner === "top-right") {
+    top = Math.max(bounds.y, Math.min(top + deltaY, bottom - MIN_FLOAT_HEIGHT));
+  } else {
+    bottom = Math.min(bounds.y + bounds.height, Math.max(bottom + deltaY, top + MIN_FLOAT_HEIGHT));
+  }
+
+  return finalizeLayout(updateFloatingPane(layout, instanceId, {
+    x: left,
+    y: top,
+    width: right - left,
+    height: bottom - top,
+  }));
+}
+
+export function floatPane(
+  layout: LayoutConfig,
+  instanceId: string,
+  termWidth: number,
+  termHeight: number,
+  def?: PaneDef,
+): LayoutConfig {
+  const instance = findPaneInstance(layout, instanceId);
+  if (!instance) return layout;
+  const remembered = instance.placementMemory?.floating;
+  const rect = remembered
+    ? clampFloatingRect(remembered, termWidth, termHeight)
+    : defaultFloatingRect(termWidth, termHeight, def);
+  return floatAtRect(layout, instanceId, rect);
+}
+
+export function addPaneFloating(
+  layout: LayoutConfig,
+  instance: PaneInstanceConfig | string,
+  termWidth: number,
+  termHeight: number,
+  def?: PaneDef,
+): LayoutConfig {
+  const resolvedInstance = typeof instance === "string" ? createPaneInstance(instance) : instance;
+  const withInstance = ensurePaneInstance(layout, resolvedInstance);
+  return floatPane(withInstance, resolvedInstance.instanceId, termWidth, termHeight, def);
+}
+
+export function bringToFront(layout: LayoutConfig, instanceId: string): LayoutConfig {
+  return finalizeLayout(updateFloatingPane(layout, instanceId, { zIndex: maxFloatingZ(layout) + 1 }));
+}
+
+export function getRememberedFloatingRect(
+  layout: LayoutConfig,
+  instanceId: string,
+  termWidth: number,
+  termHeight: number,
+  def?: PaneDef,
+): FloatingPlacementMemory {
+  const instance = findPaneInstance(layout, instanceId);
+  const remembered = instance?.placementMemory?.floating;
+  return remembered
+    ? clampFloatingRect(remembered, termWidth, termHeight)
+    : defaultFloatingRect(termWidth, termHeight, def);
+}

package/src/plugins/pane-manager/floating.ts

@@ -0,0 +1,76 @@
+import type { FloatingPaneEntry, LayoutConfig } from "../../types/config";
+import type { PaneDef } from "../../types/plugin";
+
+export const MIN_FLOAT_WIDTH = 15;
+export const MIN_FLOAT_HEIGHT = 6;
+
+export interface FloatingRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  zIndex?: number;
+}
+
+interface LayoutBoundsLike {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export function clampFloatingRect(rect: FloatingRect, termWidth?: number, termHeight?: number): FloatingRect {
+  const width = Math.max(MIN_FLOAT_WIDTH, Math.round(rect.width));
+  const height = Math.max(MIN_FLOAT_HEIGHT, Math.round(rect.height));
+  const maxX = typeof termWidth === "number" ? Math.max(0, termWidth - width) : Number.POSITIVE_INFINITY;
+  const maxY = typeof termHeight === "number" ? Math.max(0, termHeight - height) : Number.POSITIVE_INFINITY;
+  return {
+    x: Math.max(0, Math.min(Math.round(rect.x), maxX)),
+    y: Math.max(0, Math.min(Math.round(rect.y), maxY)),
+    width,
+    height,
+    zIndex: rect.zIndex,
+  };
+}
+
+export function clampFloatingRectWithinBounds(rect: FloatingRect, bounds: LayoutBoundsLike): FloatingRect {
+  const width = Math.min(Math.max(MIN_FLOAT_WIDTH, Math.round(rect.width)), Math.max(1, bounds.width));
+  const height = Math.min(Math.max(MIN_FLOAT_HEIGHT, Math.round(rect.height)), Math.max(1, bounds.height));
+  const maxX = bounds.x + Math.max(0, bounds.width - width);
+  const maxY = bounds.y + Math.max(0, bounds.height - height);
+  return {
+    x: Math.max(bounds.x, Math.min(Math.round(rect.x), maxX)),
+    y: Math.max(bounds.y, Math.min(Math.round(rect.y), maxY)),
+    width,
+    height,
+    zIndex: rect.zIndex,
+  };
+}
+
+export function defaultFloatingRect(termWidth: number, termHeight: number, def?: PaneDef): FloatingRect {
+  const width = def?.defaultFloatingSize?.width ?? Math.floor(termWidth * 0.6);
+  const height = def?.defaultFloatingSize?.height ?? Math.floor(termHeight * 0.6);
+  return clampFloatingRect({
+    x: Math.floor((termWidth - width) / 2),
+    y: Math.floor((termHeight - height) / 2),
+    width,
+    height,
+  }, termWidth, termHeight);
+}
+
+export function maxFloatingZ(layout: LayoutConfig): number {
+  return layout.floating.reduce((highest, entry) => Math.max(highest, entry.zIndex ?? 50), 50);
+}
+
+export function updateFloatingPane(
+  layout: LayoutConfig,
+  instanceId: string,
+  updates: Partial<Pick<FloatingPaneEntry, "x" | "y" | "width" | "height" | "zIndex">>,
+): LayoutConfig {
+  return {
+    ...layout,
+    floating: layout.floating.map((entry) => (
+      entry.instanceId === instanceId ? { ...entry, ...updates } : entry
+    )),
+  };
+}

package/src/plugins/pane-manager/gridlock-inference.ts

@@ -0,0 +1,126 @@
+import type { DockLayoutNode } from "../../types/config";
+import type { LayoutBounds } from "./dock-tree";
+
+export interface GridlockRect {
+  instanceId: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export function boundsForRects(rects: GridlockRect[]): LayoutBounds {
+  const minX = Math.min(...rects.map((rect) => rect.x));
+  const minY = Math.min(...rects.map((rect) => rect.y));
+  const maxX = Math.max(...rects.map((rect) => rect.x + rect.width));
+  const maxY = Math.max(...rects.map((rect) => rect.y + rect.height));
+  return {
+    x: minX,
+    y: minY,
+    width: Math.max(1, maxX - minX),
+    height: Math.max(1, maxY - minY),
+  };
+}
+
+function buildGridDockTree(instanceIds: string[], depth = 0): DockLayoutNode | null {
+  if (instanceIds.length === 0) return null;
+  if (instanceIds.length === 1) return { kind: "pane", instanceId: instanceIds[0]! };
+  const splitIndex = Math.ceil(instanceIds.length / 2);
+  return {
+    kind: "split",
+    axis: depth % 2 === 0 ? "horizontal" : "vertical",
+    ratio: splitIndex / instanceIds.length,
+    first: buildGridDockTree(instanceIds.slice(0, splitIndex), depth + 1)!,
+    second: buildGridDockTree(instanceIds.slice(splitIndex), depth + 1)!,
+  };
+}
+
+function clampGridlockRatio(value: number): number {
+  if (!Number.isFinite(value)) return 0.5;
+  return Math.max(0.1, Math.min(0.9, value));
+}
+
+function inferSplitCandidate(
+  rects: GridlockRect[],
+  axis: "horizontal" | "vertical",
+  bounds: LayoutBounds,
+): { axis: "horizontal" | "vertical"; ratio: number; first: GridlockRect[]; second: GridlockRect[] } | null {
+  const tolerance = 1;
+  const candidates = new Set<number>();
+
+  for (const rect of rects) {
+    if (axis === "horizontal") {
+      candidates.add(rect.y);
+      candidates.add(rect.y + rect.height);
+    } else {
+      candidates.add(rect.x);
+      candidates.add(rect.x + rect.width);
+    }
+  }
+
+  const minBound = axis === "horizontal" ? bounds.y : bounds.x;
+  const maxBound = axis === "horizontal" ? bounds.y + bounds.height : bounds.x + bounds.width;
+
+  let best: { ratio: number; first: GridlockRect[]; second: GridlockRect[]; score: number } | null = null;
+  for (const candidate of candidates) {
+    if (candidate <= minBound + tolerance || candidate >= maxBound - tolerance) continue;
+
+    const first: GridlockRect[] = [];
+    const second: GridlockRect[] = [];
+    let valid = true;
+
+    for (const rect of rects) {
+      const start = axis === "horizontal" ? rect.y : rect.x;
+      const end = axis === "horizontal" ? rect.y + rect.height : rect.x + rect.width;
+
+      if (end <= candidate + tolerance) {
+        first.push(rect);
+      } else if (start >= candidate - tolerance) {
+        second.push(rect);
+      } else {
+        valid = false;
+        break;
+      }
+    }
+
+    if (!valid || first.length === 0 || second.length === 0) continue;
+
+    const ratio = axis === "horizontal"
+      ? clampGridlockRatio((candidate - bounds.y) / Math.max(1, bounds.height))
+      : clampGridlockRatio((candidate - bounds.x) / Math.max(1, bounds.width));
+    const balance = Math.abs(first.length - second.length);
+    const centerBias = Math.abs(ratio - 0.5);
+    const score = balance * 10 + centerBias;
+
+    if (!best || score < best.score) {
+      best = { ratio, first, second, score };
+    }
+  }
+
+  return best ? { axis, ratio: best.ratio, first: best.first, second: best.second } : null;
+}
+
+export function inferDockTreeFromRects(rects: GridlockRect[], bounds?: LayoutBounds): DockLayoutNode | null {
+  if (rects.length === 0) return null;
+  if (rects.length === 1) return { kind: "pane", instanceId: rects[0]!.instanceId };
+
+  const rectBounds = bounds ?? boundsForRects(rects);
+  const preferredAxis = rectBounds.width >= rectBounds.height ? "vertical" : "horizontal";
+  const primary = inferSplitCandidate(rects, preferredAxis, rectBounds);
+  const secondary = inferSplitCandidate(rects, preferredAxis === "vertical" ? "horizontal" : "vertical", rectBounds);
+  const chosen = primary ?? secondary;
+
+  if (!chosen) {
+    return buildGridDockTree(
+      [...rects].sort((a, b) => a.y - b.y || a.x - b.x).map((rect) => rect.instanceId),
+    );
+  }
+
+  return {
+    kind: "split",
+    axis: chosen.axis === "vertical" ? "horizontal" : "vertical",
+    ratio: chosen.ratio,
+    first: inferDockTreeFromRects(chosen.first, boundsForRects(chosen.first))!,
+    second: inferDockTreeFromRects(chosen.second, boundsForRects(chosen.second))!,
+  };
+}

package/src/plugins/pane-manager/gridlock.ts

@@ -0,0 +1,34 @@
+import type { LayoutConfig } from "../../types/config";
+import {
+  boundsForRects,
+  inferDockTreeFromRects,
+  type GridlockRect,
+} from "./gridlock-inference";
+import {
+  getDockLeafLayouts,
+  type LayoutBounds,
+} from "./dock-tree";
+import { finalizeLayout } from "./layout-state";
+
+export function gridlockAllPanes(
+  layout: LayoutConfig,
+  bounds: LayoutBounds = { x: 0, y: 0, width: 120, height: 40 },
+): LayoutConfig {
+  const dockedRects: GridlockRect[] = getDockLeafLayouts(layout, bounds)
+    .map((leaf) => ({ instanceId: leaf.instanceId, ...leaf.rect }));
+  const floatingRects: GridlockRect[] = layout.floating.map((entry) => ({
+    instanceId: entry.instanceId,
+    x: entry.x,
+    y: entry.y,
+    width: entry.width,
+    height: entry.height,
+  }));
+  const allRects = [...dockedRects, ...floatingRects];
+  if (allRects.length === 0) return layout;
+
+  return finalizeLayout({
+    ...layout,
+    dockRoot: inferDockTreeFromRects(allRects, boundsForRects(allRects)),
+    floating: [],
+  });
+}