@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/model/replace.js

@@ -0,0 +1,207 @@
+import { JSONError, PositionError, ReplaceError } from "./errors.js";
+import { Fragment } from "./fragment.js";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+// src/model/replace.ts
+/**
+* Slices and the replace algorithm.
+*
+* @since 0.1.0
+*/
+/**
+* A slice represents a piece cut out of a larger document. It stores
+* not only a fragment, but also the depth up to which nodes on both
+* side are ‘open’ (cut through).
+*
+* @since 0.1.0
+* @category models
+*/
+var Slice = class Slice {
+	/**
+	* Create a slice. When specifying a non-zero open depth, you must
+	* make sure that there are nodes of at least that depth at the
+	* appropriate side of the fragment—i.e. if the fragment is an empty
+	* paragraph node, `openStart` and `openEnd` can't be greater than 1.
+	*
+	* It is not necessary for the content of open nodes to conform to the
+	* schema's content constraints, though it should be a valid
+	* start/end/middle for such a node, depending on which sides are
+	* open.
+	*/
+	constructor(content, openStart, openEnd) {
+		this.content = content;
+		this.openStart = openStart;
+		this.openEnd = openEnd;
+	}
+	/** The size this slice would add when inserted into a document. */
+	get size() {
+		return this.content.size - this.openStart - this.openEnd;
+	}
+	/** @internal */
+	insertAt(pos, fragment) {
+		const content = insertInto(this.content, pos + this.openStart, fragment, this.openStart + 1, this.openEnd + 1);
+		return content && new Slice(content, this.openStart, this.openEnd);
+	}
+	/** @internal */
+	removeBetween(from, to) {
+		return new Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
+	}
+	/** Tests whether this slice is equal to another slice. */
+	eq(other) {
+		return this.content.eq(other.content) && this.openStart === other.openStart && this.openEnd === other.openEnd;
+	}
+	/** @internal */
+	[Equal.symbol](that) {
+		return that instanceof Slice && this.eq(that);
+	}
+	/** @internal */
+	[Hash.symbol]() {
+		return Hash.combine(Hash.hash(this.content))(Hash.combine(Hash.number(this.openStart))(Hash.number(this.openEnd)));
+	}
+	/** @internal */
+	toString() {
+		return this.content + "(" + this.openStart + "," + this.openEnd + ")";
+	}
+	/** Convert a slice to a JSON-serializable representation. */
+	toJSON() {
+		if (!this.content.size) return null;
+		const json = { content: this.content.toJSON() };
+		if (this.openStart > 0) json.openStart = this.openStart;
+		if (this.openEnd > 0) json.openEnd = this.openEnd;
+		return json;
+	}
+	/** @internal */
+	static fromJSONUnsafe(schema, json) {
+		if (!json) return Slice.empty;
+		const openStart = json.openStart || 0, openEnd = json.openEnd || 0;
+		if (typeof openStart !== "number" || typeof openEnd !== "number") throw new JSONError({ message: "Invalid input for Slice.fromJSON" });
+		if (json.content != null && !Array.isArray(json.content)) throw new JSONError({ message: "Invalid input for Slice.fromJSON" });
+		const nodes = (json.content ?? []).map((n) => schema.nodeFromJSONUnsafe(n));
+		return new Slice(Fragment.fromArray(nodes), openStart, openEnd);
+	}
+	/**
+	* Create a slice from a fragment by taking the maximum possible open
+	* value on both side of the fragment.
+	*/
+	static maxOpen(fragment, openIsolating = true) {
+		let openStart = 0, openEnd = 0;
+		for (let n = fragment.content[0]; n && !n.isLeaf; n = n.content.content[0]) {
+			if (!openIsolating && n.type.spec.isolating) break;
+			openStart++;
+		}
+		for (let n = fragment.content[fragment.content.length - 1]; n && !n.isLeaf; n = n.content.content[n.content.content.length - 1]) {
+			if (!openIsolating && n.type.spec.isolating) break;
+			openEnd++;
+		}
+		return new Slice(fragment, openStart, openEnd);
+	}
+	static {
+		this.empty = new Slice(Fragment.empty, 0, 0);
+	}
+};
+function removeRange(content, from, to) {
+	const { index, offset } = content.findIndex(from);
+	const child = content.content[index];
+	const { index: indexTo, offset: offsetTo } = content.findIndex(to);
+	if (offset === from || child.isText) {
+		if (offsetTo !== to && !content.content[indexTo].isText) throw new PositionError({ message: "Removing non-flat range" });
+		return content.cut(0, from).append(content.cut(to));
+	}
+	if (index !== indexTo) throw new PositionError({ message: "Removing non-flat range" });
+	return content.replaceChild(index, child.copy(removeRange(child.content, from - offset - 1, to - offset - 1)));
+}
+function insertInto(content, dist, insert, openStart, openEnd, parent) {
+	const { index, offset } = content.findIndex(dist);
+	const child = content.content[index];
+	if (offset === dist || child.isText) {
+		if (parent && openStart <= 0 && openEnd <= 0 && !parent.canReplace(index, index, insert)) return null;
+		return content.cut(0, dist).append(insert).append(content.cut(dist));
+	}
+	const inner = insertInto(child.content, dist - offset - 1, insert, index === 0 ? openStart - 1 : 0, index === content.childCount - 1 ? openEnd - 1 : 0, child);
+	return inner && content.replaceChild(index, child.copy(inner));
+}
+/** @internal */
+function replace($from, $to, slice) {
+	if (slice.openStart > $from.depth) throw new ReplaceError({ message: "Inserted content deeper than insertion position" });
+	if ($from.depth - slice.openStart !== $to.depth - slice.openEnd) throw new ReplaceError({ message: "Inconsistent open depths" });
+	return replaceOuter($from, $to, slice, 0);
+}
+function replaceOuter($from, $to, slice, depth) {
+	const index = $from.index(depth), node = $from.node(depth);
+	if (index === $to.index(depth) && depth < $from.depth - slice.openStart) {
+		const inner = replaceOuter($from, $to, slice, depth + 1);
+		return node.copy(node.content.replaceChild(index, inner));
+	} else if (!slice.content.size) return close(node, replaceTwoWay($from, $to, depth));
+	else if (!slice.openStart && !slice.openEnd && $from.depth === depth && $to.depth === depth) {
+		const parent = $from.parent, content = parent.content;
+		return close(parent, content.cut(0, $from.parentOffset).append(slice.content).append(content.cut($to.parentOffset)));
+	} else {
+		const { end, start } = prepareSliceForReplace(slice, $from);
+		return close(node, replaceThreeWay($from, start, end, $to, depth));
+	}
+}
+function checkJoin(main, sub) {
+	if (!sub.type.compatibleContent(main.type)) throw new ReplaceError({ message: "Cannot join " + sub.type.name + " onto " + main.type.name });
+}
+function joinable($before, $after, depth) {
+	const node = $before.node(depth);
+	checkJoin(node, $after.node(depth));
+	return node;
+}
+function addNode(child, target) {
+	const last = target.length - 1;
+	if (last >= 0 && child.isText && child.sameMarkup(target[last])) target[last] = child.withText(target[last].text + child.text);
+	else target.push(child);
+}
+function addRange($start, $end, depth, target) {
+	const node = ($end || $start).node(depth);
+	let startIndex = 0;
+	const endIndex = $end ? $end.index(depth) : node.childCount;
+	if ($start) {
+		startIndex = $start.index(depth);
+		if ($start.depth > depth) startIndex++;
+		else if ($start.textOffset) {
+			addNode($start.nodeAfterOrNull, target);
+			startIndex++;
+		}
+	}
+	for (let i = startIndex; i < endIndex; i++) addNode(node.content.content[i], target);
+	if ($end && $end.depth === depth && $end.textOffset) addNode($end.nodeBeforeOrNull, target);
+}
+function close(node, content) {
+	if (!node.type.validContent(content)) throw new ReplaceError({ message: `Invalid content for node ${node.type.name}: ${content.toString().slice(0, 50)}` });
+	return node.copy(content);
+}
+function replaceThreeWay($from, $start, $end, $to, depth) {
+	const openStart = $from.depth > depth && joinable($from, $start, depth + 1);
+	const openEnd = $to.depth > depth && joinable($end, $to, depth + 1);
+	const content = [];
+	addRange(null, $from, depth, content);
+	if (openStart && openEnd && $start.index(depth) === $end.index(depth)) {
+		checkJoin(openStart, openEnd);
+		addNode(close(openStart, replaceThreeWay($from, $start, $end, $to, depth + 1)), content);
+	} else {
+		if (openStart) addNode(close(openStart, replaceTwoWay($from, $start, depth + 1)), content);
+		addRange($start, $end, depth, content);
+		if (openEnd) addNode(close(openEnd, replaceTwoWay($end, $to, depth + 1)), content);
+	}
+	addRange($to, null, depth, content);
+	return new Fragment(content);
+}
+function replaceTwoWay($from, $to, depth) {
+	const content = [];
+	addRange(null, $from, depth, content);
+	if ($from.depth > depth) addNode(close(joinable($from, $to, depth + 1), replaceTwoWay($from, $to, depth + 1)), content);
+	addRange($to, null, depth, content);
+	return new Fragment(content);
+}
+function prepareSliceForReplace(slice, $along) {
+	const extra = $along.depth - slice.openStart;
+	let node = $along.node(extra).copy(slice.content);
+	for (let i = extra - 1; i >= 0; i--) node = $along.node(i).copy(Fragment.from(node));
+	return {
+		start: node.resolveNoCache(slice.openStart + extra),
+		end: node.resolveNoCache(node.content.size - slice.openEnd - extra)
+	};
+}
+export { Slice, replace };

