Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

fix(editor): move existing images and reorder galleries (#708)

tianma-ife590dd55c063
diff --git a/apps/web/src/components/editor/ResizableImage.tsx b/apps/web/src/components/editor/ResizableImage.tsx
index 99e1c87a..29f1ef2b 100644
--- a/apps/web/src/components/editor/ResizableImage.tsx
+++ b/apps/web/src/components/editor/ResizableImage.tsx
@@ -17,6 +17,7 @@ import { cn } from "@/lib/utils";
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
import { isImageInGallery } from "./image-editing-context";
import { createImageSelectionPlugin, imageSelectionKey } from "./image-selection";
+import { createImageDragPlugin } from "./image-drag";
export type ImageMenuRequestDetail = {
element: HTMLElement;
@@ -292,7 +293,8 @@ const ResizableImageNodeView = ({
ref={imageRef}
src={src}
alt={alt}
- draggable={false}
+ draggable={editable}
+ data-drag-handle={editable ? "" : undefined}
referrerPolicy={getImageReferrerPolicy(src)}
onClick={(event) => {
// A positioned figure does not occupy the full block wrapper. Select
@@ -391,7 +393,7 @@ const ResizableImageNodeView = ({
export const ResizableImage = Image.extend({
addProseMirrorPlugins() {
- return [...(this.parent?.() ?? []), createImageSelectionPlugin()];
+ return [...(this.parent?.() ?? []), createImageSelectionPlugin(), createImageDragPlugin()];
},
addPasteRules() {
return [createMarkdownImagePasteRule(this.type)];
diff --git a/apps/web/src/components/editor/image-drag.test.mjs b/apps/web/src/components/editor/image-drag.test.mjs
new file mode 100644
index 00000000..d2275669
--- /dev/null
+++ b/apps/web/src/components/editor/image-drag.test.mjs
@@ -0,0 +1,97 @@
+import { describe, expect, test } from "bun:test";
+import { getSchema } from "@tiptap/core";
+import StarterKit from "@tiptap/starter-kit";
+import Image from "@tiptap/extension-image";
+import { EditorState } from "@tiptap/pm/state";
+import { history, undo, redo } from "@tiptap/pm/history";
+import { ImageGallery } from "@edgeever/shared";
+import { createImageDragPlugin, imageDragKey, moveImage } from "./image-drag";
+
+const schema = getSchema([StarterKit, Image.extend({ addAttributes() {
+ return { ...this.parent(), width: { default: null }, alignment: { default: null } };
+} }), ImageGallery]);
+const image = (src) => schema.nodes.image.create({ src, alt: `alt ${src}`, title: `title ${src}`, width: 42, alignment: "right" });
+const paragraph = (text) => schema.nodes.paragraph.create(null, schema.text(text));
+const gallery = (...names) => schema.nodes.edgeeverImageGallery.create({ layout: "3", fit: "height" }, names.map(image));
+const state = (...nodes) => EditorState.create({ doc: schema.nodes.doc.create(null, nodes), plugins: [history(), createImageDragPlugin()] });
+const move = (before, from, to) => {
+ const tr = moveImage(before, from, to);
+ expect(tr).not.toBeNull();
+ const next = before.applyTransaction(tr).state;
+ next.doc.check();
+ return next;
+};
+const sources = (doc) => { const result = []; doc.descendants((node) => { if (node.type.name === "image") result.push(node.attrs.src); }); return result; };
+
+describe("existing image dragging (#708)", () => {
+ test("moves between paragraphs in either direction without changing image attributes", () => {
+ const before = state(paragraph("a"), image("/resources/original"), paragraph("b"));
+ const after = move(before, 3, 0);
+ expect(after.doc.firstChild).toBe(before.doc.child(1));
+ expect(after.doc.toJSON()).toEqual(schema.nodes.doc.create(null, [image("/resources/original"), paragraph("a"), paragraph("b")]).toJSON());
+ expect(move(after, 0, after.doc.content.size).doc.lastChild).toBe(before.doc.child(1));
+ });
+ test("reorders A,B to B,A in a gallery and preserves gallery presentation", () => {
+ const before = state(gallery("A", "B"));
+ const after = move(before, 1, 3);
+ expect(sources(after.doc)).toEqual(["B", "A"]);
+ expect(after.doc.firstChild.attrs).toEqual(before.doc.firstChild.attrs);
+ expect(after.doc.firstChild.lastChild).toBe(before.doc.firstChild.firstChild);
+ expect(move(after, 2, 1).doc.toJSON()).toEqual(before.doc.toJSON());
+ });
+ test("moving the only gallery image out removes the empty shell", () => {
+ const before = state(gallery("A"), paragraph("text"));
+ const after = move(before, 1, before.doc.content.size);
+ expect(after.doc.toJSON()).toEqual(schema.nodes.doc.create(null, [paragraph("text"), image("A")]).toJSON());
+ });
+ test("moves into and between galleries without placeholders or duplicates", () => {
+ let next = move(state(gallery("A"), gallery("B", "C")), 1, 5);
+ expect(next.doc.childCount).toBe(1);
+ expect(sources(next.doc)).toEqual(["B", "A", "C"]);
+ next = move(state(image("A"), gallery("B", "C")), 0, 3);
+ expect(next.doc.childCount).toBe(1);
+ expect(sources(next.doc)).toEqual(["B", "A", "C"]);
+ });
+ test("one undo restores the original document; redo repeats the move", () => {
+ const before = state(gallery("A"), paragraph("text"), gallery("B", "C"));
+ let next = move(before, 1, 11);
+ const moved = next.doc.toJSON();
+ expect(undo(next, (tr) => { next = next.applyTransaction(tr).state; })).toBe(true);
+ expect(next.doc.toJSON()).toEqual(before.doc.toJSON());
+ expect(redo(next, (tr) => { next = next.applyTransaction(tr).state; })).toBe(true);
+ expect(next.doc.toJSON()).toEqual(moved);
+ });
+ test("rejects self drops, adjacent no-ops, text positions and invalid positions", () => {
+ const before = state(image("A"), paragraph("text"));
+ for (const to of [-1, 0, 1, 3, 999]) expect(moveImage(before, 0, to)).toBeNull();
+ expect(moveImage(before, 1, 0)).toBeNull();
+ expect(moveImage(before, -1, 0)).toBeNull();
+ expect(moveImage(before, 999, 0)).toBeNull();
+ });
+ test("undoing a move does not undo the text typed immediately before it", () => {
+ let next = state(paragraph("a"), image("A"));
+ next = next.apply(next.tr.insertText(" typed", 2));
+ const beforeMove = next.doc.toJSON();
+ next = move(next, next.doc.firstChild.nodeSize, 0);
+ expect(undo(next, (tr) => { next = next.applyTransaction(tr).state; })).toBe(true);
+ expect(next.doc.toJSON()).toEqual(beforeMove);
+ expect(next.doc.textContent).toBe("a typed");
+ });
+ test("leaves external file drops and readonly views to their existing handlers", () => {
+ const plugin = createImageDragPlugin();
+ let next = state(image("A"), paragraph("text"));
+ next = next.apply(next.tr.setMeta(imageDragKey, 0));
+ const external = { editable: true, state: next, dragging: null };
+ expect(plugin.props.handleDrop(external, {}, null, true)).toBe(false);
+ const readonly = { ...external, editable: false, dragging: { slice: next.selection.content(), move: true } };
+ expect(plugin.props.handleDrop(readonly, {}, null, true)).toBe(false);
+ });
+ test("maps the drag source through other edits and cancels if the source is deleted", () => {
+ let next = state(paragraph("a"), image("A"));
+ next = next.apply(next.tr.setMeta(imageDragKey, 3));
+ next = next.apply(next.tr.insertText("hello", 1));
+ expect(imageDragKey.getState(next)).toBe(8);
+ next = next.apply(next.tr.delete(8, 9));
+ expect(imageDragKey.getState(next)).toBeNull();
+ });
+});
diff --git a/apps/web/src/components/editor/image-drag.ts b/apps/web/src/components/editor/image-drag.ts
new file mode 100644
index 00000000..1b44b16f
--- /dev/null
+++ b/apps/web/src/components/editor/image-drag.ts
@@ -0,0 +1,181 @@
+import { NodeSelection, Plugin, PluginKey, type EditorState } from "@tiptap/pm/state";
+import { closeHistory } from "@tiptap/pm/history";
+import type { EditorView } from "@tiptap/pm/view";
+import { IMAGE_GALLERY_NODE_TYPE } from "@edgeever/shared";
+import { imageSelectionKey } from "./image-selection";
+
+export const imageDragKey = new PluginKey<number | null>("imageDrag");
+
+/** Move the original node, preserving resource references and every attribute. */
+export function moveImage(state: EditorState, from: number, target: number) {
+ if (from < 0 || from >= state.doc.content.size) return null;
+ const image = state.doc.nodeAt(from);
+ if (image?.type.name !== "image" || target < 0 || target > state.doc.content.size) return null;
+ if (target >= from && target <= from + image.nodeSize) return null;
+
+ const $from = state.doc.resolve(from);
+ const tr = closeHistory(state.tr);
+ // Deleting a gallery's last child alone would cause schema filling to create
+ // an empty image. Remove its container in the same transaction instead.
+ if ($from.parent.type.name === IMAGE_GALLERY_NODE_TYPE && $from.parent.childCount === 1) {
+ tr.delete($from.before(), $from.after());
+ } else {
+ tr.delete(from, from + image.nodeSize);
+ }
+ const position = tr.mapping.map(target);
+ const $target = tr.doc.resolve(position);
+ if (!$target.parent.canReplaceWith($target.index(), $target.index(), image.type)) return null;
+ tr.insert(position, image);
+ tr.setSelection(NodeSelection.create(tr.doc, position));
+ return tr.setMeta(imageSelectionKey, null).setMeta(imageDragKey, null).scrollIntoView();
+}
+
+type DropTarget = { position: number; left: number; top: number; width: number; height: number };
+
+function imagePosition(view: EditorView, element: Element) {
+ const figure = element.closest(".edgeever-image-node");
+ if (!figure || !view.dom.contains(figure)) return null;
+ const position = view.posAtDOM(figure, 0);
+ return view.state.doc.nodeAt(position)?.type.name === "image" ? { figure, position } : null;
+}
+
+function dropTarget(view: EditorView, event: DragEvent): DropTarget | null {
+ const element = event.target instanceof Element ? event.target : null;
+ let hit = element && imagePosition(view, element);
+ // Grid gaps belong to the nearest image, rather than the gallery container.
+ const galleryElement = element?.closest("[data-edgeever-image-gallery]");
+ if (!hit && galleryElement && view.dom.contains(galleryElement)) {
+ let distance = Infinity;
+ for (const figure of galleryElement.querySelectorAll(".edgeever-image-node")) {
+ const rect = figure.getBoundingClientRect();
+ const dx = Math.max(rect.left - event.clientX, 0, event.clientX - rect.right);
+ const dy = Math.max(rect.top - event.clientY, 0, event.clientY - rect.bottom);
+ const candidateDistance = dx * dx + dy * dy;
+ if (candidateDistance < distance) {
+ distance = candidateDistance;
+ hit = imagePosition(view, figure);
+ }
+ }
+ }
+ if (hit) {
+ const rect = hit.figure.getBoundingClientRect();
+ const gallery = hit.figure.closest("[data-edgeever-image-gallery]");
+ // A one-column gallery uses top/bottom edges; a grid uses left/right edges.
+ const horizontal = gallery && Array.from(gallery.querySelectorAll(".edgeever-image-node")).some((sibling) => {
+ const other = sibling.getBoundingClientRect();
+ return Math.abs(other.left - rect.left) > 1 && other.top < rect.bottom && other.bottom > rect.top;
+ });
+ const after = horizontal ? event.clientX > rect.left + rect.width / 2 : event.clientY > rect.top + rect.height / 2;
+ return {
+ position: hit.position + (after ? 1 : 0),
+ left: horizontal ? (after ? rect.right : rect.left) : rect.left,
+ top: horizontal ? rect.top : (after ? rect.bottom : rect.top),
+ width: horizontal ? 3 : rect.width,
+ height: horizontal ? rect.height : 3,
+ };
+ }
+
+ const coords = view.posAtCoords({ left: event.clientX, top: event.clientY });
+ if (!coords) return null;
+ const $pos = view.state.doc.resolve(coords.pos);
+ const imageType = view.state.schema.nodes.image;
+ // Snap to block boundaries instead of splitting the paragraph under the mouse.
+ for (let depth = $pos.depth; depth > 0; depth -= 1) {
+ const before = $pos.before(depth);
+ const parent = view.state.doc.resolve(before);
+ if (!parent.parent.canReplaceWith(parent.index(), parent.index(), imageType)) continue;
+ const dom = view.nodeDOM(before);
+ if (!(dom instanceof HTMLElement)) continue;
+ const rect = dom.getBoundingClientRect();
+ const after = event.clientY > rect.top + rect.height / 2;
+ return { position: after ? $pos.after(depth) : before, left: rect.left, top: after ? rect.bottom : rect.top, width: rect.width, height: 3 };
+ }
+ if ($pos.parent.canReplaceWith($pos.index(), $pos.index(), imageType)) {
+ const rect = view.dom.getBoundingClientRect();
+ const caret = view.coordsAtPos(coords.pos);
+ return { position: coords.pos, left: rect.left, top: caret.top, width: rect.width, height: 3 };
+ }
+ return null;
+}
+
+export function createImageDragPlugin() {
+ let marker: HTMLDivElement | null = null;
+ const clearMarker = () => { marker?.remove(); marker = null; };
+ const reset = (view: EditorView) => {
+ clearMarker();
+ if (imageDragKey.getState(view.state) !== null) view.dispatch(view.state.tr.setMeta(imageDragKey, null));
+ };
+ return new Plugin<number | null>({
+ key: imageDragKey,
+ state: {
+ init: () => null,
+ apply(tr, previous) {
+ const requested = tr.getMeta(imageDragKey) as number | null | undefined;
+ if (requested !== undefined) return requested;
+ if (previous === null) return null;
+ const mapped = tr.mapping.mapResult(previous);
+ return mapped.deleted || tr.doc.nodeAt(mapped.pos)?.type.name !== "image" ? null : mapped.pos;
+ },
+ },
+ props: {
+ handleDOMEvents: {
+ dragstart(view, event) {
+ if (!view.editable || !(event.target instanceof Element)) return false;
+ const hit = imagePosition(view, event.target);
+ if (!hit || !event.target.closest("[data-drag-handle]")) return false;
+ view.dispatch(view.state.tr.setSelection(NodeSelection.create(view.state.doc, hit.position))
+ .setMeta(imageDragKey, hit.position).setMeta(imageSelectionKey, null));
+ return false; // Let ProseMirror serialize the node and start its internal drag.
+ },
+ dragover(view, event) {
+ const from = imageDragKey.getState(view.state);
+ if (!view.editable || from == null || !view.dragging) { clearMarker(); return false; }
+ const target = dropTarget(view, event);
+ if (!target || !moveImage(view.state, from, target.position)) { clearMarker(); return false; }
+ event.preventDefault();
+ if (!marker) {
+ marker = view.dom.ownerDocument.createElement("div");
+ marker.className = "edgeever-image-drop-indicator";
+ marker.setAttribute("aria-hidden", "true");
+ view.dom.ownerDocument.body.appendChild(marker);
+ }
+ Object.assign(marker.style, { left: `${target.left}px`, top: `${target.top}px`, width: `${target.width}px`, height: `${target.height}px` });
+ return true;
+ },
+ dragleave(view, event) {
+ if (!(event.relatedTarget instanceof globalThis.Node) || !view.dom.contains(event.relatedTarget)) clearMarker();
+ return false;
+ },
+ dragend(view) { reset(view); return false; },
+ drop() { clearMarker(); return false; },
+ },
+ handleDrop(view, event, _slice, moved) {
+ const from = imageDragKey.getState(view.state);
+ if (!view.editable || from == null || !view.dragging) return false;
+ if (!moved) { reset(view); return false; } // Preserve the editor's modifier-key copy gesture.
+ const target = dropTarget(view, event);
+ const transaction = target && moveImage(view.state, from, target.position);
+ if (transaction) {
+ view.dispatch(transaction);
+ // Keep the drag separate from subsequent typing in the undo history.
+ view.dispatch(closeHistory(view.state.tr));
+ view.focus();
+ } else reset(view);
+ return true; // Invalid/self drops must never fall through to insert a copy.
+ },
+ },
+ view(view) {
+ const clear = () => clearMarker();
+ view.dom.ownerDocument.addEventListener("drop", clear);
+ view.dom.ownerDocument.addEventListener("dragend", clear);
+ return {
+ update(next) { if (imageDragKey.getState(next.state) == null || !next.editable) clearMarker(); },
+ destroy() {
+ clearMarker();
+ view.dom.ownerDocument.removeEventListener("drop", clear);
+ view.dom.ownerDocument.removeEventListener("dragend", clear);
+ },
+ };
+ },
+ });
+}
diff --git a/apps/web/src/styles/globals.css b/apps/web/src/styles/globals.css
index 6de59f84..d2481080 100644
--- a/apps/web/src/styles/globals.css
+++ b/apps/web/src/styles/globals.css
@@ -2136,6 +2136,22 @@ html[data-edgeever-extension-theme] .edgeever-memo-divider {
margin: 0;
}
+.ProseMirror .edgeever-image-node img[draggable="true"] {
+ cursor: grab;
+}
+
+.ProseMirror .edgeever-image-node img[draggable="true"]:active {
+ cursor: grabbing;
+}
+
+.edgeever-image-drop-indicator {
+ position: fixed;
+ z-index: 100;
+ pointer-events: none;
+ background: hsl(var(--foreground));
+ border-radius: 2px;
+}
+
.ProseMirror .edgeever-image-node.is-selected img {
outline: 2px solid rgb(var(--slate-500-rgb) / 0.6);
outline-offset: 3px;