@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/model/resolvedpos.js

@@ -0,0 +1,305 @@
+import { attempt } from "../internal/attempt.js";
+import { PositionError } from "./errors.js";
+import { Mark } from "./mark.js";
+import * as Option from "effect/Option";
+// src/model/resolvedpos.ts
+const isPositionError = (u) => u instanceof PositionError;
+/**
+* You can resolve a position to get more information about it. Objects
+* of this class represent such a resolved position, providing various
+* pieces of context information, and some helper methods.
+*
+* Throughout this interface, methods that take an optional `depth`
+* parameter will interpret `undefined` as `this.depth` and negative
+* numbers as `this.depth + value`.
+*
+* @since 0.1.0
+* @category models
+*/
+var ResolvedPos = class ResolvedPos {
+	/** @internal */
+	constructor(pos, path, parentOffset) {
+		this.pos = pos;
+		this.path = path;
+		this.parentOffset = parentOffset;
+		this.depth = path.length / 3 - 1;
+	}
+	/** @internal */
+	resolveDepth(val) {
+		if (val == null) return this.depth;
+		if (val < 0) return this.depth + val;
+		return val;
+	}
+	/**
+	* The parent node that the position points into. Note that even if a
+	* position points into a text node, that node is not considered the
+	* parent—text nodes are ‘flat’ in this model, and have no content.
+	*/
+	get parent() {
+		return this.node(this.depth);
+	}
+	/** The root node in which the position was resolved. */
+	get doc() {
+		return this.node(0);
+	}
+	/** The ancestor node at the given level. `p.node(p.depth)` is the same as `p.parent`. */
+	node(depth) {
+		return this.path[this.resolveDepth(depth) * 3];
+	}
+	/**
+	* The index into the ancestor at the given level. If this points at
+	* the 3rd node in the 2nd paragraph on the top level, for example,
+	* `p.index(0)` is 1 and `p.index(1)` is 2.
+	*/
+	index(depth) {
+		return this.path[this.resolveDepth(depth) * 3 + 1];
+	}
+	/** The index pointing after this position into the ancestor at the given level. */
+	indexAfter(depth) {
+		depth = this.resolveDepth(depth);
+		return this.index(depth) + (depth === this.depth && !this.textOffset ? 0 : 1);
+	}
+	/** The (absolute) position at the start of the node at the given level. */
+	start(depth) {
+		depth = this.resolveDepth(depth);
+		return depth === 0 ? 0 : this.path[depth * 3 - 1] + 1;
+	}
+	/** The (absolute) position at the end of the node at the given level. */
+	end(depth) {
+		depth = this.resolveDepth(depth);
+		return this.start(depth) + this.node(depth).content.size;
+	}
+	/**
+	* The (absolute) position directly before the wrapping node at the
+	* given level, or, when `depth` is `this.depth + 1`, the original
+	* position. Fails for depth 0, since there is no position before the
+	* top-level node.
+	*/
+	before(depth) {
+		return attempt(() => this.beforeUnsafe(depth), isPositionError);
+	}
+	/** Like `before`, but throws a `PositionError` for depth 0. */
+	beforeUnsafe(depth) {
+		depth = this.resolveDepth(depth);
+		if (!depth) throw new PositionError({ message: "There is no position before the top-level node" });
+		return depth === this.depth + 1 ? this.pos : this.path[depth * 3 - 1];
+	}
+	/**
+	* The (absolute) position directly after the wrapping node at the
+	* given level, or the original position when `depth` is
+	* `this.depth + 1`. Fails for depth 0.
+	*/
+	after(depth) {
+		return attempt(() => this.afterUnsafe(depth), isPositionError);
+	}
+	/** Like `after`, but throws a `PositionError` for depth 0. */
+	afterUnsafe(depth) {
+		depth = this.resolveDepth(depth);
+		if (!depth) throw new PositionError({ message: "There is no position after the top-level node" });
+		return depth === this.depth + 1 ? this.pos : this.path[depth * 3 - 1] + this.path[depth * 3].nodeSize;
+	}
+	/**
+	* When this position points into a text node, this returns the
+	* distance between the position and the start of the text node. Will
+	* be zero for positions that point between nodes.
+	*/
+	get textOffset() {
+		return this.pos - this.path[this.path.length - 1];
+	}
+	/**
+	* Get the node directly after the position, if any. If the position
+	* points into a text node, only the part of that node after the
+	* position is returned.
+	*/
+	get nodeAfter() {
+		return Option.fromNullishOr(this.nodeAfterOrNull);
+	}
+	/** @internal */
+	get nodeAfterOrNull() {
+		const parent = this.parent, index = this.index(this.depth);
+		if (index === parent.childCount) return null;
+		const dOff = this.pos - this.path[this.path.length - 1], child = parent.content.content[index];
+		return dOff ? child.cut(dOff) : child;
+	}
+	/**
+	* Get the node directly before the position, if any. If the position
+	* points into a text node, only the part of that node before the
+	* position is returned.
+	*/
+	get nodeBefore() {
+		return Option.fromNullishOr(this.nodeBeforeOrNull);
+	}
+	/** @internal */
+	get nodeBeforeOrNull() {
+		const index = this.index(this.depth);
+		const dOff = this.pos - this.path[this.path.length - 1];
+		if (dOff) return this.parent.content.content[index].cut(0, dOff);
+		return index === 0 ? null : this.parent.content.content[index - 1];
+	}
+	/** Get the position at the given index in the parent node at the given depth (which defaults to `this.depth`). */
+	posAtIndex(index, depth) {
+		depth = this.resolveDepth(depth);
+		const node = this.path[depth * 3];
+		let pos = depth === 0 ? 0 : this.path[depth * 3 - 1] + 1;
+		for (let i = 0; i < index; i++) pos += node.content.content[i].nodeSize;
+		return pos;
+	}
+	/**
+	* Get the marks at this position, factoring in the surrounding marks'
+	* `inclusive` property. If the position is at the start of a
+	* non-empty node, the marks of the node after it (if any) are
+	* returned.
+	*/
+	marks() {
+		const parent = this.parent, index = this.index();
+		if (parent.content.size === 0) return Mark.none;
+		if (this.textOffset) return parent.content.content[index].marks;
+		let main = parent.content.content[index - 1], other = parent.content.content[index];
+		if (!main) {
+			const tmp = main;
+			main = other;
+			other = tmp;
+		}
+		let marks = main.marks;
+		for (let i = 0; i < marks.length; i++) if (marks[i].type.spec.inclusive === false && (!other || !marks[i].isInSet(other.marks))) marks = marks[i--].removeFromSet(marks);
+		return marks;
+	}
+	/**
+	* Get the marks after the current position, if any, except those that
+	* are non-inclusive and not present at position `$end`. This is
+	* mostly useful for getting the set of marks to preserve after a
+	* deletion. Will return `None` if this position is at the end of its
+	* parent node or its parent node isn't a textblock (in which case no
+	* marks should be preserved).
+	*/
+	marksAcross($end) {
+		return Option.fromNullishOr(this.marksAcrossOrNull($end));
+	}
+	/** @internal */
+	marksAcrossOrNull($end) {
+		const after = this.parent.content.content[this.index()];
+		if (!after || !after.isInline) return null;
+		let marks = after.marks;
+		const next = $end.parent.content.content[$end.index()];
+		for (let i = 0; i < marks.length; i++) if (marks[i].type.spec.inclusive === false && (!next || !marks[i].isInSet(next.marks))) marks = marks[i--].removeFromSet(marks);
+		return marks;
+	}
+	/** The depth up to which this position and the given (non-resolved) position share the same parent nodes. */
+	sharedDepth(pos) {
+		for (let depth = this.depth; depth > 0; depth--) if (this.start(depth) <= pos && this.end(depth) >= pos) return depth;
+		return 0;
+	}
+	/**
+	* Returns a range based on the place where this position and the given
+	* position diverge around block content. If both point into the same
+	* textblock, for example, a range around that textblock will be
+	* returned. If they point into different blocks, the range around
+	* those blocks in their shared ancestor is returned. You can pass in
+	* an optional predicate that will be called with a parent node to see
+	* if a range into that parent is acceptable.
+	*/
+	blockRange(other = this, pred) {
+		return Option.fromNullishOr(this.blockRangeOrNull(other, pred));
+	}
+	/** @internal */
+	blockRangeOrNull(other = this, pred) {
+		if (other.pos < this.pos) return other.blockRangeOrNull(this);
+		for (let d = this.depth - (this.parent.inlineContent || this.pos === other.pos ? 1 : 0); d >= 0; d--) if (other.pos <= this.end(d) && (!pred || pred(this.node(d)))) return new NodeRange(this, other, d);
+		return null;
+	}
+	/** Query whether the given position shares the same parent node. */
+	sameParent(other) {
+		return this.pos - this.parentOffset === other.pos - other.parentOffset;
+	}
+	/** Return the greater of this and the given position. */
+	max(other) {
+		return other.pos > this.pos ? other : this;
+	}
+	/** Return the smaller of this and the given position. */
+	min(other) {
+		return other.pos < this.pos ? other : this;
+	}
+	/** @internal */
+	toString() {
+		let str = "";
+		for (let i = 1; i <= this.depth; i++) str += (str ? "/" : "") + this.node(i).type.name + "_" + this.index(i - 1);
+		return str + ":" + this.parentOffset;
+	}
+	/** @internal */
+	static resolve(doc, pos) {
+		if (!(pos >= 0 && pos <= doc.content.size)) throw new PositionError({ message: "Position " + pos + " out of range" });
+		const path = [];
+		let start = 0, parentOffset = pos;
+		for (let node = doc;;) {
+			const { index, offset } = node.content.findIndex(parentOffset);
+			const rem = parentOffset - offset;
+			path.push(node, index, start + offset);
+			if (!rem) break;
+			node = node.content.content[index];
+			if (node.isText) break;
+			parentOffset = rem - 1;
+			start += offset + 1;
+		}
+		return new ResolvedPos(pos, path, parentOffset);
+	}
+	/** @internal */
+	static resolveCached(doc, pos) {
+		let cache = resolveCache.get(doc);
+		if (cache) for (let i = 0; i < cache.elts.length; i++) {
+			const elt = cache.elts[i];
+			if (elt.pos === pos) return elt;
+		}
+		else resolveCache.set(doc, cache = new ResolveCache());
+		const result = cache.elts[cache.i] = ResolvedPos.resolve(doc, pos);
+		cache.i = (cache.i + 1) % resolveCacheSize;
+		return result;
+	}
+};
+var ResolveCache = class {
+	constructor() {
+		this.elts = [];
+		this.i = 0;
+	}
+};
+const resolveCacheSize = 12;
+const resolveCache = /* @__PURE__ */ new WeakMap();
+/**
+* Represents a flat range of content, i.e. one that starts and ends in
+* the same node.
+*
+* @since 0.1.0
+* @category models
+*/
+var NodeRange = class {
+	/**
+	* Construct a node range. `$from` and `$to` should point into the
+	* same node until at least the given `depth`, since a node range
+	* denotes an adjacent set of nodes in a single parent node.
+	*/
+	constructor($from, $to, depth) {
+		this.$from = $from;
+		this.$to = $to;
+		this.depth = depth;
+	}
+	/** The position at the start of the range. */
+	get start() {
+		return this.$from.beforeUnsafe(this.depth + 1);
+	}
+	/** The position at the end of the range. */
+	get end() {
+		return this.$to.afterUnsafe(this.depth + 1);
+	}
+	/** The parent node that the range points into. */
+	get parent() {
+		return this.$from.node(this.depth);
+	}
+	/** The start index of the range in the parent node. */
+	get startIndex() {
+		return this.$from.index(this.depth);
+	}
+	/** The end index of the range in the parent node. */
+	get endIndex() {
+		return this.$to.indexAfter(this.depth);
+	}
+};
+export { NodeRange, ResolvedPos };