@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/model/node.js

@@ -0,0 +1,434 @@
+import { attempt } from "../internal/attempt.js";
+import { showJson } from "../internal/json.js";
+import { encodeAttrs } from "./attrsCodec.js";
+import { compareDeep } from "./comparedeep.js";
+import { ContentError, PositionError, isModelError } from "./errors.js";
+import { Fragment } from "./fragment.js";
+import { Mark } from "./mark.js";
+import { Slice, replace } from "./replace.js";
+import { ResolvedPos } from "./resolvedpos.js";
+import * as Option from "effect/Option";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+// src/model/node.ts
+const emptyAttrs = Object.create(null);
+const isPositionError = (u) => u instanceof PositionError;
+/**
+* This class represents a node in the tree that makes up a document.
+* So a document is an instance of `Node`, with children that are also
+* instances of `Node`.
+*
+* Nodes are persistent data structures. Instead of changing them, you
+* create new ones with the content you want. Old ones keep pointing at
+* the old document shape. This is made cheaper by sharing structure
+* between the old and new data as much as possible.
+*
+* The type parameters track the schema and the node type name (or
+* union of names), which determines the type of `attrs` and of the
+* node's children. Use `is` to narrow a node to a specific type.
+*
+* Nodes implement `Equal`, comparing structurally.
+*
+* @since 0.1.0
+* @category models
+*/
+var Node = class Node {
+	/** @internal */
+	constructor(type, attrs, content, marks = Mark.none) {
+		this.type = type;
+		this.attrs = attrs;
+		this.marks = marks;
+		this.content = content || Fragment.empty;
+	}
+	/** Narrow this node to the given node type(s). */
+	is(...names) {
+		return names.indexOf(this.type.name) > -1;
+	}
+	/** Narrow this node to a text node. */
+	isTextNode() {
+		return this.type.isText;
+	}
+	/** The array of this node's child nodes. */
+	get children() {
+		return this.content.content;
+	}
+	/**
+	* The size of this node, as defined by the integer-based indexing
+	* scheme. For text nodes, this is the amount of characters. For other
+	* leaf nodes, it is one. For non-leaf nodes, it is the size of the
+	* content plus two (the start and end token).
+	*/
+	get nodeSize() {
+		return this.isLeaf ? 1 : 2 + this.content.size;
+	}
+	/** The number of children that the node has. */
+	get childCount() {
+		return this.content.childCount;
+	}
+	/** Get the child node at the given index. Fails when the index is out of range. */
+	child(index) {
+		return this.content.child(index);
+	}
+	/** Like `child`, but throws a `PositionError` when the index is out of range. */
+	childUnsafe(index) {
+		return this.content.childUnsafe(index);
+	}
+	/** Get the child node at the given index, if it exists. */
+	maybeChild(index) {
+		return this.content.maybeChild(index);
+	}
+	/** Call `f` for every child node, passing the node, its offset into this parent node, and its index. */
+	forEach(f) {
+		this.content.forEach(f);
+	}
+	/**
+	* Invoke a callback for all descendant nodes recursively overlapping
+	* the given two positions that are relative to start of this node's
+	* content. This includes all ancestors of the nodes containing the
+	* two positions. The callback is invoked with the node, its position
+	* relative to the original node (method receiver), its parent node,
+	* and its child index. When the callback returns false for a given
+	* node, that node's children will not be recursed over. The last
+	* parameter can be used to specify a starting position to count
+	* from.
+	*/
+	nodesBetween(from, to, f, startPos = 0) {
+		this.content.nodesBetween(from, to, f, startPos, this);
+	}
+	/** Call the given callback for every descendant node. Doesn't descend into a node when the callback returns `false`. */
+	descendants(f) {
+		this.nodesBetween(0, this.content.size, f);
+	}
+	/** Concatenates all the text nodes found in this node and its children. */
+	get textContent() {
+		return this.isLeaf && this.type.spec.leafText ? this.type.spec.leafText(this) : this.textBetween(0, this.content.size, "");
+	}
+	/**
+	* Get all text between positions `from` and `to`. When
+	* `blockSeparator` is given, it will be inserted to separate text from
+	* different block nodes. If `leafText` is given, it'll be inserted for
+	* every non-text leaf node encountered, otherwise the spec's
+	* `leafText` will be used.
+	*/
+	textBetween(from, to, blockSeparator, leafText) {
+		return this.content.textBetween(from, to, blockSeparator, leafText);
+	}
+	/** Returns this node's first child, if any. */
+	get firstChild() {
+		return this.content.firstChild;
+	}
+	/** Returns this node's last child, if any. */
+	get lastChild() {
+		return this.content.lastChild;
+	}
+	/** Test whether two nodes represent the same piece of document. */
+	eq(other) {
+		return this === other || this.sameMarkup(other) && this.content.eq(other.content);
+	}
+	/** @internal */
+	[Equal.symbol](that) {
+		return that instanceof Node && this.eq(that);
+	}
+	/** @internal */
+	[Hash.symbol]() {
+		return Hash.combine(Hash.string(this.type.name))(Hash.combine(Hash.structure(this.attrs))(Hash.combine(Hash.array(this.marks))(Hash.hash(this.content))));
+	}
+	/** Compare the markup (type, attributes, and marks) of this node to those of another. */
+	sameMarkup(other) {
+		return this.hasMarkup(other.type, other.attrs, other.marks);
+	}
+	/** Check whether this node's markup correspond to the given type, attributes, and marks. */
+	hasMarkup(type, attrs, marks) {
+		return this.type === type && compareDeep(this.attrs, attrs || type.defaultAttrs || emptyAttrs) && Mark.sameSet(this.marks, marks || Mark.none);
+	}
+	/** Create a new node with the same markup as this node, containing the given content (or empty, if no content is given). */
+	copy(content = null) {
+		if (content === this.content) return this;
+		return new Node(this.type, this.attrs, content, this.marks);
+	}
+	/** Create a copy of this node, with the given set of marks instead of the node's own marks. */
+	mark(marks) {
+		return marks === this.marks ? this : new Node(this.type, this.attrs, this.content, marks);
+	}
+	/**
+	* Create a copy of this node with only the content between the given
+	* positions. If `to` is not given, it defaults to the end of the node.
+	*/
+	cut(from, to = this.content.size) {
+		if (from === 0 && to === this.content.size) return this;
+		return this.copy(this.content.cut(from, to));
+	}
+	/** Cut out the part of the document between the given positions, and return it as a `Slice`. */
+	slice(from, to = this.content.size, includeParents = false) {
+		return attempt(() => this.sliceUnsafe(from, to, includeParents), isPositionError);
+	}
+	/** Like `slice`, but throws a `PositionError` for invalid positions. */
+	sliceUnsafe(from, to = this.content.size, includeParents = false) {
+		if (from === to) return Slice.empty;
+		const $from = this.resolveUnsafe(from), $to = this.resolveUnsafe(to);
+		const depth = includeParents ? 0 : $from.sharedDepth(to);
+		const start = $from.start(depth);
+		const content = $from.node(depth).content.cut($from.pos - start, $to.pos - start);
+		return new Slice(content, $from.depth - depth, $to.depth - depth);
+	}
+	/**
+	* Replace the part of the document between the given positions with
+	* the given slice. The slice must 'fit', meaning its open sides must
+	* be able to connect to the surrounding content, and its content
+	* nodes must be valid children for the node they are placed into. If
+	* any of this is violated, the effect fails with a `ReplaceError`.
+	*/
+	replace(from, to, slice) {
+		return attempt(() => this.replaceUnsafe(from, to, slice), isModelError);
+	}
+	/** Like `replace`, but throws on failure. */
+	replaceUnsafe(from, to, slice) {
+		return replace(this.resolveUnsafe(from), this.resolveUnsafe(to), slice);
+	}
+	/** Find the node directly after the given position, if any. */
+	nodeAt(pos) {
+		return Option.fromNullishOr(this.nodeAtOrNull(pos));
+	}
+	/** @internal */
+	nodeAtOrNull(pos) {
+		if (pos < 0 || pos > this.content.size) return null;
+		for (let node = this;;) {
+			const { index, offset } = node.content.findIndex(pos);
+			node = node.content.content[index];
+			if (!node) return null;
+			if (offset === pos || node.isText) return node;
+			pos -= offset + 1;
+		}
+	}
+	/**
+	* Find the (direct) child node after the given offset, if any, and
+	* return it along with its index and offset relative to this node.
+	*/
+	childAfter(pos) {
+		const { index, offset } = this.content.findIndex(pos);
+		return {
+			node: this.content.maybeChild(index),
+			index,
+			offset
+		};
+	}
+	/**
+	* Find the (direct) child node before the given offset, if any, and
+	* return it along with its index and offset relative to this node.
+	*/
+	childBefore(pos) {
+		if (pos === 0) return {
+			node: Option.none(),
+			index: 0,
+			offset: 0
+		};
+		const { index, offset } = this.content.findIndex(pos);
+		if (offset < pos) return {
+			node: Option.some(this.content.content[index]),
+			index,
+			offset
+		};
+		const node = this.content.content[index - 1];
+		return {
+			node: Option.some(node),
+			index: index - 1,
+			offset: offset - node.nodeSize
+		};
+	}
+	/**
+	* Resolve the given position in the document, returning an object
+	* with information about its context.
+	*/
+	resolve(pos) {
+		return attempt(() => this.resolveUnsafe(pos), isPositionError);
+	}
+	/** Like `resolve`, but throws a `PositionError` for out-of-range positions. */
+	resolveUnsafe(pos) {
+		return ResolvedPos.resolveCached(this, pos);
+	}
+	/** @internal */
+	resolveNoCache(pos) {
+		return ResolvedPos.resolve(this, pos);
+	}
+	/** Test whether a given mark or mark type occurs in this document between the two given positions. */
+	rangeHasMark(from, to, type) {
+		let found = false;
+		if (to > from) this.nodesBetween(from, to, (node) => {
+			if (type instanceof Mark ? type.isInSet(node.marks) : type.findInSet(node.marks)) found = true;
+			return !found;
+		});
+		return found;
+	}
+	/** True when this is a block (non-inline node) */
+	get isBlock() {
+		return this.type.isBlock;
+	}
+	/** True when this is a textblock node, a block node with inline content. */
+	get isTextblock() {
+		return this.type.isTextblock;
+	}
+	/** True when this node allows inline content. */
+	get inlineContent() {
+		return this.type.inlineContent;
+	}
+	/** True when this is an inline node (a text node or a node that can appear among text). */
+	get isInline() {
+		return this.type.isInline;
+	}
+	/** True when this is a text node. */
+	get isText() {
+		return this.type.isText;
+	}
+	/** True when this is a leaf node. */
+	get isLeaf() {
+		return this.type.isLeaf;
+	}
+	/**
+	* True when this is an atom, i.e. when it does not have directly
+	* editable content. This is usually the same as `isLeaf`, but can be
+	* configured with the `atom` property on a node's spec.
+	*/
+	get isAtom() {
+		return this.type.isAtom;
+	}
+	/** Return a string representation of this node for debugging purposes. */
+	toString() {
+		if (this.type.spec.toDebugString) return this.type.spec.toDebugString(this);
+		let name = this.type.name;
+		if (this.content.size) name += "(" + this.content.toStringInner() + ")";
+		return wrapMarks(this.marks, name);
+	}
+	/** Get the content match in this node at the given index. */
+	contentMatchAt(index) {
+		return attempt(() => this.contentMatchAtUnsafe(index), (u) => u instanceof ContentError);
+	}
+	/** Like `contentMatchAt`, but throws when the node's content is invalid. */
+	contentMatchAtUnsafe(index) {
+		const match = this.type.contentMatch.matchFragmentOrNull(this.content, 0, index);
+		if (!match) throw new ContentError({ message: "Called contentMatchAt on a node with invalid content" });
+		return match;
+	}
+	/**
+	* Test whether replacing the range between `from` and `to` (by child
+	* index) with the given replacement fragment (which defaults to the
+	* empty fragment) would leave the node's content valid. You can
+	* optionally pass `start` and `end` indices into the replacement
+	* fragment.
+	*/
+	canReplace(from, to, replacement = Fragment.empty, start = 0, end = replacement.childCount) {
+		const one = this.contentMatchAtUnsafe(from).matchFragmentOrNull(replacement, start, end);
+		const two = one && one.matchFragmentOrNull(this.content, to);
+		if (!two || !two.validEnd) return false;
+		for (let i = start; i < end; i++) if (!this.type.allowsMarks(replacement.content[i].marks)) return false;
+		return true;
+	}
+	/**
+	* Test whether replacing the range `from` to `to` (by index) with a
+	* node of the given type would leave the node's content valid.
+	*/
+	canReplaceWith(from, to, type, marks) {
+		if (marks && !this.type.allowsMarks(marks)) return false;
+		const start = this.contentMatchAtUnsafe(from).matchTypeOrNull(type);
+		const end = start && start.matchFragmentOrNull(this.content, to);
+		return end ? end.validEnd : false;
+	}
+	/**
+	* Test whether the given node's content could be appended to this
+	* node. If that node is empty, this will only return true if there is
+	* at least one node type that can appear in both nodes (to avoid
+	* merging completely incompatible nodes).
+	*/
+	canAppend(other) {
+		if (other.content.size) return this.canReplace(this.childCount, this.childCount, other.content);
+		return this.type.compatibleContent(other.type);
+	}
+	/**
+	* Check whether this node and its descendants conform to the schema
+	* (including attribute schemas), failing with a `ContentError` or
+	* `AttributeError` when they do not.
+	*/
+	check() {
+		return attempt(() => this.checkUnsafe(), isModelError);
+	}
+	/** Like `check`, but throws on failure. */
+	checkUnsafe() {
+		this.type.checkContent(this.content);
+		this.type.checkAttrs(this.attrs);
+		let copy = Mark.none;
+		for (let i = 0; i < this.marks.length; i++) {
+			const mark = this.marks[i];
+			mark.type.checkAttrs(mark.attrs);
+			copy = mark.addToSet(copy);
+		}
+		if (!Mark.sameSet(copy, this.marks)) throw new ContentError({ message: `Invalid collection of marks for node ${this.type.name}: ${this.marks.map((m) => m.type.name).join(",")}` });
+		this.content.forEach((node) => node.checkUnsafe());
+	}
+	/** Return a JSON-serializable representation of this node. */
+	toJSON() {
+		const obj = { type: this.type.name };
+		for (const _ in this.attrs) {
+			obj.attrs = this.type.identityAttrs ? this.attrs : encodeAttrs(this.type.attrs, this.attrs);
+			break;
+		}
+		if (this.content.size) obj.content = this.content.toJSON();
+		if (this.marks.length) obj.marks = this.marks.map((n) => n.toJSON());
+		return obj;
+	}
+};
+/**
+* A text node. Text nodes are always leaves and carry their text in
+* `text`.
+*
+* @since 0.1.0
+* @category models
+*/
+var TextNode = class TextNode extends Node {
+	/** @internal */
+	constructor(type, attrs, content, marks) {
+		super(type, attrs, null, marks);
+		if (!content) throw new ContentError({ message: "Empty text nodes are not allowed" });
+		this.text = content;
+	}
+	toString() {
+		if (this.type.spec.toDebugString) return this.type.spec.toDebugString(this);
+		return wrapMarks(this.marks, showJson(this.text));
+	}
+	get textContent() {
+		return this.text;
+	}
+	textBetween(from, to) {
+		return this.text.slice(from, to);
+	}
+	get nodeSize() {
+		return this.text.length;
+	}
+	mark(marks) {
+		return marks === this.marks ? this : new TextNode(this.type, this.attrs, this.text, marks);
+	}
+	/** Create a copy of this text node with different text. */
+	withText(text) {
+		if (text === this.text) return this;
+		return new TextNode(this.type, this.attrs, text, this.marks);
+	}
+	cut(from = 0, to = this.text.length) {
+		if (from === 0 && to === this.text.length) return this;
+		return this.withText(this.text.slice(from, to));
+	}
+	eq(other) {
+		return this.sameMarkup(other) && other instanceof TextNode && this.text === other.text;
+	}
+	[Hash.symbol]() {
+		return Hash.combine(Hash.string(this.text))(Hash.array(this.marks));
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			text: this.text
+		};
+	}
+};
+function wrapMarks(marks, str) {
+	for (let i = marks.length - 1; i >= 0; i--) str = marks[i].type.name + "(" + str + ")";
+	return str;
+}
+export { Node, TextNode };

