Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import { useDragDropContext } from '@thisbeyond/solid-dnd';
import { createEffect, on, onCleanup } from 'solid-js';
import { createPointerAutoScroll } from './create-pointer-auto-scroll';
type NestedScroll = {
viewportSelector: string;
horizontalOutside: boolean;
};
type Point = { x: number; y: number };
type Edges = { left: number; right: number; top: number; bottom: number };
function edgeVelocity(position: number, start: number, end: number) {
const edge = Math.min(48, (end - start) / 4);
if (edge <= 0) return 0;
if (position < start + edge)
return Math.max(-1, -(1 - (position - start) / edge));
if (position > end - edge) return Math.min(1, 1 - (end - position) / edge);
return 0;
}
function scrollLane(
viewport: HTMLElement,
selector: string,
pointer: Point,
edges: Edges,
elapsed: number
) {
for (const lane of viewport.querySelectorAll<HTMLElement>(selector)) {
const rect = lane.getBoundingClientRect();
const left = Math.max(rect.left, edges.left);
const right = Math.min(rect.right, edges.right);
const top = Math.max(rect.top, edges.top);
const bottom = Math.min(rect.bottom, edges.bottom);
if (
pointer.x < left ||
pointer.x > right ||
pointer.y < top ||
pointer.y > bottom
)
continue;
const previous = lane.scrollTop;
lane.scrollTop = Math.max(
0,
Math.min(
lane.scrollHeight - lane.clientHeight,
previous + edgeVelocity(pointer.y, top, bottom) * elapsed * 0.7
)
);
return lane.scrollTop !== previous;
}
return false;
}
function scrollDragFrame(
viewport: HTMLElement,
pointer: Point,
elapsed: number,
options: { axis: 'x' | 'y' | 'both'; nestedScroll?: NestedScroll }
) {
const bounds = viewport.getBoundingClientRect();
const edges = {
left: Math.max(bounds.left, 0),
right: Math.min(bounds.right, window.innerWidth),
top: Math.max(bounds.top, 0),
bottom: Math.min(bounds.bottom, window.innerHeight),
};
const inside =
pointer.x >= edges.left &&
pointer.x <= edges.right &&
pointer.y >= edges.top &&
pointer.y <= edges.bottom;
// The marker opts a board into nested scrolling without changing other surfaces.
const nested =
options.nestedScroll &&
viewport.querySelector(options.nestedScroll.viewportSelector)
? options.nestedScroll
: undefined;
const beforeX = viewport.scrollLeft;
if (options.axis !== 'y' && (inside || nested?.horizontalOutside)) {
viewport.scrollLeft = Math.max(
0,
Math.min(
viewport.scrollWidth - viewport.clientWidth,
beforeX +
edgeVelocity(pointer.x, edges.left, edges.right) * elapsed * 0.7
)
);
}
let scrolled = viewport.scrollLeft !== beforeX;
if (inside && options.axis !== 'x' && !nested) {
const beforeY = viewport.scrollTop;
viewport.scrollTop = Math.max(
0,
Math.min(
viewport.scrollHeight - viewport.clientHeight,
beforeY +
edgeVelocity(pointer.y, edges.top, edges.bottom) * elapsed * 0.7
)
);
scrolled ||= viewport.scrollTop !== beforeY;
}
if (nested) {
scrolled =
scrollLane(viewport, nested.viewportSelector, pointer, edges, elapsed) ||
scrolled;
}
return scrolled;
}
/** Scroll the active solid-dnd surface while the pointer rests near its edge. */
export function createDragAutoScroll(options: {
getViewport: () => HTMLElement | undefined;
axis: 'x' | 'y' | 'both';
nestedScroll?: NestedScroll;
}) {
const context = useDragDropContext();
if (!context) throw new Error('Drag auto-scroll requires DragDropProvider');
const [state, actions] = context;
const autoScroll = createPointerAutoScroll({
...options,
getPointer: () => state.active.sensor?.coordinates.current,
onScroll: () => actions.detectCollisions(),
});
createEffect(
on(
() => state.active.draggableId,
(id) => {
if (id === null) return;
if (!options.nestedScroll) {
autoScroll.start();
onCleanup(autoScroll.stop);
return;
}
let previousTime: number | undefined;
let frame: number;
const tick = (time: number) => {
const elapsed = Math.min(time - (previousTime ?? time), 32);
previousTime = time;
const viewport = options.getViewport();
const pointer = state.active.sensor?.coordinates.current;
if (viewport && pointer) {
if (scrollDragFrame(viewport, pointer, elapsed, options))
actions.detectCollisions();
}
frame = requestAnimationFrame(tick);
};
frame = requestAnimationFrame(tick);
onCleanup(() => cancelAnimationFrame(frame));
}
)
);
}