@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/model/errors.d.ts

@@ -0,0 +1,90 @@
+import * as Schema from "effect/Schema";
+declare const PositionError_base: Schema.Class<PositionError, Schema.TaggedStruct<"PositionError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A position or index was outside of the valid range of a node or
+ * fragment.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class PositionError extends PositionError_base {}
+declare const ReplaceError_base: Schema.Class<ReplaceError, Schema.TaggedStruct<"ReplaceError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when a [`Slice`](#Slice) cannot be fitted into a document,
+ * typically by `Node.replace`.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class ReplaceError extends ReplaceError_base {}
+declare const ContentError_base: Schema.Class<ContentError, Schema.TaggedStruct<"ContentError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Content that does not satisfy a node type's content expression or
+ * mark restrictions.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class ContentError extends ContentError_base {}
+declare const AttributeError_base: Schema.Class<AttributeError, Schema.TaggedStruct<"AttributeError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Missing, unknown, or invalid node or mark attributes.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class AttributeError extends AttributeError_base {}
+declare const SchemaDefinitionError_base: Schema.Class<SchemaDefinitionError, Schema.TaggedStruct<"SchemaDefinitionError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A schema definition (or a content expression in it) is invalid.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class SchemaDefinitionError extends SchemaDefinitionError_base {}
+declare const JSONError_base: Schema.Class<JSONError, Schema.TaggedStruct<"JSONError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when deserializing JSON that does not describe a valid
+ * document structure for the schema.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class JSONError extends JSONError_base {}
+declare const DOMSpecError_base: Schema.Class<DOMSpecError, Schema.TaggedStruct<"DOMSpecError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An invalid [`DOMOutputSpec`](#DOMOutputSpec) was passed to the DOM
+ * serializer (for example a misplaced content hole, or an array taken
+ * from an attribute value).
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class DOMSpecError extends DOMSpecError_base {}
+/**
+ * Union of all errors produced by the model.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export type ModelError = PositionError | ReplaceError | ContentError | AttributeError | SchemaDefinitionError | JSONError | DOMSpecError;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+export declare const isModelError: (u: unknown) => u is ModelError;
+export {};

package/dist/model/errors.js

@@ -0,0 +1,76 @@
+import * as Predicate from "effect/Predicate";
+import * as HashSet from "effect/HashSet";
+import * as Schema from "effect/Schema";
+// src/model/errors.ts
+/**
+* Tagged errors raised by the document model.
+*
+* Every fallible operation in `@thomasfosterau/effect-richtext/model` reports failure
+* through the Effect error channel using one of these errors. The
+* `*Unsafe` variants of those operations throw the same error values
+* instead, which makes them usable from synchronous code.
+*
+* @since 0.1.0
+*/
+/**
+* A position or index was outside of the valid range of a node or
+* fragment.
+*
+* @since 0.1.0
+* @category errors
+*/
+var PositionError = class extends Schema.TaggedError()("PositionError", { message: Schema.String }) {};
+/**
+* Raised when a [`Slice`](#Slice) cannot be fitted into a document,
+* typically by `Node.replace`.
+*
+* @since 0.1.0
+* @category errors
+*/
+var ReplaceError = class extends Schema.TaggedError()("ReplaceError", { message: Schema.String }) {};
+/**
+* Content that does not satisfy a node type's content expression or
+* mark restrictions.
+*
+* @since 0.1.0
+* @category errors
+*/
+var ContentError = class extends Schema.TaggedError()("ContentError", { message: Schema.String }) {};
+/**
+* Missing, unknown, or invalid node or mark attributes.
+*
+* @since 0.1.0
+* @category errors
+*/
+var AttributeError = class extends Schema.TaggedError()("AttributeError", { message: Schema.String }) {};
+/**
+* A schema definition (or a content expression in it) is invalid.
+*
+* @since 0.1.0
+* @category errors
+*/
+var SchemaDefinitionError = class extends Schema.TaggedError()("SchemaDefinitionError", { message: Schema.String }) {};
+/**
+* Raised when deserializing JSON that does not describe a valid
+* document structure for the schema.
+*
+* @since 0.1.0
+* @category errors
+*/
+var JSONError = class extends Schema.TaggedError()("JSONError", { message: Schema.String }) {};
+/**
+* An invalid [`DOMOutputSpec`](#DOMOutputSpec) was passed to the DOM
+* serializer (for example a misplaced content hole, or an array taken
+* from an attribute value).
+*
+* @since 0.1.0
+* @category errors
+*/
+var DOMSpecError = class extends Schema.TaggedError()("DOMSpecError", { message: Schema.String }) {};
+const modelErrorTags = HashSet.make("PositionError", "ReplaceError", "ContentError", "AttributeError", "SchemaDefinitionError", "JSONError", "DOMSpecError");
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isModelError = (u) => Predicate.isObjectOrArray(u) && HashSet.has(modelErrorTags, u._tag);
+export { AttributeError, ContentError, DOMSpecError, JSONError, PositionError, ReplaceError, SchemaDefinitionError, isModelError };

