pi-ui-extension 1.1.0

package/extensions/sidebar/resize.ts

@@ -0,0 +1,154 @@
+import type {
+  Component,
+  OverlayHandle,
+  OverlayOptions,
+  TUI,
+  TuiInputListener,
+} from "@earendil-works/pi-tui";
+
+const SGR_MOUSE = /^\u001b\[<(\d+);(\d+);(\d+)([Mm])$/;
+const PREVIEW_FRAME_INTERVAL_MS = 16;
+
+export type SgrMouseEvent = {
+  readonly button: number;
+  readonly x: number;
+  readonly y: number;
+  readonly release: boolean;
+  readonly motion: boolean;
+};
+
+export function parseSgrMouseEvent(data: string): SgrMouseEvent | undefined {
+  const match = data.match(SGR_MOUSE);
+  if (!match) return undefined;
+  const button = Number(match[1]);
+  const x = Number(match[2]);
+  const y = Number(match[3]);
+  if (![button, x, y].every(Number.isFinite) || x < 1 || y < 1) return undefined;
+  return { button, x, y, release: match[4] === "m", motion: (button & 32) !== 0 };
+}
+
+export class SidebarDivider implements Component {
+  constructor(
+    private readonly paint: (line: string) => string,
+    private readonly getHeight: () => number,
+  ) {}
+  render(): string[] { return Array.from({ length: Math.max(1, this.getHeight()) }, () => this.paint("│")); }
+  invalidate(): void {}
+}
+
+/** Install ahead of Pi's built-in fullscreen mouse handler so sidebar gestures can consume events first. */
+export function installPriorityInputListener(tui: TUI, listener: TuiInputListener): () => void {
+  const unsubscribe = tui.addInputListener(listener);
+  const listeners = (tui as unknown as { inputListeners?: Set<TuiInputListener> }).inputListeners;
+  if (listeners instanceof Set && listeners.delete(listener)) {
+    const existing = [...listeners];
+    listeners.clear();
+    listeners.add(listener);
+    for (const item of existing) listeners.add(item);
+  }
+  return unsubscribe;
+}
+
+export type MouseResizeOptions = {
+  readonly tui: TUI;
+  readonly preview: Component;
+  readonly isVisible: () => boolean;
+  readonly getDividerX: () => number;
+  readonly clampSidebarWidth: (width: number) => number;
+  readonly commitSidebarWidth: (width: number) => void;
+};
+
+export function installMouseResize(options: MouseResizeOptions): () => void {
+  let dragging = false;
+  let dragColumns = 0;
+  let dragRows = 0;
+  let geometryTimer: ReturnType<typeof setInterval> | undefined;
+  let previewHandle: OverlayHandle | undefined;
+  let pendingX: number | undefined;
+  let frameTimer: ReturnType<typeof setTimeout> | undefined;
+  let lastFrameAt = 0;
+  let disposed = false;
+  const previewOptions: OverlayOptions = {
+    width: 1,
+    maxHeight: "100%",
+    row: 0,
+    col: Math.max(0, options.getDividerX() - 1),
+    nonCapturing: true,
+  };
+
+  const clearFrameTimer = (): void => {
+    if (frameTimer) clearTimeout(frameTimer);
+    frameTimer = undefined;
+  };
+  const hidePreview = (): void => {
+    previewHandle?.hide();
+    previewHandle = undefined;
+  };
+  const cancelDrag = (): void => {
+    dragging = false;
+    pendingX = undefined;
+    clearFrameTimer();
+    if (geometryTimer) clearInterval(geometryTimer);
+    geometryTimer = undefined;
+    hidePreview();
+  };
+  const geometryValid = (): boolean => options.isVisible()
+    && (!dragging || (dragColumns === options.tui.terminal.columns && dragRows === options.tui.terminal.rows));
+  const flushPreview = (): void => {
+    clearFrameTimer();
+    if (disposed || !geometryValid()) { cancelDrag(); return; }
+    if (pendingX === undefined) return;
+    previewOptions.col = Math.max(0, pendingX - 1);
+    pendingX = undefined;
+    lastFrameAt = performance.now();
+    options.tui.requestRender();
+  };
+  const schedulePreview = (x: number): void => {
+    pendingX = x;
+    if (frameTimer) return;
+    const elapsed = performance.now() - lastFrameAt;
+    frameTimer = setTimeout(flushPreview, Math.max(0, PREVIEW_FRAME_INTERVAL_MS - elapsed));
+    frameTimer.unref?.();
+  };
+  const sidebarWidthAt = (x: number): number => options.clampSidebarWidth(options.tui.terminal.columns - x);
+  const previewXFor = (x: number): number => options.tui.terminal.columns - sidebarWidthAt(x);
+
+  const listener: TuiInputListener = (data) => {
+    if (disposed || !geometryValid()) { cancelDrag(); return undefined; }
+    const mouse = parseSgrMouseEvent(data);
+    if (!mouse) return undefined;
+
+    if (mouse.release) {
+      if (!dragging) return undefined;
+      cancelDrag();
+      options.commitSidebarWidth(sidebarWidthAt(mouse.x));
+      return { consume: true };
+    }
+    if (!mouse.motion && (mouse.button & 3) === 0 && (mouse.button & 64) === 0) {
+      if (Math.abs(mouse.x - options.getDividerX()) > 1) return undefined;
+      if (dragging) return { consume: true };
+      dragging = true;
+      dragColumns = options.tui.terminal.columns;
+      dragRows = options.tui.terminal.rows;
+      // Only watch geometry during a drag, including resizes with no further mouse input.
+      geometryTimer = setInterval(() => { if (!geometryValid()) cancelDrag(); }, PREVIEW_FRAME_INTERVAL_MS);
+      geometryTimer.unref?.();
+      previewOptions.col = Math.max(0, options.getDividerX() - 1);
+      previewHandle = options.tui.showOverlay(options.preview, previewOptions);
+      return { consume: true };
+    }
+    if (mouse.motion && dragging) {
+      schedulePreview(previewXFor(mouse.x));
+      return { consume: true };
+    }
+    return dragging ? { consume: true } : undefined;
+  };
+
+  const unsubscribe = installPriorityInputListener(options.tui, listener);
+
+  return () => {
+    disposed = true;
+    cancelDrag();
+    unsubscribe();
+  };
+}

package/extensions/tool-view/controller.test.ts

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { installToolViewController } from "./controller.ts";
+
+type Handler = (event: any, ctx: any) => unknown;
+
+test("applies a mode change from another context wrapper in the active session", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "tool-view-controller-"));
+  const modeFile = join(directory, "mode.json");
+  const handlers = new Map<string, Handler[]>();
+  const statuses: string[] = [];
+  const notices: string[] = [];
+  const expandedValues: boolean[] = [];
+  const sessionManager = { getSessionId: () => "session-1" };
+  let toolsExpanded = false;
+
+  const pi = {
+    registerTool() {},
+    registerCommand() {},
+    registerShortcut() {},
+    getCommands: () => [],
+    on(event: string, handler: Handler) {
+      handlers.set(event, [...(handlers.get(event) ?? []), handler]);
+    },
+  } as any;
+  const ui = {
+    setStatus(_id: string, value: string | undefined) { if (value) statuses.push(value); },
+    notify(message: string) { notices.push(message); },
+    getToolsExpanded: () => toolsExpanded,
+    setToolsExpanded(value: boolean) {
+      toolsExpanded = value;
+      expandedValues.push(value);
+    },
+  };
+
+  try {
+    const controller = await installToolViewController(pi, { modeFile });
+    const sessionCtx = { mode: "tui", ui, sessionManager } as any;
+    for (const handler of handlers.get("session_start") ?? []) handler({}, sessionCtx);
+
+    // Pi may create another ExtensionContext wrapper for a panel/command while
+    // retaining the same active SessionManager identity.
+    const panelCtx = { mode: "tui", ui, sessionManager } as any;
+    await controller.setMode("normal", panelCtx);
+
+    assert.equal(controller.getMode(), "normal");
+    assert.deepEqual(JSON.parse(await readFile(modeFile, "utf8")), { mode: "normal" });
+    assert.equal(statuses.at(-1), "工具：完整");
+    assert.equal(notices.at(-1), "工具显示模式：完整（normal）");
+    assert.deepEqual(expandedValues.slice(-2), [true, false]);
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});