@flighthq/gui 0.4.1-edge.28.7f8e221

package/src/tooltipController.test.ts

@@ -0,0 +1,56 @@
+import { createGuiTestNode, emitGuiPointer } from './guiTestHelper';
+import {
+  createTooltipController,
+  disposeTooltipController,
+  hideTooltipController,
+  showTooltipController,
+} from './tooltipController';
+
+describe('createTooltipController', () => {
+  it('shows after delay at the pointer offset and hides on exit', () => {
+    vi.useFakeTimers();
+    const content = createGuiTestNode();
+    const target = createGuiTestNode();
+    createTooltipController({ content, delay: 50, offset: { x: 3, y: 4 }, target });
+    emitGuiPointer(target, 'onPointerOver', { worldX: 10, worldY: 20 });
+    expect(content.visible).toBe(false);
+    vi.advanceTimersByTime(50);
+    expect([content.visible, content.x, content.y]).toEqual([true, 13, 24]);
+    emitGuiPointer(target, 'onPointerOut');
+    expect(content.visible).toBe(false);
+    vi.useRealTimers();
+  });
+});
+
+describe('disposeTooltipController', () => {
+  it('cancels delayed display', () => {
+    vi.useFakeTimers();
+    const content = createGuiTestNode();
+    const target = createGuiTestNode();
+    const controller = createTooltipController({ content, delay: 50, target });
+    emitGuiPointer(target, 'onPointerOver');
+    disposeTooltipController(controller);
+    vi.advanceTimersByTime(50);
+    expect(content.visible).toBe(false);
+    vi.useRealTimers();
+  });
+});
+
+describe('hideTooltipController', () => {
+  it('hides immediately', () => {
+    const content = createGuiTestNode();
+    const controller = createTooltipController({ content, target: createGuiTestNode() });
+    showTooltipController(controller);
+    hideTooltipController(controller);
+    expect(content.visible).toBe(false);
+  });
+});
+
+describe('showTooltipController', () => {
+  it('shows immediately when called', () => {
+    const content = createGuiTestNode();
+    const controller = createTooltipController({ content, target: createGuiTestNode() });
+    showTooltipController(controller);
+    expect(content.visible).toBe(true);
+  });
+});

package/src/treeViewController.test.ts

@@ -0,0 +1,105 @@
+import { connectSignal } from '@flighthq/signals/contract';
+import type { TreeViewControllerItem } from '@flighthq/types/contract';
+
+import { createGuiTestNode, emitGuiKeyboard, emitGuiPointer } from './guiTestHelper';
+import {
+  createTreeViewController,
+  disposeTreeViewController,
+  getTreeViewControllerSelectedItem,
+  getTreeViewControllerSignals,
+  isTreeViewControllerItemExpanded,
+  setTreeViewControllerItemExpanded,
+  setTreeViewControllerSelectedItem,
+  toggleTreeViewControllerItem,
+} from './treeViewController';
+
+function tree() {
+  const child: TreeViewControllerItem = { visual: createGuiTestNode() };
+  const root: TreeViewControllerItem = { children: [child], visual: createGuiTestNode() };
+  return { child, root };
+}
+
+describe('createTreeViewController', () => {
+  it('models expansion separately from flat ListController state', () => {
+    const { child, root } = tree();
+    const controller = createTreeViewController({ items: [root] });
+    expect(child.visual.visible).toBe(false);
+    emitGuiPointer(root.visual, 'onDoubleClick');
+    expect(isTreeViewControllerItemExpanded(controller, root)).toBe(true);
+    expect(child.visual.visible).toBe(true);
+  });
+
+  it('navigates hierarchy with left and right', () => {
+    const { child, root } = tree();
+    const controller = createTreeViewController({ items: [root], selectedItem: root });
+    emitGuiKeyboard(root.visual, 'onKeyDown', 'ArrowRight');
+    emitGuiKeyboard(root.visual, 'onKeyDown', 'ArrowRight');
+    expect(getTreeViewControllerSelectedItem(controller)).toBe(child);
+  });
+});
+
+describe('disposeTreeViewController', () => {
+  it('detaches item input', () => {
+    const { root } = tree();
+    const controller = createTreeViewController({ items: [root] });
+    disposeTreeViewController(controller);
+    emitGuiPointer(root.visual, 'onClick');
+    expect(getTreeViewControllerSelectedItem(controller)).toBeNull();
+  });
+});
+
+describe('getTreeViewControllerSelectedItem', () => {
+  it('returns configured selection', () => {
+    const { root } = tree();
+    expect(getTreeViewControllerSelectedItem(createTreeViewController({ items: [root], selectedItem: root }))).toBe(
+      root,
+    );
+  });
+});
+
+describe('getTreeViewControllerSignals', () => {
+  it('emits activation separately from expansion', () => {
+    const { root } = tree();
+    const controller = createTreeViewController({ items: [root] });
+    let activated = false;
+    connectSignal(getTreeViewControllerSignals(controller).onActivate, () => (activated = true));
+    emitGuiPointer(root.visual, 'onDoubleClick');
+    expect(activated).toBe(true);
+  });
+});
+
+describe('isTreeViewControllerItemExpanded', () => {
+  it('reads authored initial expansion', () => {
+    const { root } = tree();
+    root.expanded = true;
+    expect(isTreeViewControllerItemExpanded(createTreeViewController({ items: [root] }), root)).toBe(true);
+  });
+});
+
+describe('setTreeViewControllerItemExpanded', () => {
+  it('ignores leaves', () => {
+    const { child, root } = tree();
+    const controller = createTreeViewController({ items: [root] });
+    setTreeViewControllerItemExpanded(controller, child, true);
+    expect(isTreeViewControllerItemExpanded(controller, child)).toBe(false);
+  });
+});
+
+describe('setTreeViewControllerSelectedItem', () => {
+  it('rejects foreign items', () => {
+    const { root } = tree();
+    const controller = createTreeViewController({ items: [root] });
+    setTreeViewControllerSelectedItem(controller, { visual: createGuiTestNode() });
+    expect(getTreeViewControllerSelectedItem(controller)).toBeNull();
+  });
+});
+
+describe('toggleTreeViewControllerItem', () => {
+  it('toggles expansion in both directions', () => {
+    const { root } = tree();
+    const controller = createTreeViewController({ items: [root] });
+    toggleTreeViewControllerItem(controller, root);
+    toggleTreeViewControllerItem(controller, root);
+    expect(isTreeViewControllerItemExpanded(controller, root)).toBe(false);
+  });
+});

