An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
import {describe, it} from "node:test";
import * as assert from "node:assert/strict";
import {
completeDrag,
createDragRefreshQueue,
dispatchWithNativeDragEnabled,
getDragRelayTypes,
getSourceDragGhostVisibility,
getWheelScrollDelta,
hasActiveTouchGesture,
isDragRelaySource,
restoreNativeDrag,
shouldCancelPointerDragAfterWindowExit,
shouldRequestForeignMouseDrop,
shouldRequireLongPress,
shouldSuppressNativeContextMenu,
suspendNativeDrag,
} from "./touchDragBridgeCore";
const dragRelayMimeTypes = {
block: "application/siyuan-block",
documents: "application/siyuan-documents",
file: "application/siyuan-file",
gutterPrefix: "application/siyuan-gutter",
};
const createGuard = () => {
let draggable = "true";
const state = {
draggableElement: {
setAttribute: (name: string, value: string) => {
if (name === "draggable") {
draggable = value;
}
},
},
restoreDraggable: false,
};
return {
state,
getDraggable: () => draggable,
};
};
describe("touch drag native guard", () => {
it("suspends native dragging until the synthetic dragstart is dispatched", () => {
const guard = createGuard();
suspendNativeDrag(guard.state);
assert.equal(guard.getDraggable(), "false");
let draggableDuringDispatch = "";
dispatchWithNativeDragEnabled(guard.state, () => {
draggableDuringDispatch = guard.getDraggable();
});
assert.equal(draggableDuringDispatch, "true");
assert.equal(guard.getDraggable(), "false");
});
it("keeps native dragging suspended when dragstart dispatch throws", () => {
const guard = createGuard();
suspendNativeDrag(guard.state);
assert.throws(() => dispatchWithNativeDragEnabled(guard.state, () => {
throw new Error("dragstart failed");
}));
assert.equal(guard.getDraggable(), "false");
});
it("restores native dragging during cleanup", () => {
const guard = createGuard();
suspendNativeDrag(guard.state);
restoreNativeDrag(guard.state);
assert.equal(guard.getDraggable(), "true");
});
});
describe("touch drag completion", () => {
const runCompletion = (isDragging: boolean, canceled: boolean) => {
const calls: string[] = [];
completeDrag(isDragging, canceled, {
drop: () => calls.push("drop"),
dragEnd: () => calls.push("dragend"),
cleanup: () => calls.push("cleanup"),
});
return calls;
};
it("dispatches drop and dragend before cleanup after a successful drag", () => {
assert.deepEqual(runCompletion(true, false), ["drop", "dragend", "cleanup"]);
});
it("dispatches dragend before cleanup when a drag is canceled", () => {
assert.deepEqual(runCompletion(true, true), ["dragend", "cleanup"]);
});
it("only cleans up when the long press did not become a drag", () => {
assert.deepEqual(runCompletion(false, false), ["cleanup"]);
});
});
describe("touch drag relay data", () => {
it("keeps the block and gutter payload while excluding unrelated data", () => {
const types = [
"text/plain",
dragRelayMimeTypes.block,
`${dragRelayMimeTypes.gutterPrefix}NodeParagraph`,
];
assert.deepEqual(getDragRelayTypes(types, dragRelayMimeTypes), types.slice(1));
assert.equal(isDragRelaySource(types, dragRelayMimeTypes), true);
});
it("keeps document tree data for cross-window dragging", () => {
const types = [dragRelayMimeTypes.file, dragRelayMimeTypes.documents, "text/html"];
assert.deepEqual(getDragRelayTypes(types, dragRelayMimeTypes), types.slice(0, 2));
assert.equal(isDragRelaySource(types, dragRelayMimeTypes), true);
});
it("rejects incomplete relay payloads", () => {
assert.equal(isDragRelaySource([dragRelayMimeTypes.block], dragRelayMimeTypes), false);
assert.equal(isDragRelaySource([dragRelayMimeTypes.documents], dragRelayMimeTypes), false);
});
});
describe("desktop mouse drag candidates", () => {
it("does not suppress a trusted context menu for a mouse candidate", () => {
const activeGesture = hasActiveTouchGesture([{isMouse: true}, null]);
assert.equal(shouldSuppressNativeContextMenu(true, activeGesture), false);
assert.equal(hasActiveTouchGesture([{isMouse: false}, {isMouse: true}]), true);
});
it("starts desktop mouse drags without the touch long-press delay", () => {
assert.equal(shouldRequireLongPress(true, true, false), false);
assert.equal(shouldRequireLongPress(true, true, true), true);
assert.equal(shouldRequireLongPress(true, false, false), true);
});
it("keeps an active desktop relay alive after its source window loses capture", () => {
assert.equal(shouldCancelPointerDragAfterWindowExit(false, true, true), false);
assert.equal(shouldCancelPointerDragAfterWindowExit(false, false, true), true);
assert.equal(shouldCancelPointerDragAfterWindowExit(false, true, false), true);
assert.equal(shouldCancelPointerDragAfterWindowExit(true, true, true), true);
});
it("requests a drop when the mouse is released over a foreign desktop window", () => {
assert.equal(shouldRequestForeignMouseDrop(false, 0, true, false), true);
assert.equal(shouldRequestForeignMouseDrop(false, 1, true, false), false);
assert.equal(shouldRequestForeignMouseDrop(false, 0, false, false), false);
assert.equal(shouldRequestForeignMouseDrop(false, 0, true, true), false);
assert.equal(shouldRequestForeignMouseDrop(true, 0, true, false), false);
});
it("hides the source drag ghost after the pointer leaves its window", () => {
assert.equal(getSourceDragGhostVisibility(false), "");
assert.equal(getSourceDragGhostVisibility(true), "hidden");
});
});
describe("synthetic drag wheel scrolling", () => {
it("normalizes pixel, line, and page wheel deltas", () => {
assert.equal(getWheelScrollDelta(12, 0, 30, 300), 12);
assert.equal(getWheelScrollDelta(2, 1, 30, 300), 60);
assert.equal(getWheelScrollDelta(-1, 2, 30, 300), -300);
});
});
describe("touch drag refresh queue", () => {
const createFrameHarness = () => {
let nextHandle = 0;
const callbacks = new Map<number, FrameRequestCallback>();
const canceled: number[] = [];
return {
requestFrame: (callback: FrameRequestCallback) => {
const handle = ++nextHandle;
callbacks.set(handle, callback);
return handle;
},
cancelFrame: (handle: number) => {
canceled.push(handle);
},
runFrame: (handle: number) => callbacks.get(handle)?.(0),
getRequestedCount: () => callbacks.size,
getCanceled: () => canceled,
};
};
it("coalesces refreshes scheduled in the same frame", () => {
const frames = createFrameHarness();
let refreshCount = 0;
const queue = createDragRefreshQueue(
() => refreshCount++,
frames.requestFrame,
frames.cancelFrame,
);
queue.schedule();
queue.schedule();
assert.equal(frames.getRequestedCount(), 1);
frames.runFrame(1);
assert.equal(refreshCount, 1);
});
it("does not refresh after canceling a scheduled frame", () => {
const frames = createFrameHarness();
let refreshCount = 0;
const queue = createDragRefreshQueue(
() => refreshCount++,
frames.requestFrame,
frames.cancelFrame,
);
queue.schedule();
queue.cancel();
frames.runFrame(1);
assert.deepEqual(frames.getCanceled(), [1]);
assert.equal(refreshCount, 0);
});
it("allows scheduling again after a refresh", () => {
const frames = createFrameHarness();
let refreshCount = 0;
const queue = createDragRefreshQueue(
() => refreshCount++,
frames.requestFrame,
frames.cancelFrame,
);
queue.schedule();
frames.runFrame(1);
queue.schedule();
frames.runFrame(2);
assert.equal(refreshCount, 2);
assert.equal(frames.getRequestedCount(), 2);
});
});
describe("touch drag context menu", () => {
it("only suppresses a trusted native menu during an active gesture", () => {
assert.equal(shouldSuppressNativeContextMenu(true, true), true);
assert.equal(shouldSuppressNativeContextMenu(false, true), false);
assert.equal(shouldSuppressNativeContextMenu(true, false), false);
});
});