package/dist/model/fragment.d.ts

@@ -0,0 +1,131 @@
+import { PositionError } from "./errors.js";
+import { Node, NodeJSON } from "./node.js";
+import { AnySchema, NodeNames } from "./schema.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+/**
+ * Callback used by `nodesBetween` and `descendants`. Return `false` to
+ * prevent descending into a node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type NodeVisitor<Sc extends AnySchema = AnySchema> = (node: Node<Sc>, pos: number, parent: Option.Option<Node<Sc>>, index: number) => boolean | void;
+/**
+ * A fragment represents a node's collection of child nodes.
+ *
+ * Like nodes, fragments are persistent data structures, and you should
+ * not mutate them or their content. Rather, you create new instances
+ * whenever needed.
+ *
+ * Fragments implement `Equal` (structural equality) and are iterable.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Fragment<Sc extends AnySchema = AnySchema, out N extends NodeNames<Sc> = NodeNames<Sc>> implements Equal.Equal, Iterable<Node<Sc, N>> {
+  /** The child nodes in this fragment. */
+  readonly content: ReadonlyArray<Node<Sc, N>>;
+  /** The size of the fragment, which is the total of the size of its content nodes. */
+  readonly size: number;
+  /** @internal */
+  constructor(
+  /** The child nodes in this fragment. */
+  content: ReadonlyArray<Node<Sc, N>>, size?: number);
+  [Symbol.iterator](): Iterator<Node<Sc, N>>;
+  /**
+   * Invoke a callback for all descendant nodes between the given two
+   * positions (relative to start of this fragment). Doesn't descend
+   * into a node when the callback returns `false`.
+   */
+  nodesBetween(from: number, to: number, f: NodeVisitor<Sc>, nodeStart?: number, parent?: Node<Sc>): void;
+  /**
+   * Call the given callback for every descendant node. `pos` will be
+   * relative to the start of the fragment. The callback may return
+   * `false` to prevent traversal of a given node's children.
+   */
+  descendants(f: NodeVisitor<Sc>): void;
+  /** Extract the text between `from` and `to`. See `Node.textBetween`. */
+  textBetween(from: number, to: number, blockSeparator?: string | null, leafText?: string | null | ((leafNode: Node<Sc>) => string)): string;
+  /** Create a new fragment containing the combined content of this fragment and the other. */
+  append<N2 extends NodeNames<Sc>>(other: Fragment<Sc, N2>): Fragment<Sc, N | N2>;
+  /** Cut out the sub-fragment between the two given positions. */
+  cut(from: number, to?: number): Fragment<Sc, N>;
+  /** @internal */
+  cutByIndex(from: number, to: number): Fragment<Sc, N>;
+  /** Create a new fragment in which the node at the given index is replaced by the given node. */
+  replaceChild<N2 extends NodeNames<Sc>>(index: number, node: Node<Sc, N2>): Fragment<Sc, N | N2>;
+  /** Create a new fragment by prepending the given node to this fragment. */
+  addToStart<N2 extends NodeNames<Sc>>(node: Node<Sc, N2>): Fragment<Sc, N | N2>;
+  /** Create a new fragment by appending the given node to this fragment. */
+  addToEnd<N2 extends NodeNames<Sc>>(node: Node<Sc, N2>): Fragment<Sc, N | N2>;
+  /** Compare this fragment to another one. */
+  eq(other: Fragment<any, any>): boolean;
+  /** @internal */
+  [Equal.symbol](that: Equal.Equal): boolean;
+  /** @internal */
+  [Hash.symbol](): number;
+  /** The first child of the fragment, if any. */
+  get firstChild(): Option.Option<Node<Sc, N>>;
+  /** The last child of the fragment, if any. */
+  get lastChild(): Option.Option<Node<Sc, N>>;
+  /** The number of child nodes in this fragment. */
+  get childCount(): number;
+  /** Get the child node at the given index. Fails with a `PositionError` when the index is out of range. */
+  child(index: number): Effect.Effect<Node<Sc, N>, PositionError>;
+  /** Like `child`, but throws a `PositionError` when the index is out of range. */
+  childUnsafe(index: number): Node<Sc, N>;
+  /** Get the child node at the given index, if it exists. */
+  maybeChild(index: number): Option.Option<Node<Sc, N>>;
+  /** Call `f` for every child node, passing the node, its offset into this parent node, and its index. */
+  forEach(f: (node: Node<Sc, N>, offset: number, index: number) => void): void;
+  /** Find the first position at which this fragment and another fragment differ, if any. */
+  findDiffStart(other: Fragment<any, any>, pos?: number): Option.Option<number>;
+  /**
+   * Find the first position, searching from the end, at which this
+   * fragment and the given fragment differ, if any. Since this
+   * position will not be the same in both nodes, an object with two
+   * separate positions is returned.
+   */
+  findDiffEnd(other: Fragment<any, any>, pos?: number, otherPos?: number): Option.Option<{
+    readonly a: number;
+    readonly b: number;
+  }>;
+  /**
+   * Find the index and inner offset corresponding to a given relative
+   * position in this fragment. The result object will be reused
+   * (overwritten) the next time the function is called.
+   *
+   * @internal
+   */
+  findIndex(pos: number): {
+    index: number;
+    offset: number;
+  };
+  /** Return a debugging string that describes this fragment. */
+  toString(): string;
+  /** @internal */
+  toStringInner(): string;
+  /** Create a JSON-serializable representation of this fragment. */
+  toJSON(): ReadonlyArray<NodeJSON> | null;
+  /**
+   * Build a fragment from an array of nodes. Ensures that adjacent text
+   * nodes with the same marks are joined together.
+   */
+  static fromArray<Sc extends AnySchema, N extends NodeNames<Sc>>(array: ReadonlyArray<Node<Sc, N>>): Fragment<Sc, N>;
+  /**
+   * Create a fragment from something that can be interpreted as a set
+   * of nodes. For `null`/`undefined`, it returns the empty fragment.
+   * For a fragment, the fragment itself. For a node or array of nodes,
+   * a fragment containing those nodes.
+   */
+  static from<Sc extends AnySchema, N extends NodeNames<Sc>>(nodes?: Fragment<Sc, N> | Node<Sc, N> | ReadonlyArray<Node<Sc, N>> | null): Fragment<Sc, N>;
+  /**
+   * An empty fragment. Intended to be reused whenever a node doesn't
+   * contain anything (rather than allocating a new empty fragment for
+   * each leaf node).
+   */
+  static readonly empty: Fragment<any, any>;
+}