package/dist/model/replace.d.ts

@@ -0,0 +1,78 @@
+import { Fragment } from "./fragment.js";
+import { Node, NodeJSON } from "./node.js";
+import { ResolvedPos } from "./resolvedpos.js";
+import { AnySchema } from "./schema.js";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+/**
+ * The JSON representation of a slice.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface SliceJSON {
+  readonly content: ReadonlyArray<NodeJSON>;
+  readonly openStart?: number;
+  readonly openEnd?: number;
+}
+/**
+ * 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
+ */
+export declare class Slice<Sc extends AnySchema = AnySchema> implements Equal.Equal {
+  /** The slice's content. */
+  readonly content: Fragment<Sc>;
+  /** The open depth at the start of the fragment. */
+  readonly openStart: number;
+  /** The open depth at the end. */
+  readonly openEnd: number;
+  /**
+   * 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(
+  /** The slice's content. */
+  content: Fragment<Sc>,
+  /** The open depth at the start of the fragment. */
+  openStart: number,
+  /** The open depth at the end. */
+  openEnd: number);
+  /** The size this slice would add when inserted into a document. */
+  get size(): number;
+  /** @internal */
+  insertAt(pos: number, fragment: Fragment<Sc>): Slice<Sc> | null;
+  /** @internal */
+  removeBetween(from: number, to: number): Slice<Sc>;
+  /** Tests whether this slice is equal to another slice. */
+  eq(other: Slice<any>): boolean;
+  /** @internal */
+  [Equal.symbol](that: Equal.Equal): boolean;
+  /** @internal */
+  [Hash.symbol](): number;
+  /** @internal */
+  toString(): string;
+  /** Convert a slice to a JSON-serializable representation. */
+  toJSON(): SliceJSON | null;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(schema: Sc, json: any): Slice<Sc>;
+  /**
+   * Create a slice from a fragment by taking the maximum possible open
+   * value on both side of the fragment.
+   */
+  static maxOpen<Sc extends AnySchema>(fragment: Fragment<Sc>, openIsolating?: boolean): Slice<Sc>;
+  /** The empty slice. */
+  static readonly empty: Slice<any>;
+}
+/** @internal */
+export declare function replace<Sc extends AnySchema>($from: ResolvedPos<Sc>, $to: ResolvedPos<Sc>, slice: Slice<Sc>): Node<Sc>;