package/src/windowController.test.ts

@@ -0,0 +1,75 @@
+import { connectSignal } from '@flighthq/signals/contract';
+
+import { createButtonController } from './buttonController';
+import { createGuiTestNode, emitGuiPointer } from './guiTestHelper';
+import {
+  createWindowController,
+  disposeWindowController,
+  getWindowControllerSignals,
+  setWindowControllerPosition,
+  setWindowControllerSize,
+} from './windowController';
+
+describe('createWindowController', () => {
+  it('moves from a title bar and resizes from a handle', () => {
+    const frame = createGuiTestNode(200, 100);
+    const titleBar = createGuiTestNode();
+    const resizeHandle = createGuiTestNode();
+    createWindowController({ frame, resizeHandle, titleBar });
+    emitGuiPointer(titleBar, 'onPointerDown', { worldX: 10, worldY: 10 });
+    emitGuiPointer(titleBar, 'onPointerMove', { worldX: 30, worldY: 40 });
+    expect([frame.x, frame.y]).toEqual([20, 30]);
+    emitGuiPointer(resizeHandle, 'onPointerDown', { worldX: 0, worldY: 0 });
+    emitGuiPointer(resizeHandle, 'onPointerMove', { worldX: 100, worldY: 50 });
+    expect([frame.scaleX, frame.scaleY]).toEqual([1.5, 1.5]);
+  });
+
+  it('forwards a composed close button', () => {
+    const closeNode = createGuiTestNode();
+    const controller = createWindowController({
+      closeButton: createButtonController({ upState: closeNode }),
+      frame: createGuiTestNode(),
+    });
+    let closed = false;
+    connectSignal(getWindowControllerSignals(controller).onClose, () => (closed = true));
+    emitGuiPointer(closeNode, 'onClick');
+    expect(closed).toBe(true);
+  });
+});
+
+describe('disposeWindowController', () => {
+  it('detaches title dragging', () => {
+    const frame = createGuiTestNode();
+    const titleBar = createGuiTestNode();
+    const controller = createWindowController({ frame, titleBar });
+    disposeWindowController(controller);
+    emitGuiPointer(titleBar, 'onPointerDown', { worldX: 0 });
+    emitGuiPointer(titleBar, 'onPointerMove', { worldX: 20 });
+    expect(frame.x).toBe(0);
+  });
+});
+
+describe('getWindowControllerSignals', () => {
+  it('returns stable signals', () => {
+    const controller = createWindowController({ frame: createGuiTestNode() });
+    expect(getWindowControllerSignals(controller)).toBe(getWindowControllerSignals(controller));
+  });
+});
+
+describe('setWindowControllerPosition', () => {
+  it('sets the frame transform', () => {
+    const frame = createGuiTestNode();
+    const controller = createWindowController({ frame });
+    setWindowControllerPosition(controller, 4, 5);
+    expect([frame.x, frame.y]).toEqual([4, 5]);
+  });
+});
+
+describe('setWindowControllerSize', () => {
+  it('honors minimum dimensions', () => {
+    const frame = createGuiTestNode(100, 100);
+    const controller = createWindowController({ frame, minimumHeight: 50, minimumWidth: 50 });
+    setWindowControllerSize(controller, 10, 20);
+    expect([frame.scaleX, frame.scaleY]).toEqual([0.5, 0.5]);
+  });
+});