package/dist/model/resolvedpos.d.ts

@@ -0,0 +1,196 @@
+import { PositionError } from "./errors.js";
+import { Mark } from "./mark.js";
+import { Node } from "./node.js";
+import { AnySchema } from "./schema.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+/**
+ * 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
+ */
+export declare class ResolvedPos<Sc extends AnySchema = AnySchema> {
+  /** The position that was resolved. */
+  readonly pos: number;
+  /** @internal */
+  readonly path: ReadonlyArray<any>;
+  /** The offset this position has into its parent node. */
+  readonly parentOffset: number;
+  /**
+   * The number of levels the parent node is from the root. If this
+   * position points directly into the root node, it is 0. If it points
+   * into a top-level paragraph, 1, and so on.
+   */
+  readonly depth: number;
+  /** @internal */
+  constructor(
+  /** The position that was resolved. */
+  pos: number,
+  /** @internal */
+  path: ReadonlyArray<any>,
+  /** The offset this position has into its parent node. */
+  parentOffset: number);
+  /** @internal */
+  resolveDepth(val: number | undefined | null): number;
+  /**
+   * 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(): Node<Sc>;
+  /** The root node in which the position was resolved. */
+  get doc(): Node<Sc>;
+  /** The ancestor node at the given level. `p.node(p.depth)` is the same as `p.parent`. */
+  node(depth?: number | null): Node<Sc>;
+  /**
+   * 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?: number | null): number;
+  /** The index pointing after this position into the ancestor at the given level. */
+  indexAfter(depth?: number | null): number;
+  /** The (absolute) position at the start of the node at the given level. */
+  start(depth?: number | null): number;
+  /** The (absolute) position at the end of the node at the given level. */
+  end(depth?: number | null): number;
+  /**
+   * 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?: number | null): Effect.Effect<number, PositionError>;
+  /** Like `before`, but throws a `PositionError` for depth 0. */
+  beforeUnsafe(depth?: number | null): number;
+  /**
+   * 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?: number | null): Effect.Effect<number, PositionError>;
+  /** Like `after`, but throws a `PositionError` for depth 0. */
+  afterUnsafe(depth?: number | null): number;
+  /**
+   * 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(): number;
+  /**
+   * 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(): Option.Option<Node<Sc>>;
+  /** @internal */
+  get nodeAfterOrNull(): Node<Sc> | null;
+  /**
+   * 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(): Option.Option<Node<Sc>>;
+  /** @internal */
+  get nodeBeforeOrNull(): Node<Sc> | null;
+  /** Get the position at the given index in the parent node at the given depth (which defaults to `this.depth`). */
+  posAtIndex(index: number, depth?: number | null): number;
+  /**
+   * 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(): ReadonlyArray<Mark<Sc>>;
+  /**
+   * 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: ResolvedPos<Sc>): Option.Option<ReadonlyArray<Mark<Sc>>>;
+  /** @internal */
+  marksAcrossOrNull($end: ResolvedPos<Sc>): ReadonlyArray<Mark<Sc>> | null;
+  /** The depth up to which this position and the given (non-resolved) position share the same parent nodes. */
+  sharedDepth(pos: number): number;
+  /**
+   * 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?: ResolvedPos<Sc>, pred?: (node: Node<Sc>) => boolean): Option.Option<NodeRange<Sc>>;
+  /** @internal */
+  blockRangeOrNull(other?: ResolvedPos<Sc>, pred?: (node: Node<Sc>) => boolean): NodeRange<Sc> | null;
+  /** Query whether the given position shares the same parent node. */
+  sameParent(other: ResolvedPos<any>): boolean;
+  /** Return the greater of this and the given position. */
+  max(other: ResolvedPos<Sc>): ResolvedPos<Sc>;
+  /** Return the smaller of this and the given position. */
+  min(other: ResolvedPos<Sc>): ResolvedPos<Sc>;
+  /** @internal */
+  toString(): string;
+  /** @internal */
+  static resolve<Sc extends AnySchema>(doc: Node<Sc>, pos: number): ResolvedPos<Sc>;
+  /** @internal */
+  static resolveCached<Sc extends AnySchema>(doc: Node<Sc>, pos: number): ResolvedPos<Sc>;
+}
+/**
+ * Represents a flat range of content, i.e. one that starts and ends in
+ * the same node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class NodeRange<Sc extends AnySchema = AnySchema> {
+  /**
+   * A resolved position along the start of the content. May have a
+   * `depth` greater than this object's `depth` property, since these
+   * are the positions that were used to compute the range, not
+   * re-resolved positions directly at its boundaries.
+   */
+  readonly $from: ResolvedPos<Sc>;
+  /** A position along the end of the content. */
+  readonly $to: ResolvedPos<Sc>;
+  /** The depth of the node that this range points into. */
+  readonly depth: number;
+  /**
+   * 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(
+  /**
+   * A resolved position along the start of the content. May have a
+   * `depth` greater than this object's `depth` property, since these
+   * are the positions that were used to compute the range, not
+   * re-resolved positions directly at its boundaries.
+   */
+  $from: ResolvedPos<Sc>,
+  /** A position along the end of the content. */
+  $to: ResolvedPos<Sc>,
+  /** The depth of the node that this range points into. */
+  depth: number);
+  /** The position at the start of the range. */
+  get start(): number;
+  /** The position at the end of the range. */
+  get end(): number;
+  /** The parent node that the range points into. */
+  get parent(): Node<Sc>;
+  /** The start index of the range in the parent node. */
+  get startIndex(): number;
+  /** The end index of the range in the parent node. */
+  get endIndex(): number;
+}