package/dist/model/fragment.js

@@ -0,0 +1,262 @@
+import { attempt } from "../internal/attempt.js";
+import { findDiffEnd, findDiffStart } from "./diff.js";
+import { PositionError } from "./errors.js";
+import * as Option from "effect/Option";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+// src/model/fragment.ts
+const isPositionError = (u) => u instanceof PositionError;
+/**
+* A fragment represents a node's collection of child nodes.
+*
+* Like nodes, fragments are persistent data structures, and you should
+* not mutate them or their content. Rather, you create new instances
+* whenever needed.
+*
+* Fragments implement `Equal` (structural equality) and are iterable.
+*
+* @since 0.1.0
+* @category models
+*/
+var Fragment = class Fragment {
+	/** @internal */
+	constructor(content, size) {
+		this.content = content;
+		this.size = size || 0;
+		if (size == null) for (let i = 0; i < content.length; i++) this.size += content[i].nodeSize;
+	}
+	[Symbol.iterator]() {
+		return this.content[Symbol.iterator]();
+	}
+	/**
+	* Invoke a callback for all descendant nodes between the given two
+	* positions (relative to start of this fragment). Doesn't descend
+	* into a node when the callback returns `false`.
+	*/
+	nodesBetween(from, to, f, nodeStart = 0, parent) {
+		const parentOption = parent ? Option.some(parent) : Option.none();
+		for (let i = 0, pos = 0; pos < to; i++) {
+			const child = this.content[i], end = pos + child.nodeSize;
+			if (end > from && f(child, nodeStart + pos, parentOption, i) !== false && child.content.size) {
+				const start = pos + 1;
+				child.nodesBetween(Math.max(0, from - start), Math.min(child.content.size, to - start), f, nodeStart + start);
+			}
+			pos = end;
+		}
+	}
+	/**
+	* Call the given callback for every descendant node. `pos` will be
+	* relative to the start of the fragment. The callback may return
+	* `false` to prevent traversal of a given node's children.
+	*/
+	descendants(f) {
+		this.nodesBetween(0, this.size, f);
+	}
+	/** Extract the text between `from` and `to`. See `Node.textBetween`. */
+	textBetween(from, to, blockSeparator, leafText) {
+		let text = "", first = true;
+		this.nodesBetween(from, to, (node, pos) => {
+			const nodeText = node.isText ? node.text.slice(Math.max(from, pos) - pos, to - pos) : !node.isLeaf ? "" : leafText ? typeof leafText === "function" ? leafText(node) : leafText : node.type.spec.leafText ? node.type.spec.leafText(node) : "";
+			if (node.isBlock && (node.isLeaf && nodeText || node.isTextblock) && blockSeparator) {
+				if (first) first = false;
+				else text += blockSeparator;
+			}
+			text += nodeText;
+		}, 0);
+		return text;
+	}
+	/** Create a new fragment containing the combined content of this fragment and the other. */
+	append(other) {
+		if (!other.size) return this;
+		if (!this.size) return other;
+		const last = this.content[this.content.length - 1], first = other.content[0];
+		const content = this.content.slice();
+		let i = 0;
+		if (last.isText && last.sameMarkup(first)) {
+			content[content.length - 1] = last.withText(last.text + first.text);
+			i = 1;
+		}
+		for (; i < other.content.length; i++) content.push(other.content[i]);
+		return new Fragment(content, this.size + other.size);
+	}
+	/** Cut out the sub-fragment between the two given positions. */
+	cut(from, to = this.size) {
+		if (from === 0 && to === this.size) return this;
+		const result = [];
+		let size = 0;
+		if (to > from) for (let i = 0, pos = 0; pos < to; i++) {
+			let child = this.content[i];
+			const end = pos + child.nodeSize;
+			if (end > from) {
+				if (pos < from || end > to) {
+					if (child.isText) child = child.cut(Math.max(0, from - pos), Math.min(child.text.length, to - pos));
+					else child = child.cut(Math.max(0, from - pos - 1), Math.min(child.content.size, to - pos - 1));
+				}
+				result.push(child);
+				size += child.nodeSize;
+			}
+			pos = end;
+		}
+		return new Fragment(result, size);
+	}
+	/** @internal */
+	cutByIndex(from, to) {
+		if (from === to) return Fragment.empty;
+		if (from === 0 && to === this.content.length) return this;
+		return new Fragment(this.content.slice(from, to));
+	}
+	/** Create a new fragment in which the node at the given index is replaced by the given node. */
+	replaceChild(index, node) {
+		const current = this.content[index];
+		if (current === node) return this;
+		const copy = this.content.slice();
+		const size = this.size + node.nodeSize - current.nodeSize;
+		copy[index] = node;
+		return new Fragment(copy, size);
+	}
+	/** Create a new fragment by prepending the given node to this fragment. */
+	addToStart(node) {
+		return new Fragment([node].concat(this.content), this.size + node.nodeSize);
+	}
+	/** Create a new fragment by appending the given node to this fragment. */
+	addToEnd(node) {
+		return new Fragment(this.content.concat(node), this.size + node.nodeSize);
+	}
+	/** Compare this fragment to another one. */
+	eq(other) {
+		if (this.content.length !== other.content.length) return false;
+		for (let i = 0; i < this.content.length; i++) if (!this.content[i].eq(other.content[i])) return false;
+		return true;
+	}
+	/** @internal */
+	[Equal.symbol](that) {
+		return that instanceof Fragment && this.eq(that);
+	}
+	/** @internal */
+	[Hash.symbol]() {
+		return Hash.array(this.content);
+	}
+	/** The first child of the fragment, if any. */
+	get firstChild() {
+		return Option.fromUndefinedOr(this.content[0]);
+	}
+	/** The last child of the fragment, if any. */
+	get lastChild() {
+		return Option.fromUndefinedOr(this.content[this.content.length - 1]);
+	}
+	/** The number of child nodes in this fragment. */
+	get childCount() {
+		return this.content.length;
+	}
+	/** Get the child node at the given index. Fails with a `PositionError` when the index is out of range. */
+	child(index) {
+		return attempt(() => this.childUnsafe(index), isPositionError);
+	}
+	/** Like `child`, but throws a `PositionError` when the index is out of range. */
+	childUnsafe(index) {
+		const found = this.content[index];
+		if (!found) throw new PositionError({ message: "Index " + index + " out of range for " + this });
+		return found;
+	}
+	/** Get the child node at the given index, if it exists. */
+	maybeChild(index) {
+		return Option.fromUndefinedOr(this.content[index]);
+	}
+	/** Call `f` for every child node, passing the node, its offset into this parent node, and its index. */
+	forEach(f) {
+		for (let i = 0, p = 0; i < this.content.length; i++) {
+			const child = this.content[i];
+			f(child, p, i);
+			p += child.nodeSize;
+		}
+	}
+	/** Find the first position at which this fragment and another fragment differ, if any. */
+	findDiffStart(other, pos = 0) {
+		return Option.fromNullishOr(findDiffStart(this, other, pos));
+	}
+	/**
+	* Find the first position, searching from the end, at which this
+	* fragment and the given fragment differ, if any. Since this
+	* position will not be the same in both nodes, an object with two
+	* separate positions is returned.
+	*/
+	findDiffEnd(other, pos = this.size, otherPos = other.size) {
+		return Option.fromNullishOr(findDiffEnd(this, other, pos, otherPos));
+	}
+	/**
+	* Find the index and inner offset corresponding to a given relative
+	* position in this fragment. The result object will be reused
+	* (overwritten) the next time the function is called.
+	*
+	* @internal
+	*/
+	findIndex(pos) {
+		if (pos === 0) return retIndex(0, pos);
+		if (pos === this.size) return retIndex(this.content.length, pos);
+		if (pos > this.size || pos < 0) throw new PositionError({ message: `Position ${pos} outside of fragment (${this.toString()})` });
+		for (let i = 0, curPos = 0;; i++) {
+			const cur = this.content[i], end = curPos + cur.nodeSize;
+			if (end >= pos) {
+				if (end === pos) return retIndex(i + 1, end);
+				return retIndex(i, curPos);
+			}
+			curPos = end;
+		}
+	}
+	/** Return a debugging string that describes this fragment. */
+	toString() {
+		return "<" + this.toStringInner() + ">";
+	}
+	/** @internal */
+	toStringInner() {
+		return this.content.join(", ");
+	}
+	/** Create a JSON-serializable representation of this fragment. */
+	toJSON() {
+		return this.content.length ? this.content.map((n) => n.toJSON()) : null;
+	}
+	/**
+	* Build a fragment from an array of nodes. Ensures that adjacent text
+	* nodes with the same marks are joined together.
+	*/
+	static fromArray(array) {
+		if (!array.length) return Fragment.empty;
+		let joined;
+		let size = 0;
+		for (let i = 0; i < array.length; i++) {
+			const node = array[i];
+			size += node.nodeSize;
+			if (i && node.isText && array[i - 1].sameMarkup(node)) {
+				if (!joined) joined = array.slice(0, i);
+				joined[joined.length - 1] = node.withText(joined[joined.length - 1].text + node.text);
+			} else if (joined) joined.push(node);
+		}
+		return new Fragment(joined || array, size);
+	}
+	/**
+	* Create a fragment from something that can be interpreted as a set
+	* of nodes. For `null`/`undefined`, it returns the empty fragment.
+	* For a fragment, the fragment itself. For a node or array of nodes,
+	* a fragment containing those nodes.
+	*/
+	static from(nodes) {
+		if (!nodes) return Fragment.empty;
+		if (nodes instanceof Fragment) return nodes;
+		if (Array.isArray(nodes)) return this.fromArray(nodes);
+		if (nodes.attrs) return new Fragment([nodes], nodes.nodeSize);
+		throw new PositionError({ message: "Can not convert " + nodes + " to a Fragment" });
+	}
+	static {
+		this.empty = new Fragment([], 0);
+	}
+};
+const found = {
+	index: 0,
+	offset: 0
+};
+function retIndex(index, offset) {
+	found.index = index;
+	found.offset = offset;
+	return found;
+}
+export { Fragment };