Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

:sparkles: Support block drag selection on Android and iOS

Danielaf1f8a587d96
diff --git a/app/src/boot/globalEvent/dragover.ts b/app/src/boot/globalEvent/dragover.ts
index 0eaaaf94a7..4345afd665 100644
--- a/app/src/boot/globalEvent/dragover.ts
+++ b/app/src/boot/globalEvent/dragover.ts
@@ -58,7 +58,8 @@ const scrollAnimation = (timestamp: number) => {
dragoverScroll.lastTime = timestamp;
};
-export const dragOverScroll = (moveEvent: MouseEvent, contentRect: DOMRect, element: Element, direction: "x" | "y" = "y") => {
+export const dragOverScroll = (moveEvent: Pick<MouseEvent, "clientX" | "clientY">, contentRect: DOMRect,
+ element: Element, direction: "x" | "y" = "y") => {
const clientPosition = direction === "x" ? moveEvent.clientX : moveEvent.clientY;
const start = direction === "x" ? contentRect.left : contentRect.top;
const end = direction === "x" ? contentRect.right : contentRect.bottom;
diff --git a/app/src/mobile/util/sidebarSwipe.test.ts b/app/src/mobile/util/sidebarSwipe.test.ts
index 75dccfa3ec..de9566c8ce 100644
--- a/app/src/mobile/util/sidebarSwipe.test.ts
+++ b/app/src/mobile/util/sidebarSwipe.test.ts
@@ -133,6 +133,8 @@ const createTouchHarness = (side: "left" | "right", options: {
start: (x = 180, y = 200) => touch.handleTouchStart(event(x, y)),
move: (x: number, y = 200, count = 1) => touch.handleTouchMove(event(x, y, count)),
end: (x: number, y = 200) => { now += 100; touch.handleTouchEnd(event(x, y)); },
+ handledMove: (x: number) => touch.handleTouchMove({...event(x), defaultPrevented: true}),
+ handledEnd: (x: number) => touch.handleTouchEnd({...event(x), defaultPrevented: true}),
cancel: () => touch.handleTouchCancel(),
};
};
@@ -140,6 +142,18 @@ const createTouchHarness = (side: "left" | "right", options: {
for (const side of ["left", "right"] as const) {
const nextX = side === "left" ? 240 : 120;
const closeX = side === "left" ? 120 : 240;
+ test(`${side} sidebar does not reuse a gesture consumed by editor block selection`, () => {
+ const harness = createTouchHarness(side, {closed: true});
+ harness.start();
+ harness.handledMove(nextX);
+ harness.handledEnd(nextX);
+ assert.deepEqual(harness.actions, []);
+ harness.start();
+ harness.move(nextX);
+ harness.end(nextX);
+ assert.deepEqual(harness.actions, [`open:${side}`]);
+ });
+
test(`${side} sidebar ignores the complete gesture inside a protected canvas and resumes outside it`, () => {
const harness = createTouchHarness(side, {closed: true});
harness.start();
diff --git a/app/src/mobile/util/touch.ts b/app/src/mobile/util/touch.ts
index b10135bddf..99bff32293 100644
--- a/app/src/mobile/util/touch.ts
+++ b/app/src/mobile/util/touch.ts
@@ -147,6 +147,11 @@ export const handleTouchSelectionChange = () => {
};
export const handleTouchEnd = (event: TouchEvent) => {
+ if (event.defaultPrevented) {
+ resetTouchGesture();
+ handleTouchUp();
+ return;
+ }
updateSidebarSwipeState();
if (preventSwipe) {
return;
@@ -442,6 +447,10 @@ const isHorizontalScrollable = (target: HTMLElement, xDiff: number) => {
};
export const handleTouchMove = (event: TouchEvent) => {
+ if (event.defaultPrevented) {
+ resetTouchGesture();
+ return;
+ }
const target = event.target as HTMLElement;
// 位移超过阈值说明是滑动而非长按,取消进入多选的定时器
if (clientX && clientY &&
diff --git a/app/src/protyle/wysiwyg/blockDragSelectionGesture.test.ts b/app/src/protyle/wysiwyg/blockDragSelectionGesture.test.ts
new file mode 100644
index 0000000000..431c98bb8c
--- /dev/null
+++ b/app/src/protyle/wysiwyg/blockDragSelectionGesture.test.ts
@@ -0,0 +1,217 @@
+import * as assert from "node:assert/strict";
+import {readFileSync} from "node:fs";
+import {test} from "node:test";
+import {runInNewContext} from "node:vm";
+import {ModuleKind, ScriptTarget, transpileModule} from "typescript";
+
+const compiled = transpileModule(readFileSync("src/protyle/wysiwyg/blockDragSelectionGesture.ts", "utf8"), {
+ compilerOptions: {module: ModuleKind.CommonJS, target: ScriptTarget.ES2021},
+}).outputText;
+
+class Surface {
+ listeners = new Map<string, Set<(event: any) => void>>();
+
+ addEventListener(type: string, listener: (event: any) => void) {
+ if (!this.listeners.has(type)) {
+ this.listeners.set(type, new Set());
+ }
+ this.listeners.get(type).add(listener);
+ }
+
+ removeEventListener(type: string, listener: (event: any) => void) {
+ this.listeners.get(type)?.delete(listener);
+ }
+
+ send(type: string, properties: Record<string, unknown> = {}) {
+ const event = {
+ type, clientX: 20, clientY: 20, button: 0, buttons: 1, detail: 1,
+ cancelable: true, defaultPrevented: false, stopped: false,
+ preventDefault() { this.defaultPrevented = true; },
+ stopImmediatePropagation() { this.stopped = true; },
+ ...properties,
+ };
+ for (const listener of Array.from(this.listeners.get(type) || [])) {
+ listener(event);
+ if (event.stopped) {
+ break;
+ }
+ }
+ return event;
+ }
+
+ count() {
+ return Array.from(this.listeners.values()).reduce((total, listeners) => total + listeners.size, 0);
+ }
+}
+
+const fixture = () => {
+ const exports: any = {};
+ let time = 10000;
+ const window = new Surface();
+ const document = Object.assign(new Surface(), {defaultView: window});
+ const blocks = [{id: "a"}, {id: "b"}, {id: "c"}];
+ const element = Object.assign(new Surface(), {ownerDocument: document, contains: (): boolean => true});
+ const scrollElement = new Surface();
+ let enabled = true;
+ let multiSelect = false;
+ const selections: string[][] = [];
+ const finishes: Array<{source: string, cancelled: boolean}> = [];
+ const scrolls: unknown[] = [];
+ runInNewContext(compiled, {
+ exports,
+ require: () => ({Constants: {SIZE_DRAG_THRESHOLD: 5, TIMEOUT_MULTIPLE_SELECT: 1500}}),
+ Date: {now: () => time},
+ });
+ const dispose = exports.bindBlockDragSelectionGesture(element, scrollElement, {
+ canStart: () => enabled,
+ getStartBlock: (target: object) => blocks.includes(target as typeof blocks[0]) ? target : undefined,
+ getBlockAtPoint: (point: {clientY: number}) => blocks[Math.floor(point.clientY / 100)],
+ isMultiSelectMode: () => multiSelect,
+ select: (start: typeof blocks[0], end: typeof blocks[0]) => selections.push([start.id, end.id]),
+ scroll: (point: unknown) => scrolls.push(point),
+ finish: (source: string, cancelled: boolean) => finishes.push({source, cancelled}),
+ });
+ const mouseDown = (properties = {}) => element.send("mousedown", {target: blocks[0], ...properties});
+ const touch = (type: string, y = 20, properties = {}) => {
+ const point = {identifier: 1, clientX: 20, clientY: y};
+ return (type === "touchstart" ? element : document).send(type, {
+ target: blocks[0], touches: type === "touchend" ? [] : [point], changedTouches: [point], ...properties,
+ });
+ };
+ return {
+ element, document, window, scrollElement, selections, finishes, scrolls, blocks, dispose, mouseDown, touch,
+ advance: (milliseconds: number) => time += milliseconds,
+ disable: () => enabled = false,
+ enterMultiSelect: () => multiSelect = true,
+ };
+};
+
+test("mouse text selection stays native in one block and becomes a reversible whole-block range across blocks", () => {
+ const f = fixture();
+ f.mouseDown();
+ assert.equal(f.document.send("mousemove", {clientY: 50}).defaultPrevented, false);
+ assert.deepEqual(f.selections, []);
+ assert.equal(f.document.send("mousemove", {clientY: 220}).defaultPrevented, true);
+ f.document.send("mousemove", {clientY: 120});
+ f.document.send("mousemove", {clientY: 20});
+ assert.deepEqual(f.selections, [["a", "c"], ["a", "b"], ["a", "a"]]);
+ assert.equal(f.document.send("mouseup").stopped, true);
+ assert.deepEqual(f.finishes, [{source: "mouse", cancelled: false}]);
+ assert.equal(f.element.send("click").defaultPrevented, true);
+ assert.equal(f.document.count(), 0);
+ assert.equal(f.scrollElement.count(), 0);
+ assert.equal(f.window.count(), 0);
+});
+
+test("new gestures preserve modifier clicks, right clicks, double clicks and handled controls", () => {
+ for (const properties of [{ctrlKey: true}, {shiftKey: true}, {metaKey: true}, {altKey: true},
+ {button: 2}, {detail: 2}, {defaultPrevented: true}, {target: {}},
+ {sourceCapabilities: {firesTouchEvents: true}}]) {
+ const f = fixture();
+ f.mouseDown(properties);
+ f.document.send("mousemove", {clientY: 220});
+ assert.deepEqual(f.selections, []);
+ assert.equal(f.document.count(), 0);
+ }
+});
+
+test("ordinary touch scrolling never changes into block selection after waiting", () => {
+ const f = fixture();
+ f.touch("touchstart");
+ assert.equal(f.touch("touchmove", 50).defaultPrevented, false);
+ f.advance(2000);
+ f.touch("touchmove", 220);
+ f.touch("touchend", 220);
+ assert.deepEqual(f.selections, []);
+ assert.equal(f.document.count(), 0);
+});
+
+test("a sustained touch can cross block boundaries without changing a short native word selection", () => {
+ const f = fixture();
+ f.touch("touchstart");
+ f.advance(1600);
+ assert.equal(f.touch("touchmove", 22).defaultPrevented, false);
+ assert.equal(f.touch("touchmove", 120).defaultPrevented, true);
+ assert.equal(f.touch("touchmove", 220).defaultPrevented, true);
+ assert.equal(f.touch("touchend", 220).defaultPrevented, true);
+ assert.deepEqual(f.selections, [["a", "b"], ["a", "c"]]);
+ assert.deepEqual(f.finishes, [{source: "touch", cancelled: false}]);
+ f.mouseDown();
+ assert.equal(f.document.count(), 0);
+});
+
+test("multi-select touch suppresses native scrolling and supports dragging after long-press activation", () => {
+ const f = fixture();
+ f.touch("touchstart");
+ f.enterMultiSelect();
+ assert.equal(f.touch("touchmove", 50).defaultPrevented, true);
+ f.touch("touchmove", 220);
+ f.touch("touchend", 220);
+ assert.deepEqual(f.selections, [["a", "a"], ["a", "c"]]);
+ assert.equal(f.touch("touchstart").defaultPrevented, true);
+ assert.equal(f.touch("touchend").defaultPrevented, false);
+});
+
+test("multi-touch, native cancellation, lost buttons, escape, blur and disposal release gesture listeners", () => {
+ for (const end of ["multi-touch", "touchcancel", "buttons", "escape", "blur", "dispose", "disabled", "detached"]) {
+ const f = fixture();
+ if (end === "multi-touch" || end === "touchcancel") {
+ f.enterMultiSelect();
+ f.touch("touchstart");
+ f.touch("touchmove", 120);
+ f.document.send(end === "multi-touch" ? "touchstart" : "touchcancel", {touches: [{}, {}]});
+ } else {
+ f.mouseDown();
+ f.document.send("mousemove", {clientY: 120});
+ if (end === "buttons") {
+ f.document.send("mousemove", {buttons: 0});
+ } else if (end === "escape") {
+ f.document.send("keydown", {key: "Escape"});
+ } else if (end === "blur") {
+ f.window.send("blur");
+ } else if (end === "disabled" || end === "detached") {
+ if (end === "disabled") {
+ f.disable();
+ } else {
+ f.element.contains = () => false;
+ }
+ f.document.send("mousemove", {clientY: 220});
+ } else {
+ f.dispose();
+ assert.equal(f.element.count(), 0);
+ }
+ }
+ assert.equal(f.finishes.length, 1, end);
+ assert.equal(f.document.count(), 0, end);
+ assert.equal(f.window.count(), 0, end);
+ assert.equal(f.scrolls[f.scrolls.length - 1], undefined, end);
+ }
+});
+
+test("scrolling refreshes the active range and a composition cancels it without consuming IME input", () => {
+ const f = fixture();
+ f.mouseDown();
+ f.document.send("mousemove", {clientY: 120});
+ f.scrollElement.send("scroll");
+ assert.equal(f.selections.length, 2);
+ assert.equal(f.element.send("compositionstart").defaultPrevented, false);
+ assert.deepEqual(f.finishes, [{source: "mouse", cancelled: true}]);
+ f.mouseDown();
+ assert.equal(f.document.count(), 0);
+ f.element.send("compositionend");
+ f.mouseDown();
+ f.document.send("mousemove", {clientY: 220});
+ f.document.send("mouseup");
+ assert.deepEqual(f.selections[f.selections.length - 1], ["a", "c"]);
+});
+
+test("native drag and non-cancelable touch scrolling stay with the browser", () => {
+ const f = fixture();
+ f.mouseDown();
+ assert.equal(f.document.send("dragstart").defaultPrevented, false);
+ assert.equal(f.document.count(), 0);
+ f.touch("touchstart");
+ f.advance(1600);
+ assert.equal(f.touch("touchmove", 120, {cancelable: false}).defaultPrevented, false);
+ assert.deepEqual(f.selections, []);
+});
diff --git a/app/src/protyle/wysiwyg/blockDragSelectionGesture.ts b/app/src/protyle/wysiwyg/blockDragSelectionGesture.ts
new file mode 100644
index 0000000000..397526973f
--- /dev/null
+++ b/app/src/protyle/wysiwyg/blockDragSelectionGesture.ts
@@ -0,0 +1,212 @@
+import {Constants} from "../../constants";
+
+type TPoint = {clientX: number, clientY: number};
+type TSource = "mouse" | "touch";
+
+interface IBlockDragSelectionOptions {
+ canStart: (source: TSource) => boolean;
+ getStartBlock: (target: HTMLElement, source: TSource) => HTMLElement | undefined;
+ getBlockAtPoint: (point: TPoint) => HTMLElement | undefined;
+ isMultiSelectMode: () => boolean;
+ select: (start: HTMLElement, end: HTMLElement, source: TSource) => void;
+ scroll: (point?: TPoint) => void;
+ finish: (source: TSource, cancelled: boolean) => void;
+}
+
+// 文字选区保留在单个编辑宿主内,跨块拖动由应用维护整块选区。
+export const bindBlockDragSelectionGesture = (element: HTMLElement, scrollElement: HTMLElement,
+ options: IBlockDragSelectionOptions) => {
+ const ownerDocument = element.ownerDocument;
+ const ownerWindow = ownerDocument.defaultView;
+ let gesture: {
+ source: TSource, block: HTMLElement, point: TPoint, time: number, touchID?: number,
+ active: boolean, lastPoint: TPoint,
+ } | undefined;
+ let suppressClickUntil = 0;
+ let lastTouchTime = 0;
+ let composing = false;
+
+ const finish = (cancelled: boolean) => {
+ const previous = gesture;
+ gesture = undefined;
+ ownerDocument.removeEventListener("mousemove", mouseMove, true);
+ ownerDocument.removeEventListener("mouseup", mouseUp, true);
+ ownerDocument.removeEventListener("touchmove", touchMove, true);
+ ownerDocument.removeEventListener("touchend", touchEnd, true);
+ ownerDocument.removeEventListener("touchcancel", cancel, true);
+ ownerDocument.removeEventListener("touchstart", additionalTouch, true);
+ ownerDocument.removeEventListener("keydown", keyDown, true);
+ ownerDocument.removeEventListener("dragstart", dragStart, true);
+ scrollElement.removeEventListener("scroll", scroll);
+ ownerWindow.removeEventListener("blur", cancel);
+ if (previous?.active) {
+ suppressClickUntil = Date.now() + 500;
+ options.scroll();
+ options.finish(previous.source, cancelled);
+ }
+ };
+ const cancel = () => finish(true);
+ const keyDown = (event: KeyboardEvent) => {
+ if (event.key === "Escape") {
+ cancel();
+ }
+ };
+ const dragStart = (event: DragEvent) => {
+ if (gesture?.active) {
+ event.preventDefault();
+ } else {
+ cancel();
+ }
+ };
+ const update = (point: TPoint, allowSingleBlock = false) => {
+ if (!gesture || composing || !element.contains(gesture.block) || !options.canStart(gesture.source)) {
+ cancel();
+ return false;
+ }
+ const end = options.getBlockAtPoint(point);
+ if (!gesture.active && (!end || end === gesture.block && !allowSingleBlock)) {
+ return false;
+ }
+ gesture.active = true;
+ gesture.lastPoint = point;
+ if (end) {
+ options.select(gesture.block, end, gesture.source);
+ }
+ options.scroll(point);
+ return true;
+ };
+ const scroll = () => {
+ if (gesture?.active) {
+ update(gesture.lastPoint);
+ }
+ };
+ const mouseMove = (event: MouseEvent) => {
+ if ((event.buttons & 1) === 0) {
+ finish(false);
+ } else if (update(event)) {
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ }
+ };
+ const mouseUp = (event: MouseEvent) => {
+ const active = gesture?.active;
+ finish(false);
+ if (active) {
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ }
+ };
+ const additionalTouch = (event: TouchEvent) => {
+ if (event.touches.length !== 1) {
+ cancel();
+ }
+ };
+ const touchMove = (event: TouchEvent) => {
+ const touch = gesture && Array.from(event.touches).find(item => item.identifier === gesture.touchID);
+ if (!touch || event.touches.length !== 1 || !event.cancelable) {
+ cancel();
+ return;
+ }
+ if (!gesture.active) {
+ if (Math.abs(touch.clientX - gesture.point.clientX) < Constants.SIZE_DRAG_THRESHOLD &&
+ Math.abs(touch.clientY - gesture.point.clientY) < Constants.SIZE_DRAG_THRESHOLD) {
+ return;
+ }
+ // 普通滑动交给浏览器滚动;多选模式或持续长按后的滑动才尝试扩选。
+ if (!options.isMultiSelectMode() && Date.now() - gesture.time < Constants.TIMEOUT_MULTIPLE_SELECT) {
+ cancel();
+ return;
+ }
+ }
+ if (update(touch, options.isMultiSelectMode())) {
+ // 保留冒泡,让移动端全局手势清理自己的长按和侧栏滑动状态。
+ event.preventDefault();
+ }
+ };
+ const touchEnd = (event: TouchEvent) => {
+ lastTouchTime = Date.now();
+ if (!gesture || !Array.from(event.changedTouches).some(item => item.identifier === gesture.touchID)) {
+ return;
+ }
+ const active = gesture.active;
+ finish(false);
+ if (active) {
+ event.preventDefault();
+ }
+ };
+ const start = (target: HTMLElement, point: TPoint, source: TSource, touchID?: number) => {
+ finish(true);
+ suppressClickUntil = 0;
+ if (composing || !options.canStart(source)) {
+ return;
+ }
+ const block = options.getStartBlock(target, source);
+ if (!block) {
+ return;
+ }
+ gesture = {source, block, point, time: Date.now(), touchID, active: false, lastPoint: point};
+ ownerDocument.addEventListener("keydown", keyDown, true);
+ ownerDocument.addEventListener("dragstart", dragStart, true);
+ ownerWindow.addEventListener("blur", cancel);
+ scrollElement.addEventListener("scroll", scroll);
+ if (source === "mouse") {
+ ownerDocument.addEventListener("mousemove", mouseMove, true);
+ ownerDocument.addEventListener("mouseup", mouseUp, true);
+ } else {
+ ownerDocument.addEventListener("touchmove", touchMove, {capture: true, passive: false});
+ ownerDocument.addEventListener("touchend", touchEnd, {capture: true, passive: false});
+ ownerDocument.addEventListener("touchcancel", cancel, true);
+ ownerDocument.addEventListener("touchstart", additionalTouch, true);
+ }
+ return true;
+ };
+ const mouseDown = (event: MouseEvent & {sourceCapabilities?: {firesTouchEvents: boolean}}) => {
+ if (event.defaultPrevented || event.button !== 0 || event.detail > 1 ||
+ event.shiftKey || event.ctrlKey || event.metaKey || event.altKey || gesture?.source === "touch" ||
+ event.sourceCapabilities?.firesTouchEvents || Date.now() - lastTouchTime < 500) {
+ return;
+ }
+ start(event.target as HTMLElement, event, "mouse");
+ };
+ const touchStart = (event: TouchEvent) => {
+ lastTouchTime = Date.now();
+ if (event.defaultPrevented || event.touches.length !== 1) {
+ cancel();
+ return;
+ }
+ const touch = event.touches[0];
+ if (start(event.target as HTMLElement, touch, "touch", touch.identifier) && options.isMultiSelectMode()) {
+ // 多选模式中的触摸从按下时阻止原生滚动,松手未移动仍交给现有点选处理。
+ event.preventDefault();
+ }
+ };
+ const click = (event: MouseEvent) => {
+ if (Date.now() < suppressClickUntil) {
+ suppressClickUntil = 0;
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ }
+ };
+ const compositionStart = () => {
+ composing = true;
+ cancel();
+ };
+ const compositionEnd = () => {
+ composing = false;
+ };
+ element.addEventListener("mousedown", mouseDown);
+ element.addEventListener("touchstart", touchStart, {passive: false});
+ element.addEventListener("click", click, true);
+ element.addEventListener("compositionstart", compositionStart);
+ element.addEventListener("compositionend", compositionEnd);
+ element.addEventListener("focusout", compositionEnd);
+ return () => {
+ cancel();
+ element.removeEventListener("mousedown", mouseDown);
+ element.removeEventListener("touchstart", touchStart);
+ element.removeEventListener("click", click, true);
+ element.removeEventListener("compositionstart", compositionStart);
+ element.removeEventListener("compositionend", compositionEnd);
+ element.removeEventListener("focusout", compositionEnd);
+ };
+};
diff --git a/app/src/protyle/wysiwyg/boundedBlockDragSelect.test.ts b/app/src/protyle/wysiwyg/boundedBlockDragSelect.test.ts
new file mode 100644
index 0000000000..d8a9890fb3
--- /dev/null
+++ b/app/src/protyle/wysiwyg/boundedBlockDragSelect.test.ts
@@ -0,0 +1,146 @@
+import * as assert from "node:assert/strict";
+import {readFileSync} from "node:fs";
+import {test} from "node:test";
+import {runInNewContext} from "node:vm";
+import {ModuleKind, ScriptTarget, transpileModule} from "typescript";
+import type {bindBlockDragSelectionGesture} from "./blockDragSelectionGesture";
+
+const compiled = transpileModule(readFileSync("src/protyle/wysiwyg/boundedBlockDragSelect.ts", "utf8"), {
+ compilerOptions: {module: ModuleKind.CommonJS, target: ScriptTarget.ES2021},
+}).outputText;
+
+const fixture = (mobile = false) => {
+ const exports: any = {};
+ const classes = new Set<string>();
+ let rootEditable = "false";
+ let backlink = false;
+ let multiSelect = false;
+ let blockOwned = true;
+ let selectionCleared = 0;
+ let focused: unknown;
+ let modeElement: unknown;
+ let toolbarCount = 0;
+ const states = [new Set<string>(), new Set<string>()];
+ const blocks = states.map((state, index) => ({
+ classList: {add: (name: string) => state.add(name), remove: (name: string) => state.delete(name)},
+ getAttribute: () => `block-${index}`,
+ removeAttribute: () => {},
+ contains: (other: unknown): boolean => other === blocks[index],
+ }));
+ const element = {
+ classList: {contains: (name: string) => classes.has(name), add: (name: string) => classes.add(name),
+ remove: (name: string) => classes.delete(name)},
+ getAttribute: () => rootEditable,
+ closest: () => backlink ? {} : null,
+ contains: () => blockOwned,
+ ownerDocument: {getSelection: () => ({removeAllRanges: () => selectionCleared++})},
+ querySelectorAll: () => blocks.filter((_, i) => states[i].has("protyle-wysiwyg--select")),
+ };
+ const protyle: any = {
+ gutter: {}, disabled: false,
+ toolbar: {isMultiSelectMode: () => multiSelect, subElement: {},
+ showMultiSelectMode: () => multiSelect = true},
+ contentElement: {getBoundingClientRect: () => ({left: 0, right: 100, top: 0, bottom: 100})},
+ };
+ let options: Parameters<typeof bindBlockDragSelectionGesture>[2];
+ const modules: Record<string, unknown> = {
+ "./blockDragSelectionGesture": {bindBlockDragSelectionGesture: (_element: unknown, _scroll: unknown,
+ value: typeof options) => options = value},
+ "./blockSelection": {
+ BLOCK_SELECTION_CLASS: "protyle-wysiwyg--select",
+ clearBlockSelectionMode: () => states.forEach(state => state.clear()),
+ setBlockSelectionModeElement: (_element: unknown, block: unknown) => modeElement = block,
+ },
+ "./blockDragSelect": {getBlockDragSelectBlock: () => blocks[0]},
+ "./getBlock": {},
+ "../util/hasClosest": {isInEmbedBlock: () => false},
+ "../util/selection": {
+ focusBlock: (block: unknown) => focused = block,
+ getBlockRangeSelectElements: () => ({selectElements: blocks}),
+ },
+ "../ui/hideElements": {hideElements: () => {}},
+ "../../util/functions": {isMobile: () => mobile},
+ "../../layout/status": {countBlockWord: () => {}},
+ "../../mobile/util/multiSelectToolbar": {updateMultiSelectToolbar: (_element: unknown, count: number) => toolbarCount = count},
+ };
+ runInNewContext(compiled, {exports, require: (name: string) => modules[name], window: {siyuan: {}}});
+ // 构造 WYSIWYG 时实例尚未赋给 protyle,绑定阶段不能从 protyle 读取编辑器元素。
+ exports.bindBoundedBlockDragSelect(protyle, element);
+ protyle.wysiwyg = {element};
+ const target = (excluded = false, editable = true, ownEditor = true) => ({
+ closest: (selector: string) => {
+ if (selector === ".protyle-wysiwyg") {
+ return ownEditor ? element : {};
+ }
+ if (selector === '[contenteditable="true"]' || selector === "[contenteditable]") {
+ return {getAttribute: () => editable ? "true" : "false"};
+ }
+ return excluded ? {} : null;
+ },
+ } as unknown as HTMLElement);
+ return {
+ options: options!, protyle, blocks: blocks as unknown as HTMLElement[], classes, states, target,
+ setEditable: (value: string) => rootEditable = value,
+ setBacklink: () => backlink = true,
+ detach: () => blockOwned = false,
+ enterMultiSelect: () => multiSelect = true,
+ state: () => ({focused, modeElement, multiSelect, selectionCleared, toolbarCount}),
+ };
+};
+
+test("bounded mouse selection is enabled only for protected editor roots with block operations", () => {
+ const f = fixture();
+ assert.equal(f.options.canStart("mouse"), true);
+ f.setEditable("true");
+ assert.equal(f.options.canStart("mouse"), false);
+ assert.equal(f.options.canStart("touch"), true);
+ f.setEditable("false");
+ f.classes.add("fn__pointer-none");
+ assert.equal(f.options.canStart("mouse"), false, "padding drag retains ownership of its gesture");
+ f.classes.clear();
+ f.protyle.disabled = true;
+ assert.equal(f.options.canStart("touch"), false);
+ f.protyle.disabled = false;
+ f.setBacklink();
+ assert.equal(f.options.canStart("mouse"), false);
+});
+
+test("bounded selection starts in editable block content and leaves controls and nested editors alone", () => {
+ const f = fixture();
+ assert.equal(f.options.getStartBlock(f.target(), "mouse"), f.blocks[0]);
+ assert.equal(f.options.getStartBlock(f.target(true), "mouse"), undefined);
+ assert.equal(f.options.getStartBlock(f.target(false, false), "mouse"), undefined);
+ assert.equal(f.options.getStartBlock(f.target(false, true, false), "mouse"), undefined);
+ f.enterMultiSelect();
+ assert.equal(f.options.getStartBlock(f.target(false, false), "touch"), f.blocks[0]);
+});
+
+test("desktop completion uses existing block selection and a focusable block without reopening the editor root", () => {
+ const f = fixture();
+ f.options.select(f.blocks[0], f.blocks[1], "mouse");
+ assert.ok(f.states.every(state => state.has("protyle-wysiwyg--select")));
+ assert.equal(f.state().selectionCleared, 1);
+ assert.ok(f.classes.has("protyle-wysiwyg--hiderange"));
+ f.options.finish("mouse", false);
+ assert.equal(f.state().focused, f.blocks[1]);
+ assert.equal(f.state().modeElement, f.blocks[1]);
+ assert.equal(f.classes.has("protyle-wysiwyg--hiderange"), false);
+ assert.equal(f.options.canStart("mouse"), true);
+});
+
+test("mobile completion retains the multi-select toolbar and cancellation does not steal focus", () => {
+ const f = fixture(true);
+ f.options.select(f.blocks[0], f.blocks[1], "touch");
+ f.options.finish("touch", false);
+ assert.equal(f.state().multiSelect, true);
+ assert.equal(f.state().focused, undefined);
+ f.options.select(f.blocks[0], f.blocks[1], "touch");
+ assert.equal(f.state().toolbarCount, 2);
+ f.options.finish("touch", true);
+ assert.equal(f.classes.has("protyle-wysiwyg--hiderange"), false);
+ const removed = fixture();
+ removed.options.select(removed.blocks[0], removed.blocks[1], "mouse");
+ removed.detach();
+ removed.options.finish("mouse", false);
+ assert.equal(removed.state().focused, undefined);
+});
diff --git a/app/src/protyle/wysiwyg/boundedBlockDragSelect.ts b/app/src/protyle/wysiwyg/boundedBlockDragSelect.ts
new file mode 100644
index 0000000000..8757842323
--- /dev/null
+++ b/app/src/protyle/wysiwyg/boundedBlockDragSelect.ts
@@ -0,0 +1,106 @@
+import {dragOverScroll, stopScrollAnimation} from "../../boot/globalEvent/dragover";
+import {countBlockWord} from "../../layout/status";
+import {updateMultiSelectToolbar} from "../../mobile/util/multiSelectToolbar";
+import {isMobile} from "../../util/functions";
+import {hideElements} from "../ui/hideElements";
+import {hasClosestBlock, isInEmbedBlock} from "../util/hasClosest";
+import {focusBlock, getBlockRangeSelectElements} from "../util/selection";
+import {getBlockDragSelectBlock} from "./blockDragSelect";
+import {bindBlockDragSelectionGesture} from "./blockDragSelectionGesture";
+import {BLOCK_SELECTION_CLASS, clearBlockSelectionMode, setBlockSelectionModeElement} from "./blockSelection";
+import {isContainerBlock} from "./getBlock";
+
+export const bindBoundedBlockDragSelect = (protyle: IProtyle, element: HTMLElement) => {
+ let selected: HTMLElement[] = [];
+ let activeBlock: HTMLElement;
+ let selecting = false;
+ const getBlock = (target: Element) => {
+ if (!target || target.closest(".protyle-wysiwyg") !== element) {
+ return undefined;
+ }
+ const block = getBlockDragSelectBlock(target, element, hasClosestBlock, isContainerBlock,
+ item => item.getAttribute("data-type") === "NodeListItem");
+ return block ? (isInEmbedBlock(block) || block) as HTMLElement : undefined;
+ };
+ return bindBlockDragSelectionGesture(element, protyle.contentElement, {
+ canStart: source => !!protyle.gutter && !protyle.disabled &&
+ !window.siyuan.touchDragActive && !element.closest(".sy__backlink--bottom") &&
+ !element.classList.contains("fn__pointer-none") &&
+ // iPad 保留可跨块编辑的正文宿主,鼠标继续使用其原生文字选区。
+ (source === "touch" || element.getAttribute("contenteditable") === "false"),
+ isMultiSelectMode: () => protyle.toolbar.isMultiSelectMode(),
+ getStartBlock: (target, source) => {
+ if (target.closest("input, textarea, select, button, a, audio, video, iframe, protyle-html, " +
+ ".protyle-action, .protyle-attr, .protyle-action__drag, .sb__resize, .protyle-custom, " +
+ ".av, .table, .protyle-wysiwyg__embed, [data-type='NodeBlockQueryEmbed'], [data-prevent-swipe]")) {
+ return undefined;
+ }
+ if (source === "mouse" || !protyle.toolbar.isMultiSelectMode()) {
+ const editable = target.closest('[contenteditable="true"]');
+ if (!editable || !element.contains(editable) ||
+ target.closest("[contenteditable]")?.getAttribute("contenteditable") !== "true") {
+ return undefined;
+ }
+ }
+ return getBlock(target);
+ },
+ getBlockAtPoint: point => {
+ const rect = protyle.contentElement.getBoundingClientRect();
+ if (point.clientX < rect.left || point.clientX > rect.right) {
+ return undefined;
+ }
+ return getBlock(element.ownerDocument.elementFromPoint(point.clientX,
+ Math.max(rect.top + 1, Math.min(point.clientY, rect.bottom - 1))));
+ },
+ select: (start, end) => {
+ if (!selecting) {
+ selecting = true;
+ clearBlockSelectionMode(element, true);
+ hideElements(["toolbar", "gutter", "hint"], protyle);
+ element.classList.add("protyle-wysiwyg--hiderange");
+ }
+ element.ownerDocument.getSelection()?.removeAllRanges();
+ selected = getBlockRangeSelectElements(start, end).selectElements;
+ const next = new Set(selected);
+ element.querySelectorAll(`.${BLOCK_SELECTION_CLASS}`).forEach(item => {
+ if (!next.has(item as HTMLElement)) {
+ item.classList.remove(BLOCK_SELECTION_CLASS);
+ }
+ item.removeAttribute("select-start");
+ item.removeAttribute("select-end");
+ });
+ selected.forEach(item => item.classList.add(BLOCK_SELECTION_CLASS));
+ activeBlock = selected.find(item => item === end || item.contains(end)) || selected[selected.length - 1];
+ if (protyle.toolbar.isMultiSelectMode()) {
+ updateMultiSelectToolbar(protyle.toolbar.subElement, selected.length);
+ }
+ },
+ scroll: point => {
+ const rect = protyle.contentElement.getBoundingClientRect();
+ if (point && point.clientX >= rect.left && point.clientX <= rect.right) {
+ dragOverScroll(point, rect, protyle.contentElement);
+ } else {
+ stopScrollAnimation();
+ }
+ },
+ finish: (_source, cancelled) => {
+ selecting = false;
+ element.classList.remove("protyle-wysiwyg--hiderange");
+ if (!activeBlock || !element.contains(activeBlock)) {
+ return;
+ }
+ if (!cancelled) {
+ if (isMobile()) {
+ if (!protyle.toolbar.isMultiSelectMode()) {
+ protyle.toolbar.showMultiSelectMode(protyle, activeBlock);
+ }
+ } else {
+ // 保留单块内的折叠光标,让复制、剪切和删除复用已有块选区处理。
+ focusBlock(activeBlock);
+ setBlockSelectionModeElement(element, activeBlock);
+ }
+ }
+ countBlockWord(selected.map(item => item.getAttribute("data-node-id")), protyle);
+ },
+ });
+};
diff --git a/app/src/protyle/wysiwyg/index.ts b/app/src/protyle/wysiwyg/index.ts
index e028e91729..a5f4294c30 100644
--- a/app/src/protyle/wysiwyg/index.ts
+++ b/app/src/protyle/wysiwyg/index.ts
@@ -1,4 +1,5 @@
import {recordReplacementUndo} from "./replacementInput";
+import {bindBoundedBlockDragSelect} from "./boundedBlockDragSelect";
import {bindEmbedToolbarVisibility} from "./embedToolbarVisibility";
import {bindSpellcheckFocus} from "../util/spellcheckFocus";
import {isTableLikeView} from "../render/av/viewType";
@@ -406,6 +407,7 @@ export class WYSIWYG {
private disposeSpellcheckFocus?: () => void;
private disposeEmbedToolbarVisibility?: () => void;
private disposeHeadingFoldIndicators?: () => void;
+ private disposeBoundedBlockDragSelect?: () => void;
private scheduleInput(callback: () => void | Promise<void>, delay = 0, replace = true) {
if (replace && this.inputTimeout) {
@@ -545,6 +547,9 @@ export class WYSIWYG {
if (!isMobile()) {
bindTouchBlockDragSelect(this.element, () => !protyle.toolbar.isMultiSelectMode());
}
+ if (isAndroid() || isIOSDevice()) {
+ this.disposeBoundedBlockDragSelect = bindBoundedBlockDragSelect(protyle, this.element);
+ }
/// #if !MOBILE
bindTouchNavigation(this.element, (target, point) => {
if (!protyle.toolbar.isMultiSelectMode() && !window.siyuan.touchDragActive) {
@@ -576,6 +581,7 @@ export class WYSIWYG {
this.disposeHeadingFoldIndicators?.();
this.disposeEmbedToolbarVisibility?.();
this.disposeSpellcheckFocus?.();
+ this.disposeBoundedBlockDragSelect?.();
this.largeListVirtualizer?.destroy();
}