Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

7.6 KB
Raw Blame
import { createRoot, createSignal } from 'solid-js';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createDragAutoScroll } from './create-drag-auto-scroll';

const drag = vi.hoisted(() => ({
  active: (): boolean => false,
  pointer: { x: 390, y: 200 },
  detectCollisions: vi.fn(),
}));
vi.mock('@thisbeyond/solid-dnd', () => ({
  useDragDropContext: () => [
    {
      active: {
        get draggableId() {
          return drag.active() ? 'column' : null;
        },
        sensor: {
          coordinates: {
            get current() {
              return drag.pointer;
            },
          },
        },
      },
    },
    { detectCollisions: drag.detectCollisions },
  ],
}));

let dispose: (() => void) | undefined;
afterEach(() => {
  dispose?.();
  vi.restoreAllMocks();
  vi.unstubAllGlobals();
  drag.detectCollisions.mockClear();
});

function setup(
  axis: 'x' | 'y' | 'both' = 'x',
  nestedScroll?: { viewportSelector: string; horizontalOutside: boolean }
) {
  const frames = new Map<number, FrameRequestCallback>();
  let sequence = 0;
  vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) => {
    frames.set(++sequence, callback);
    return sequence;
  });
  vi.stubGlobal('cancelAnimationFrame', (id: number) => frames.delete(id));
  const viewport = document.createElement('div');
  vi.spyOn(viewport, 'getBoundingClientRect').mockReturnValue(
    new DOMRect(0, 100, 400, 400)
  );
  Object.defineProperties(viewport, {
    scrollWidth: { value: 1000 },
    clientWidth: { value: 400 },
    scrollHeight: { value: 1000 },
    clientHeight: { value: 400 },
  });
  const [active, setActive] = createSignal(false);
  drag.active = active;
  drag.pointer = { x: 390, y: 200 };
  createRoot((cleanup) => {
    dispose = cleanup;
    createDragAutoScroll({ getViewport: () => viewport, axis, nestedScroll });
  });
  const frame = (time: number) => {
    const pending = [...frames.values()];
    frames.clear();
    for (const callback of pending) callback(time);
  };
  return { viewport, setActive, frame, frames };
}

describe('drag auto-scroll', () => {
  it('continues scrolling for a stationary edge pointer and stops as soon as the drag ends', () => {
    const { viewport, setActive, frame, frames } = setup();
    expect(frames.size).toBe(0);
    setActive(true);
    frame(0);
    frame(16);
    const first = viewport.scrollLeft;
    frame(32);
    expect(first).toBeGreaterThan(0);
    expect(viewport.scrollLeft).toBeGreaterThan(first);
    expect(drag.detectCollisions).toHaveBeenCalledTimes(2);
    expect(viewport.scrollTop).toBe(0);
    setActive(false);
    expect(frames.size).toBe(0);
    const stopped = viewport.scrollLeft;
    frame(48);
    expect(viewport.scrollLeft).toBe(stopped);
  });

  it('does not scroll in the center or beyond the viewport and clamps at the last column', () => {
    const { viewport, setActive, frame } = setup();
    setActive(true);
    frame(0);
    drag.pointer = { x: 200, y: 200 };
    frame(16);
    expect(viewport.scrollLeft).toBe(0);
    drag.pointer = { x: 410, y: 200 };
    frame(32);
    expect(viewport.scrollLeft).toBe(0);
    viewport.scrollLeft = 599;
    drag.pointer = { x: 399, y: 200 };
    frame(48);
    expect(viewport.scrollLeft).toBe(600);
    drag.pointer = { x: 1, y: 200 };
    frame(64);
    expect(viewport.scrollLeft).toBeLessThan(600);
  });

  it('scrolls vertical sidebars without changing their horizontal offset', () => {
    const { viewport, setActive, frame, frames } = setup('y');
    viewport.scrollLeft = 40;
    drag.pointer = { x: 395, y: 495 };
    setActive(true);
    frame(0);
    frame(16);

    expect(viewport.scrollTop).toBeGreaterThan(0);
    expect(viewport.scrollLeft).toBe(40);
    expect(drag.detectCollisions).toHaveBeenCalledOnce();

    setActive(false);
    expect(frames.size).toBe(0);
  });

  it('scrolls vertically for boards and cancels its frame on unmount', () => {
    const { viewport, setActive, frame, frames } = setup('both');
    drag.pointer = { x: 200, y: 495 };
    setActive(true);
    frame(0);
    frame(16);
    expect(viewport.scrollTop).toBeGreaterThan(0);
    expect(viewport.scrollLeft).toBe(0);
    dispose?.();
    dispose = undefined;
    expect(frames.size).toBe(0);
  });
});

