@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/view/selection.js

@@ -0,0 +1,198 @@
+import { NodeSelection, Selection, TextSelection } from "../state/selection.js";
+import { chrome, chrome_version, gecko, ie, ie_version, safari } from "./browser.js";
+import { domIndex, isElt, isEquivalentPosition, isOnEdge, selectionCollapsed } from "./dom.js";
+import * as Option from "effect/Option";
+// src/view/selection.ts
+/**
+* Syncing between the editor selection and the DOM selection.
+*
+* @internal
+*/
+const geckoKeySelection = (view, domSel, head, nearestDesc, byKey) => gecko && byKey ? Option.getOrUndefined(Option.map(nearestDesc, (desc) => skippedScrollWrapper(view, domSel, head, desc))) : void 0;
+function skippedScrollWrapper(view, domSel, head, nearestDesc) {
+	const to = view.state.selection.to;
+	if (head <= to || nearestDesc.posAtStart <= to) return void 0;
+	if (!focusAtElementEnd(domSel) || !inScrollableWrapper(domSel.focusNode, nearestDesc.dom)) return void 0;
+	return Option.getOrUndefined(Selection.findFrom(view.state.doc.resolveUnsafe(nearestDesc.posAtStart), 1));
+}
+const focusAtElementEnd = ({ focusNode, focusOffset }) => !!focusNode && isElt(focusNode) && focusOffset == focusNode.childNodes.length;
+const isScrollable = (node) => isElt(node) && getComputedStyle(node).overflow != "visible";
+const climb = (scan, stop) => {
+	const parent = scan.parentNode;
+	return scan == stop || scan.nextSibling || !parent || !isElt(parent) ? Option.none() : Option.some(parent);
+};
+const inScrollableWrapper = (scan, stop) => isScrollable(scan) || Option.match(climb(scan, stop), {
+	onNone: () => false,
+	onSome: (up) => inScrollableWrapper(up, stop)
+});
+/** @internal */
+function selectionFromDOM(view, origin = null) {
+	const domSel = view.domSelectionRange(), doc = view.state.doc;
+	if (!domSel.focusNode) return null;
+	let nearestDesc = view.docView.nearestDesc(domSel.focusNode);
+	const inWidget = nearestDesc && nearestDesc.size == 0;
+	let head = view.docView.posFromDOM(domSel.focusNode, domSel.focusOffset, 1);
+	if (head < 0) return null;
+	let $head = doc.resolveUnsafe(head), anchor, selection;
+	if (selectionCollapsed(domSel)) {
+		anchor = head;
+		while (nearestDesc && !nearestDesc.node) nearestDesc = nearestDesc.parent;
+		const nearestDescNode = nearestDesc?.node;
+		if (nearestDesc && nearestDescNode.isAtom && NodeSelection.isSelectable(nearestDescNode) && nearestDesc.parent && !(nearestDescNode.isInline && isOnEdge(domSel.focusNode, domSel.focusOffset, nearestDesc.dom))) {
+			const pos = nearestDesc.posBefore;
+			selection = new NodeSelection(head == pos ? $head : doc.resolveUnsafe(pos));
+		} else selection = geckoKeySelection(view, domSel, head, Option.fromNullishOr(nearestDesc), origin == "key");
+	} else {
+		if (domSel instanceof view.dom.ownerDocument.defaultView.Selection && domSel.rangeCount > 1) {
+			let min = head, max = head;
+			for (let i = 0; i < domSel.rangeCount; i++) {
+				const range = domSel.getRangeAt(i);
+				min = Math.min(min, view.docView.posFromDOM(range.startContainer, range.startOffset, 1));
+				max = Math.max(max, view.docView.posFromDOM(range.endContainer, range.endOffset, -1));
+			}
+			if (min < 0) return null;
+			[anchor, head] = max == view.state.selection.anchor ? [max, min] : [min, max];
+			$head = doc.resolveUnsafe(head);
+		} else anchor = view.docView.posFromDOM(domSel.anchorNode, domSel.anchorOffset, 1);
+		if (anchor < 0) return null;
+	}
+	const $anchor = doc.resolveUnsafe(anchor);
+	if (!selection) {
+		const bias = origin == "pointer" || view.state.selection.head < $head.pos && !inWidget ? 1 : -1;
+		selection = selectionBetween(view, $anchor, $head, bias);
+	}
+	return selection;
+}
+function editorOwnsSelection(view) {
+	return view.editable ? view.hasFocus() : hasSelection(view) && document.activeElement && document.activeElement.contains(view.dom);
+}
+/** @internal */
+function selectionToDOM(view, force = false) {
+	const sel = view.state.selection;
+	syncNodeSelection(view, sel);
+	if (!editorOwnsSelection(view)) return;
+	const mouseDown = view.input.mouseDown;
+	if (!force && chrome && mouseDown) {
+		const domSel = view.domSelectionRange(), curSel = view.domObserver.currentSelection;
+		if (domSel.anchorNode && curSel.anchorNode && isEquivalentPosition(domSel.anchorNode, domSel.anchorOffset, curSel.anchorNode, curSel.anchorOffset) && mouseDown.delaySelUpdate()) {
+			view.domObserver.setCurSelection();
+			return;
+		}
+	}
+	view.domObserver.disconnectSelection();
+	if (view.cursorWrapper) selectCursorWrapper(view);
+	else {
+		const { anchor, head } = sel;
+		let resetEditableFrom, resetEditableTo;
+		if (brokenSelectBetweenUneditable && !(sel instanceof TextSelection)) {
+			if (!sel.$from.parent.inlineContent) resetEditableFrom = temporarilyEditableNear(view, sel.from);
+			if (!sel.empty && !sel.$from.parent.inlineContent) resetEditableTo = temporarilyEditableNear(view, sel.to);
+		}
+		view.docView.setSelection(anchor, head, view, force);
+		if (brokenSelectBetweenUneditable) {
+			if (resetEditableFrom) resetEditable(resetEditableFrom);
+			if (resetEditableTo) resetEditable(resetEditableTo);
+		}
+		if (sel.visible) view.dom.classList.remove("ProseMirror-hideselection");
+		else {
+			view.dom.classList.add("ProseMirror-hideselection");
+			if ("onselectionchange" in document) removeClassOnSelectionChange(view);
+		}
+	}
+	view.domObserver.setCurSelection();
+	view.domObserver.connectSelection();
+}
+const brokenSelectBetweenUneditable = safari || chrome && chrome_version < 63;
+function temporarilyEditableNear(view, pos) {
+	const { node, offset } = view.docView.domFromPos(pos, 0);
+	const after = offset < node.childNodes.length ? node.childNodes[offset] : null;
+	const before = offset ? node.childNodes[offset - 1] : null;
+	if (safari && after && after.contentEditable == "false") return setEditable(after);
+	if ((!after || after.contentEditable == "false") && (!before || before.contentEditable == "false")) {
+		if (after) return setEditable(after);
+		else if (before) return setEditable(before);
+	}
+}
+function setEditable(element) {
+	element.contentEditable = "true";
+	if (safari && element.draggable) {
+		element.draggable = false;
+		element.wasDraggable = true;
+	}
+	return element;
+}
+function resetEditable(element) {
+	element.contentEditable = "false";
+	if (element.wasDraggable) {
+		element.draggable = true;
+		element.wasDraggable = null;
+	}
+}
+function removeClassOnSelectionChange(view) {
+	const doc = view.dom.ownerDocument;
+	doc.removeEventListener("selectionchange", view.input.hideSelectionGuard);
+	const domSel = view.domSelectionRange();
+	const node = domSel.anchorNode, offset = domSel.anchorOffset;
+	doc.addEventListener("selectionchange", view.input.hideSelectionGuard = () => {
+		if (domSel.anchorNode != node || domSel.anchorOffset != offset) {
+			doc.removeEventListener("selectionchange", view.input.hideSelectionGuard);
+			setTimeout(() => {
+				if (!editorOwnsSelection(view) || view.state.selection.visible) view.dom.classList.remove("ProseMirror-hideselection");
+			}, 20);
+		}
+	});
+}
+function selectCursorWrapper(view) {
+	const domSel = view.domSelection();
+	if (!domSel) return;
+	const node = view.cursorWrapper.dom, img = node.nodeName == "IMG";
+	if (img) domSel.collapse(node.parentNode, domIndex(node) + 1);
+	else domSel.collapse(node, 0);
+	if (!img && !view.state.selection.visible && ie && ie_version <= 11) {
+		node.disabled = true;
+		node.disabled = false;
+	}
+}
+/** @internal */
+function syncNodeSelection(view, sel) {
+	if (sel instanceof NodeSelection) {
+		const desc = view.docView.descAt(sel.from);
+		if (desc != view.lastSelectedViewDesc) {
+			clearNodeSelection(view);
+			if (desc) desc.selectNode();
+			view.lastSelectedViewDesc = desc;
+		}
+	} else clearNodeSelection(view);
+}
+function clearNodeSelection(view) {
+	if (view.lastSelectedViewDesc) {
+		if (view.lastSelectedViewDesc.parent) view.lastSelectedViewDesc.deselectNode();
+		view.lastSelectedViewDesc = void 0;
+	}
+}
+/** @internal */
+function selectionBetween(view, $anchor, $head, bias) {
+	return view.someProp("createSelectionBetween", (f) => f(view, $anchor, $head)) || TextSelection.between($anchor, $head, bias);
+}
+/** @internal */
+function hasFocusAndSelection(view) {
+	if (view.editable && !view.hasFocus()) return false;
+	return hasSelection(view);
+}
+/** @internal */
+function hasSelection(view) {
+	const sel = view.domSelectionRange();
+	if (!sel.anchorNode) return false;
+	try {
+		return view.dom.contains(sel.anchorNode.nodeType == 3 ? sel.anchorNode.parentNode : sel.anchorNode) && (view.editable || view.dom.contains(sel.focusNode.nodeType == 3 ? sel.focusNode.parentNode : sel.focusNode));
+	} catch {
+		return false;
+	}
+}
+/** @internal */
+function anchorInRightPlace(view) {
+	const anchorDOM = view.docView.domFromPos(view.state.selection.anchor, 0);
+	const domSel = view.domSelectionRange();
+	return isEquivalentPosition(anchorDOM.node, anchorDOM.offset, domSel.anchorNode, domSel.anchorOffset);
+}
+export { anchorInRightPlace, hasFocusAndSelection, hasSelection, selectionBetween, selectionFromDOM, selectionToDOM, syncNodeSelection };