@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/view/decoration.js

@@ -0,0 +1,566 @@
+import * as Arr from "effect/Array";
+// src/view/decoration.ts
+/**
+* Decorations: widgets, inline and node decorations, and decoration sets.
+*
+* @since 0.1.0
+*/
+function compareObjs(a, b) {
+	if (a == b) return true;
+	for (const p in a) if (a[p] !== b[p]) return false;
+	for (const p in b) if (!(p in a)) return false;
+	return true;
+}
+var FragmentCursor = class {
+	constructor(frag) {
+		this.frag = frag;
+		this.index = 0;
+		this.off = 0;
+	}
+	spansNode(from, to) {
+		const children = this.frag.content;
+		while (this.off <= from && this.index < children.length) {
+			const next = children[this.index];
+			if (!next) break;
+			if (this.off == from) return !next.isText && from + next.nodeSize == to;
+			this.off += next.nodeSize;
+			this.index++;
+		}
+		return false;
+	}
+};
+/** @internal */
+var WidgetType = class WidgetType {
+	constructor(toDOM, spec) {
+		this.toDOM = toDOM;
+		this.spec = spec || noSpec;
+		this.side = this.spec.side || 0;
+	}
+	map(mapping, span, offset, oldOffset) {
+		const { deleted, pos } = mapping.mapResult(span.from + oldOffset, this.side < 0 ? -1 : 1);
+		return deleted ? null : new Decoration(pos - offset, pos - offset, this);
+	}
+	valid() {
+		return true;
+	}
+	eq(other) {
+		return this == other || other instanceof WidgetType && (this.spec.key && this.spec.key == other.spec.key || this.toDOM == other.toDOM && compareObjs(this.spec, other.spec));
+	}
+	destroy(node) {
+		if (this.spec.destroy) this.spec.destroy(node);
+	}
+};
+/** @internal */
+var InlineType = class InlineType {
+	constructor(attrs, spec) {
+		this.attrs = attrs;
+		this.spec = spec || noSpec;
+	}
+	map(mapping, span, offset, oldOffset) {
+		const from = mapping.map(span.from + oldOffset, this.spec.inclusiveStart ? -1 : 1) - offset;
+		const to = mapping.map(span.to + oldOffset, this.spec.inclusiveEnd ? 1 : -1) - offset;
+		return from >= to ? null : new Decoration(from, to, this);
+	}
+	valid(_, span) {
+		return span.from < span.to;
+	}
+	eq(other) {
+		return this == other || other instanceof InlineType && compareObjs(this.attrs, other.attrs) && compareObjs(this.spec, other.spec);
+	}
+	static is(span) {
+		return span.type instanceof InlineType;
+	}
+	destroy() {}
+};
+/** @internal */
+var NodeType = class NodeType {
+	constructor(attrs, spec) {
+		this.attrs = attrs;
+		this.spec = spec || noSpec;
+	}
+	map(mapping, span, offset, oldOffset) {
+		const from = mapping.mapResult(span.from + oldOffset, 1);
+		if (from.deleted) return null;
+		const to = mapping.mapResult(span.to + oldOffset, -1);
+		if (to.deleted || to.pos <= from.pos) return null;
+		return new Decoration(from.pos - offset, to.pos - offset, this);
+	}
+	valid(_node, span, cursor) {
+		return cursor.spansNode(span.from, span.to);
+	}
+	eq(other) {
+		return this == other || other instanceof NodeType && compareObjs(this.attrs, other.attrs) && compareObjs(this.spec, other.spec);
+	}
+	destroy() {}
+};
+/**
+* Decoration objects can be provided to the view through the
+* `decorations` prop. They come in several variants—see the static
+* members of this class for details.
+*
+* @since 0.1.0
+* @category models
+*/
+var Decoration = class Decoration {
+	/** @internal */
+	constructor(from, to, type) {
+		this.from = from;
+		this.to = to;
+		this.type = type;
+	}
+	/** @internal */
+	copy(from, to) {
+		return new Decoration(from, to, this.type);
+	}
+	/** @internal */
+	eq(other, offset = 0) {
+		return this.type.eq(other.type) && this.from + offset == other.from && this.to + offset == other.to;
+	}
+	/** @internal */
+	map(mapping, offset, oldOffset) {
+		return this.type.map(mapping, this, offset, oldOffset);
+	}
+	/**
+	* Creates a widget decoration, which is a DOM node that's shown in
+	* the document at the given position. It is recommended that you
+	* delay rendering the widget by passing a function that will be
+	* called when the widget is actually drawn in a view, but you can
+	* also directly pass a DOM node. `getPos` can be used to find the
+	* widget's current document position.
+	*/
+	static widget(pos, toDOM, spec) {
+		return new Decoration(pos, pos, new WidgetType(toDOM, spec));
+	}
+	/**
+	* Creates an inline decoration, which adds the given attributes to
+	* each inline node between `from` and `to`.
+	*/
+	static inline(from, to, attrs, spec) {
+		return new Decoration(from, to, new InlineType(attrs, spec));
+	}
+	/**
+	* Creates a node decoration. `from` and `to` should point precisely
+	* before and after a node in the document. That node, and only that
+	* node, will receive the given attributes.
+	*/
+	static node(from, to, attrs, spec) {
+		return new Decoration(from, to, new NodeType(attrs, spec));
+	}
+	/**
+	* The spec provided when creating this decoration. Can be useful if
+	* you've stored extra information in that object.
+	*/
+	get spec() {
+		return this.type.spec;
+	}
+	/** @internal */
+	get inline() {
+		return this.type instanceof InlineType;
+	}
+	/** @internal */
+	get widget() {
+		return this.type instanceof WidgetType;
+	}
+};
+const none = [];
+const noSpec = {};
+/**
+* A collection of decorations, organized in such a way that the
+* drawing algorithm can efficiently use and compare them. This is a
+* persistent data structure—it is not modified, updates create a new
+* value.
+*
+* @since 0.1.0
+* @category models
+*/
+var DecorationSet = class DecorationSet {
+	/** @internal */
+	constructor(local, children) {
+		this.local = local.length ? local : none;
+		this.children = children.length ? children : none;
+	}
+	/**
+	* Create a set of decorations, using the structure of the given
+	* document. This will consume (modify) the `decorations` array, so you
+	* must make a copy if you want need to preserve that.
+	*/
+	static create(doc, decorations) {
+		return decorations.length ? buildTree(decorations, doc, 0, noSpec) : empty;
+	}
+	/**
+	* Find all decorations in this set which touch the given range
+	* (including decorations that start or end directly at the
+	* boundaries) and match the given predicate on their spec. When
+	* `start` and `end` are omitted, all decorations in the set are
+	* considered. When `predicate` isn't given, all decorations are
+	* assumed to match.
+	*/
+	find(start, end, predicate) {
+		const result = [];
+		this.findInner(start == null ? 0 : start, end == null ? 1e9 : end, result, 0, predicate);
+		return result;
+	}
+	findInner(start, end, result, offset, predicate) {
+		for (let i = 0; i < this.local.length; i++) {
+			const span = this.local[i];
+			if (span.from <= end && span.to >= start && (!predicate || predicate(span.spec))) result.push(span.copy(span.from + offset, span.to + offset));
+		}
+		for (let i = 0; i < this.children.length; i += 3) if (this.children[i] < end && this.children[i + 1] > start) {
+			const childOff = this.children[i] + 1;
+			this.children[i + 2].findInner(start - childOff, end - childOff, result, offset + childOff, predicate);
+		}
+	}
+	/** Map the set of decorations in response to a change in the document. */
+	map(mapping, doc, options) {
+		if (this == empty || Arr.isReadonlyArrayEmpty(mapping.maps)) return this;
+		return this.mapInner(mapping, doc, 0, 0, options || noSpec);
+	}
+	/** @internal */
+	mapInner(mapping, node, offset, oldOffset, options) {
+		let newLocal;
+		if (this.local.length) {
+			const cur = new FragmentCursor(node.content);
+			for (let i = 0; i < this.local.length; i++) {
+				const mapped = this.local[i].map(mapping, offset, oldOffset);
+				if (mapped && mapped.type.valid(node, mapped, cur)) (newLocal || (newLocal = [])).push(mapped);
+				else if (options.onRemove) options.onRemove(this.local[i].spec);
+			}
+		}
+		if (this.children.length) return mapChildren(this.children, newLocal || [], mapping, node, offset, oldOffset, options);
+		else return newLocal ? new DecorationSet(Arr.sort(newLocal, byPos), none) : empty;
+	}
+	/**
+	* Add the given array of decorations to the ones in the set, producing
+	* a new set. Consumes the `decorations` array. Needs access to the
+	* current document to create the appropriate tree structure.
+	*/
+	add(doc, decorations) {
+		if (!decorations.length) return this;
+		if (this == empty) return DecorationSet.create(doc, decorations);
+		return this.addInner(doc, decorations, 0);
+	}
+	addInner(doc, decorations, offset) {
+		let children, childIndex = 0;
+		doc.forEach((childNode, childOffset) => {
+			const baseOffset = childOffset + offset;
+			let found;
+			if (!(found = takeSpansForNode(decorations, childNode, baseOffset))) return;
+			if (!children) children = this.children.slice();
+			while (childIndex < children.length && children[childIndex] < childOffset) childIndex += 3;
+			if (children[childIndex] == childOffset) children[childIndex + 2] = children[childIndex + 2].addInner(childNode, found, baseOffset + 1);
+			else children.splice(childIndex, 0, childOffset, childOffset + childNode.nodeSize, buildTree(found, childNode, baseOffset + 1, noSpec));
+			childIndex += 3;
+		});
+		const local = moveSpans(childIndex ? withoutNulls(decorations) : decorations, -offset);
+		if (local.length) {
+			const cur = new FragmentCursor(doc.content);
+			for (let i = 0; i < local.length; i++) if (!local[i].type.valid(doc, local[i], cur)) local.splice(i--, 1);
+		}
+		return new DecorationSet(local.length ? Arr.sort(this.local.concat(local), byPos) : this.local, children || this.children);
+	}
+	/**
+	* Create a new set that contains the decorations in this set, minus
+	* the ones in the given array.
+	*/
+	remove(decorations) {
+		if (Arr.isReadonlyArrayEmpty(decorations) || this == empty) return this;
+		return this.removeInner(decorations, 0);
+	}
+	removeInner(decorations, offset) {
+		let children = this.children, local = this.local;
+		for (let i = 0; i < children.length; i += 3) {
+			let found;
+			const from = children[i] + offset, to = children[i + 1] + offset;
+			for (let j = 0, span; j < decorations.length; j++) if (span = decorations[j]) {
+				if (span.from > from && span.to < to) {
+					decorations[j] = null;
+					(found || (found = [])).push(span);
+				}
+			}
+			if (!found) continue;
+			if (children == this.children) children = this.children.slice();
+			const removed = children[i + 2].removeInner(found, from + 1);
+			if (removed != empty) children[i + 2] = removed;
+			else {
+				children.splice(i, 3);
+				i -= 3;
+			}
+		}
+		if (local.length) {
+			for (let i = 0, span; i < decorations.length; i++) if (span = decorations[i]) {
+				for (let j = 0; j < local.length; j++) if (local[j].eq(span, offset)) {
+					if (local == this.local) local = this.local.slice();
+					local.splice(j--, 1);
+				}
+			}
+		}
+		if (children == this.children && local == this.local) return this;
+		return local.length || children.length ? new DecorationSet(local, children) : empty;
+	}
+	forChild(offset, node) {
+		if (this == empty) return this;
+		if (node.isLeaf) return DecorationSet.empty;
+		let child, local;
+		for (let i = 0; i < this.children.length; i += 3) if (this.children[i] >= offset) {
+			if (this.children[i] == offset) child = this.children[i + 2];
+			break;
+		}
+		const start = offset + 1, end = start + node.content.size;
+		for (let i = 0; i < this.local.length; i++) {
+			const dec = this.local[i];
+			if (dec.from < end && dec.to > start && dec.type instanceof InlineType) {
+				const from = Math.max(start, dec.from) - start, to = Math.min(end, dec.to) - start;
+				if (from < to) (local || (local = [])).push(dec.copy(from, to));
+			}
+		}
+		if (local) {
+			const localSet = new DecorationSet(Arr.sort(local, byPos), none);
+			return child ? new DecorationGroup([localSet, child]) : localSet;
+		}
+		return child || empty;
+	}
+	/** @internal */
+	eq(other) {
+		if (this == other) return true;
+		if (!(other instanceof DecorationSet) || this.local.length != other.local.length || this.children.length != other.children.length) return false;
+		for (let i = 0; i < this.local.length; i++) if (!this.local[i].eq(other.local[i])) return false;
+		for (let i = 0; i < this.children.length; i += 3) if (this.children[i] != other.children[i] || this.children[i + 1] != other.children[i + 1] || !this.children[i + 2].eq(other.children[i + 2])) return false;
+		return true;
+	}
+	/** @internal */
+	locals(node) {
+		return removeOverlap(this.localsInner(node));
+	}
+	/** @internal */
+	localsInner(node) {
+		if (this == empty) return none;
+		if (node.inlineContent || !this.local.some(InlineType.is)) return this.local;
+		const result = [];
+		for (let i = 0; i < this.local.length; i++) if (!(this.local[i].type instanceof InlineType)) result.push(this.local[i]);
+		return result;
+	}
+	static {
+		this.empty = new DecorationSet([], []);
+	}
+	static {
+		this.removeOverlap = removeOverlap;
+	}
+	forEachSet(f) {
+		f(this);
+	}
+};
+const empty = DecorationSet.empty;
+/** @internal */
+var DecorationGroup = class DecorationGroup {
+	constructor(members) {
+		this.members = members;
+	}
+	map(mapping, doc) {
+		const mappedDecos = this.members.map((member) => member.map(mapping, doc, noSpec));
+		return DecorationGroup.from(mappedDecos);
+	}
+	forChild(offset, child) {
+		if (child.isLeaf) return DecorationSet.empty;
+		let found = [];
+		for (let i = 0; i < this.members.length; i++) {
+			const result = this.members[i].forChild(offset, child);
+			if (result == empty) continue;
+			if (result instanceof DecorationGroup) found = found.concat(result.members);
+			else found.push(result);
+		}
+		return DecorationGroup.from(found);
+	}
+	eq(other) {
+		if (!(other instanceof DecorationGroup) || other.members.length != this.members.length) return false;
+		for (let i = 0; i < this.members.length; i++) if (!this.members[i].eq(other.members[i])) return false;
+		return true;
+	}
+	locals(node) {
+		let result, sorted = true;
+		for (let i = 0; i < this.members.length; i++) {
+			const locals = this.members[i].localsInner(node);
+			if (!locals.length) continue;
+			if (!result) result = locals;
+			else {
+				if (sorted) {
+					result = result.slice();
+					sorted = false;
+				}
+				for (let j = 0; j < locals.length; j++) result.push(locals[j]);
+			}
+		}
+		return result ? removeOverlap(sorted ? result : Arr.sort(result, byPos)) : none;
+	}
+	static from(members) {
+		if (Arr.isReadonlyArrayEmpty(members)) return empty;
+		if (members.length == 1) return members[0];
+		return new DecorationGroup(members.every((m) => m instanceof DecorationSet) ? members : members.reduce((r, m) => r.concat(m instanceof DecorationSet ? m : m.members), []));
+	}
+	forEachSet(f) {
+		for (let i = 0; i < this.members.length; i++) this.members[i].forEachSet(f);
+	}
+};
+function mapChildren(oldChildren, newLocal, mapping, node, offset, oldOffset, options) {
+	const children = oldChildren.slice();
+	for (let i = 0, baseOffset = oldOffset; i < mapping.maps.length; i++) {
+		let moved = 0;
+		mapping.maps[i].forEach((oldStart, oldEnd, newStart, newEnd) => {
+			const dSize = newEnd - newStart - (oldEnd - oldStart);
+			for (let i = 0; i < children.length; i += 3) {
+				const end = children[i + 1];
+				if (end < 0 || oldStart > end + baseOffset - moved) continue;
+				const start = children[i] + baseOffset - moved;
+				if (oldEnd >= start) children[i + 1] = oldStart <= start ? -2 : -1;
+				else if (oldStart >= baseOffset && dSize) {
+					children[i] += dSize;
+					children[i + 1] += dSize;
+				}
+			}
+			moved += dSize;
+		});
+		baseOffset = mapping.maps[i].map(baseOffset, -1);
+	}
+	let mustRebuild = false;
+	for (let i = 0; i < children.length; i += 3) if (children[i + 1] < 0) {
+		if (children[i + 1] == -2) {
+			mustRebuild = true;
+			children[i + 1] = -1;
+			continue;
+		}
+		const from = mapping.map(oldChildren[i] + oldOffset), fromLocal = from - offset;
+		if (fromLocal < 0 || fromLocal >= node.content.size) {
+			mustRebuild = true;
+			continue;
+		}
+		const toLocal = mapping.map(oldChildren[i + 1] + oldOffset, -1) - offset;
+		const { index, offset: childOffset } = node.content.findIndex(fromLocal);
+		const childNode = node.content.content[index];
+		if (childNode && childOffset == fromLocal && childOffset + childNode.nodeSize == toLocal) {
+			const mapped = children[i + 2].mapInner(mapping, childNode, from + 1, oldChildren[i] + oldOffset + 1, options);
+			if (mapped != empty) {
+				children[i] = fromLocal;
+				children[i + 1] = toLocal;
+				children[i + 2] = mapped;
+			} else {
+				children[i + 1] = -2;
+				mustRebuild = true;
+			}
+		} else mustRebuild = true;
+	}
+	if (mustRebuild) {
+		const built = buildTree(mapAndGatherRemainingDecorations(children, oldChildren, newLocal, mapping, offset, oldOffset, options), node, 0, options);
+		newLocal = built.local;
+		for (let i = 0; i < children.length; i += 3) if (children[i + 1] < 0) {
+			children.splice(i, 3);
+			i -= 3;
+		}
+		for (let i = 0, j = 0; i < built.children.length; i += 3) {
+			const from = built.children[i];
+			while (j < children.length && children[j] < from) j += 3;
+			children.splice(j, 0, built.children[i], built.children[i + 1], built.children[i + 2]);
+		}
+	}
+	return new DecorationSet(Arr.sort(newLocal, byPos), children);
+}
+function moveSpans(spans, offset) {
+	if (!offset || !spans.length) return spans;
+	const result = [];
+	for (let i = 0; i < spans.length; i++) {
+		const span = spans[i];
+		result.push(new Decoration(span.from + offset, span.to + offset, span.type));
+	}
+	return result;
+}
+function mapAndGatherRemainingDecorations(children, oldChildren, decorations, mapping, offset, oldOffset, options) {
+	function gather(set, oldOffset) {
+		for (let i = 0; i < set.local.length; i++) {
+			const mapped = set.local[i].map(mapping, offset, oldOffset);
+			if (mapped) decorations.push(mapped);
+			else if (options.onRemove) options.onRemove(set.local[i].spec);
+		}
+		for (let i = 0; i < set.children.length; i += 3) gather(set.children[i + 2], set.children[i] + oldOffset + 1);
+	}
+	for (let i = 0; i < children.length; i += 3) if (children[i + 1] == -1) gather(children[i + 2], oldChildren[i] + oldOffset + 1);
+	return decorations;
+}
+function takeSpansForNode(spans, node, offset) {
+	if (node.isLeaf) return null;
+	const end = offset + node.nodeSize;
+	let found = null;
+	for (let i = 0, span; i < spans.length; i++) if ((span = spans[i]) && span.from > offset && span.to < end) {
+		(found || (found = [])).push(span);
+		spans[i] = null;
+	}
+	return found;
+}
+function withoutNulls(array) {
+	const result = [];
+	for (let i = 0; i < array.length; i++) if (array[i] != null) result.push(array[i]);
+	return result;
+}
+function buildTree(spans, node, offset, options) {
+	const children = [];
+	let hasNulls = false;
+	node.forEach((childNode, localStart) => {
+		const found = takeSpansForNode(spans, childNode, localStart + offset);
+		if (found) {
+			hasNulls = true;
+			const subtree = buildTree(found, childNode, offset + localStart + 1, options);
+			if (subtree != empty) children.push(localStart, localStart + childNode.nodeSize, subtree);
+		}
+	});
+	const locals = Arr.sort(moveSpans(hasNulls ? withoutNulls(spans) : spans, -offset), byPos);
+	if (locals.length) {
+		const cur = new FragmentCursor(node.content);
+		for (let i = 0; i < locals.length; i++) if (!locals[i].type.valid(node, locals[i], cur)) {
+			if (options.onRemove) options.onRemove(locals[i].spec);
+			locals.splice(i--, 1);
+		}
+	}
+	return locals.length || children.length ? new DecorationSet(locals, children) : empty;
+}
+const byPos = (a, b) => a.from < b.from ? -1 : a.from > b.from ? 1 : a.to < b.to ? -1 : a.to > b.to ? 1 : 0;
+function removeOverlap(spans) {
+	let working = spans;
+	for (let i = 0; i < working.length - 1; i++) {
+		const span = working[i];
+		if (span.from != span.to) for (let j = i + 1; j < working.length; j++) {
+			const next = working[j];
+			if (next.from == span.from) {
+				if (next.to != span.to) {
+					if (working == spans) working = spans.slice();
+					working[j] = next.copy(next.from, span.to);
+					insertAhead(working, j + 1, next.copy(span.to, next.to));
+				}
+				continue;
+			} else {
+				if (next.from < span.to) {
+					if (working == spans) working = spans.slice();
+					working[i] = span.copy(span.from, next.from);
+					insertAhead(working, j, span.copy(next.from, span.to));
+				}
+				break;
+			}
+		}
+	}
+	return working;
+}
+function insertAhead(array, i, deco) {
+	while (i < array.length && byPos(deco, array[i]) > 0) i++;
+	array.splice(i, 0, deco);
+}
+/**
+* Get the decorations associated with the current props of a view.
+*
+* @internal
+*/
+function viewDecorations(view) {
+	const found = [];
+	view.someProp("decorations", (f) => {
+		const result = f(view.state);
+		if (result && result != empty) found.push(result);
+	});
+	if (view.cursorWrapper) found.push(DecorationSet.create(view.state.doc, [view.cursorWrapper.deco]));
+	return DecorationGroup.from(found);
+}
+export { Decoration, DecorationGroup, DecorationSet, InlineType, NodeType, WidgetType, viewDecorations };

package/dist/view/dom.d.ts

@@ -0,0 +1,18 @@
+import { ViewDesc } from "./viewdesc.js";
+declare global {
+  interface Node {
+    /** @internal */
+    pmViewDesc?: ViewDesc | undefined;
+  }
+}
+/** @internal */
+export type DOMNode = globalThis.Node;
+/** @internal */
+export type DOMSelection = globalThis.Selection;
+/** @internal */
+export type DOMSelectionRange = {
+  focusNode: DOMNode | null;
+  focusOffset: number;
+  anchorNode: DOMNode | null;
+  anchorOffset: number;
+};