function addLane(viewport: HTMLElement, left: number) {
  const lane = document.createElement('div');
  lane.dataset.taskBoardScroll = String(left);
  viewport.append(lane);
  vi.spyOn(lane, 'getBoundingClientRect').mockReturnValue(
    new DOMRect(left, 140, 180, 300)
  );
  Object.defineProperties(lane, {
    scrollHeight: { value: 1000 },
    clientHeight: { value: 300 },
  });
  return lane;
}

const nestedScroll = {
  viewportSelector: '[data-task-board-scroll]',
  horizontalOutside: true,
};

describe('nested drag auto-scroll', () => {
  it('scrolls only the lane under the pointer, clips to the board, and switches lanes', () => {
    const { viewport, setActive, frame } = setup('x', nestedScroll);
    const first = addLane(viewport, 0);
    const second = addLane(viewport, 200);
    drag.pointer = { x: 90, y: 430 };
    setActive(true);
    frame(0);
    frame(16);
    expect(first.scrollTop).toBeGreaterThan(0);
    expect(second.scrollTop).toBe(0);
    expect(viewport.scrollTop).toBe(0);
    const offset = first.scrollTop;
    drag.pointer = { x: 290, y: 430 };
    frame(32);
    expect(first.scrollTop).toBe(offset);
    expect(second.scrollTop).toBeGreaterThan(0);
    drag.pointer = { x: 290, y: 490 };
    frame(48);
    expect(second.scrollTop).toBeGreaterThan(0);
    const clipped = second.scrollTop;
    drag.pointer = { x: 290, y: 120 };
    frame(64);
    expect(second.scrollTop).toBe(clipped);
    expect(drag.detectCollisions).toHaveBeenCalledTimes(2);
  });

  it('ignores nested options without a marked lane', () => {
    const { viewport, setActive, frame } = setup('both', nestedScroll);
    drag.pointer = { x: 410, y: 490 };
    setActive(true);
    frame(0);
    frame(16);
    expect(viewport.scrollLeft).toBe(0);
    expect(viewport.scrollTop).toBe(0);
    expect(drag.detectCollisions).not.toHaveBeenCalled();
  });

  it('clips lane edges to the visible board and stops after unmount', () => {
    const { viewport, setActive, frame, frames } = setup('both', nestedScroll);
    const lane = addLane(viewport, 200);
    vi.spyOn(lane, 'getBoundingClientRect').mockReturnValue(
      new DOMRect(200, 140, 180, 600)
    );
    drag.pointer = { x: 290, y: 490 };
    setActive(true);
    frame(0);
    frame(16);
    expect(lane.scrollTop).toBeGreaterThan(0);
    expect(viewport.scrollTop).toBe(0);
    const first = lane.scrollTop;
    drag.pointer = { x: 290, y: 530 };
    frame(32);
    expect(lane.scrollTop).toBe(first);
    lane.scrollTop = 699;
    drag.pointer = { x: 290, y: 499 };
    frame(48);
    expect(lane.scrollTop).toBe(700);
    dispose?.();
    dispose = undefined;
    expect(frames.size).toBe(0);
    frame(64);
    expect(lane.scrollTop).toBe(700);
  });

  it('scrolls horizontally past the viewport and screen, clamps velocity, and stops on drag end', () => {
    const { viewport, setActive, frame, frames } = setup('x', nestedScroll);
    addLane(viewport, 200);
    drag.pointer = { x: 1000, y: -40 };
    setActive(true);
    frame(0);
    frame(16);
    expect(viewport.scrollLeft).toBeCloseTo(11.2);
    expect(viewport.scrollTop).toBe(0);
    drag.pointer = { x: -100, y: 900 };
    frame(32);
    expect(viewport.scrollLeft).toBe(0);
    viewport.scrollLeft = 599;
    drag.pointer = { x: 1000, y: 900 };
    frame(48);
    expect(viewport.scrollLeft).toBe(600);
    setActive(false);
    expect(frames.size).toBe(0);
    frame(64);
    expect(viewport.scrollLeft).toBe(600);
  });
});