@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/model/content.js

@@ -0,0 +1,630 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { SchemaDefinitionError } from "./errors.js";
+import { Fragment } from "./fragment.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Match from "effect/Match";
+import * as Order from "effect/Order";
+// src/model/content.ts
+/**
+* Content expressions describe which children a node type allows.
+*
+* Unlike ProseMirror, which uses a string mini-language
+* (`"paragraph+"`, `"heading block*"`), content is described with
+* typed combinators. The node and group names a combinator refers to
+* are tracked at the type level, so the schema knows which node types
+* may appear inside each node:
+*
+* ```ts skip-type-checking
+* import { Content } from "@thomasfosterau/effect-richtext/model"
+*
+* Content.seq("heading", Content.zeroOrMore("block"))
+* // ContentExpr<"heading" | "block">
+* ```
+*
+* `Content.parse` accepts the ProseMirror string syntax for
+* compatibility, at the cost of losing the type-level information.
+*
+* @since 0.1.0
+*/
+var content_exports = /* @__PURE__ */ __exportAll({
+	ContentMatch: () => ContentMatch,
+	choice: () => choice,
+	format: () => format,
+	isContentExpr: () => isContentExpr,
+	oneOrMore: () => oneOrMore,
+	optional: () => optional,
+	parse: () => parse,
+	ref: () => ref,
+	repeat: () => repeat,
+	seq: () => seq,
+	zeroOrMore: () => zeroOrMore
+});
+const TypeId = "~effect-richtext/model/ContentExpr";
+const variance = { _Refs: (_) => _ };
+const make = (ast) => ({
+	[TypeId]: variance,
+	ast
+});
+const toAST = (input) => Predicate.isString(input) ? {
+	_tag: "Name",
+	name: input
+} : input.ast;
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isContentExpr = (u) => Predicate.isObjectOrArray(u) && TypeId in u;
+/**
+* Reference a single node type or group by name.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const ref = (name) => make({
+	_tag: "Name",
+	name
+});
+/**
+* A sequence of expressions that must appear in order.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const seq = (...items) => items.length === 1 ? make(toAST(items[0])) : make({
+	_tag: "Seq",
+	exprs: items.map(toAST)
+});
+/**
+* Any one of the given expressions.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const choice = (...items) => items.length === 1 ? make(toAST(items[0])) : make({
+	_tag: "Choice",
+	exprs: items.map(toAST)
+});
+/**
+* Zero or more repetitions (`expr*`).
+*
+* @since 0.1.0
+* @category combinators
+*/
+const zeroOrMore = (item) => make({
+	_tag: "Star",
+	expr: toAST(item)
+});
+/**
+* One or more repetitions (`expr+`).
+*
+* @since 0.1.0
+* @category combinators
+*/
+const oneOrMore = (item) => make({
+	_tag: "Plus",
+	expr: toAST(item)
+});
+/**
+* Zero or one occurrence (`expr?`).
+*
+* @since 0.1.0
+* @category combinators
+*/
+const optional = (item) => make({
+	_tag: "Opt",
+	expr: toAST(item)
+});
+/**
+* Between `min` and `max` repetitions (`expr{min,max}`). When `max` is
+* omitted it defaults to `min`; pass `Infinity` for no upper bound.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const repeat = (item, min, max = min) => make({
+	_tag: "Range",
+	min,
+	max: max === Infinity ? -1 : max,
+	expr: toAST(item)
+});
+/**
+* Parse a ProseMirror-style content expression string, such as
+* `"paragraph block*"`. The referenced names are not tracked at the
+* type level.
+*
+* Syntax errors throw a `SchemaDefinitionError` immediately; unknown names
+* and other semantic errors are reported when the schema is compiled.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const parse = (source) => {
+	const stream = new TokenStream(source);
+	if (stream.next === void 0) return make({
+		_tag: "Seq",
+		exprs: []
+	});
+	const expr = parseExpr(stream);
+	if (stream.next !== void 0) stream.err("Unexpected trailing text");
+	return make(expr);
+};
+/**
+* Render a content expression in ProseMirror's string syntax.
+*
+* @since 0.1.0
+* @category utils
+*/
+const format = (expr) => formatAST(toAST(expr), 0);
+const formatAST = (ast, prec) => Match.valueTags(ast, {
+	Name: (ast) => ast.name,
+	Choice: (ast) => {
+		const s = ast.exprs.map((e) => formatAST(e, 1)).join(" | ");
+		return prec > 0 ? `(${s})` : s;
+	},
+	Seq: (ast) => {
+		const s = ast.exprs.map((e) => formatAST(e, 2)).join(" ");
+		return prec > 1 ? `(${s})` : s;
+	},
+	Plus: (ast) => formatAST(ast.expr, 3) + "+",
+	Star: (ast) => formatAST(ast.expr, 3) + "*",
+	Opt: (ast) => formatAST(ast.expr, 3) + "?",
+	Range: (ast) => formatAST(ast.expr, 3) + "{" + ast.min + (ast.max === ast.min ? "" : "," + (ast.max < 0 ? "" : ast.max)) + "}"
+});
+const isEmptyAST = (ast) => Predicate.isTagged(ast, "Seq") && Arr.isReadonlyArrayEmpty(ast.exprs);
+var TokenStream = class {
+	constructor(source) {
+		this.source = source;
+		this.pos = 0;
+		this.tokens = source.split(/\s*(?=\b|\W|$)/);
+		if (this.tokens[this.tokens.length - 1] === "") this.tokens.pop();
+		if (this.tokens[0] === "") this.tokens.shift();
+	}
+	get next() {
+		return this.tokens[this.pos];
+	}
+	eat(tok) {
+		if (this.next === tok) {
+			this.pos++;
+			return true;
+		}
+		return false;
+	}
+	err(str) {
+		throw new SchemaDefinitionError({ message: str + " (in content expression '" + this.source + "')" });
+	}
+};
+function parseExpr(stream) {
+	const exprs = [];
+	do
+		exprs.push(parseExprSeq(stream));
+	while (stream.eat("|"));
+	return exprs.length === 1 ? exprs[0] : {
+		_tag: "Choice",
+		exprs
+	};
+}
+function parseExprSeq(stream) {
+	const exprs = [];
+	do
+		exprs.push(parseExprSubscript(stream));
+	while (stream.next !== void 0 && stream.next !== ")" && stream.next !== "|");
+	return exprs.length === 1 ? exprs[0] : {
+		_tag: "Seq",
+		exprs
+	};
+}
+function parseExprSubscript(stream) {
+	let expr = parseExprAtom(stream);
+	for (;;) if (stream.eat("+")) expr = {
+		_tag: "Plus",
+		expr
+	};
+	else if (stream.eat("*")) expr = {
+		_tag: "Star",
+		expr
+	};
+	else if (stream.eat("?")) expr = {
+		_tag: "Opt",
+		expr
+	};
+	else if (stream.eat("{")) expr = parseExprRange(stream, expr);
+	else break;
+	return expr;
+}
+function parseNum(stream) {
+	const next = stream.next;
+	if (next === void 0 || /\D/.test(next)) stream.err("Expected number, got '" + next + "'");
+	stream.pos++;
+	return Number(next);
+}
+function parseExprRange(stream, expr) {
+	const min = parseNum(stream);
+	let max = min;
+	if (stream.eat(",")) {
+		if (stream.next !== "}") max = parseNum(stream);
+		else max = -1;
+	}
+	if (!stream.eat("}")) stream.err("Unclosed braced range");
+	return {
+		_tag: "Range",
+		min,
+		max,
+		expr
+	};
+}
+function parseExprAtom(stream) {
+	if (stream.eat("(")) {
+		const expr = parseExpr(stream);
+		if (!stream.eat(")")) stream.err("Missing closing paren");
+		return expr;
+	}
+	const next = stream.next;
+	if (next !== void 0 && !/\W/.test(next)) {
+		stream.pos++;
+		return {
+			_tag: "Name",
+			name: next
+		};
+	}
+	return stream.err("Unexpected token '" + next + "'");
+}
+/**
+* Instances of this class represent a match state of a node type's
+* content expression, and can be used to find out whether further
+* content matches here, and whether a given position is a valid end of
+* the node.
+*
+* @since 0.1.0
+* @category models
+*/
+var ContentMatch = class ContentMatch {
+	/** @internal */
+	constructor(validEnd) {
+		this.validEnd = validEnd;
+		this.next = [];
+		this.wrapCache = [];
+	}
+	/** @internal */
+	static compile(content, nodeTypes, typeName) {
+		if (content === void 0) return ContentMatch.empty;
+		const ast = Predicate.isString(content) ? parse(content).ast : content.ast;
+		if (isEmptyAST(ast)) return ContentMatch.empty;
+		const source = formatAST(ast, 0);
+		const match = dfa(nfa(resolve(ast, {
+			inline: null,
+			nodeTypes,
+			source,
+			typeName
+		})));
+		checkForDeadEnds(match, source);
+		return match;
+	}
+	/**
+	* Match a node type, returning a match after that node if
+	* successful.
+	*/
+	matchType(type) {
+		return Option.fromNullishOr(this.matchTypeOrNull(type));
+	}
+	/** @internal */
+	matchTypeOrNull(type) {
+		for (let i = 0; i < this.next.length; i++) if (this.next[i].type === type) return this.next[i].next;
+		return null;
+	}
+	/** Try to match a fragment. Returns the resulting match when successful. */
+	matchFragment(frag, start = 0, end = frag.childCount) {
+		return Option.fromNullishOr(this.matchFragmentOrNull(frag, start, end));
+	}
+	/** @internal */
+	matchFragmentOrNull(frag, start = 0, end = frag.childCount) {
+		if (start >= end) return this;
+		let cur = this.matchTypeOrNull(frag.content[start].type);
+		for (let i = start + 1; cur && i < end; i++) cur = cur.matchTypeOrNull(frag.content[i].type);
+		return cur;
+	}
+	/** @internal */
+	get inlineContent() {
+		return Arr.isReadonlyArrayNonEmpty(this.next) && this.next[0].type.isInline;
+	}
+	/** Get the first matching node type at this match position that can be generated. */
+	get defaultType() {
+		return Option.fromNullishOr(this.defaultTypeOrNull);
+	}
+	/** @internal */
+	get defaultTypeOrNull() {
+		for (let i = 0; i < this.next.length; i++) {
+			const { type } = this.next[i];
+			if (!(type.isText || type.hasRequiredAttrs())) return type;
+		}
+		return null;
+	}
+	/** @internal */
+	compatible(other) {
+		for (let i = 0; i < this.next.length; i++) for (let j = 0; j < other.next.length; j++) if (this.next[i].type === other.next[j].type) return true;
+		return false;
+	}
+	/**
+	* Try to match the given fragment, and if that fails, see if it can
+	* be made to match by inserting nodes in front of it. When
+	* successful, return a fragment of inserted nodes (which may be
+	* empty if nothing had to be inserted). When `toEnd` is true, only
+	* return a fragment if the resulting match goes to the end of the
+	* content expression.
+	*/
+	fillBefore(after, toEnd = false, startIndex = 0) {
+		return Option.fromNullishOr(this.fillBeforeOrNull(after, toEnd, startIndex));
+	}
+	/** @internal */
+	fillBeforeOrNull(after, toEnd = false, startIndex = 0) {
+		const seen = [this];
+		function search(match, types) {
+			const finished = match.matchFragmentOrNull(after, startIndex);
+			if (finished && (!toEnd || finished.validEnd)) return Fragment.fromArray(types.map((tp) => tp.createAndFillOrNull()));
+			for (let i = 0; i < match.next.length; i++) {
+				const { next, type } = match.next[i];
+				if (!(type.isText || type.hasRequiredAttrs()) && seen.indexOf(next) === -1) {
+					seen.push(next);
+					const found = search(next, types.concat(type));
+					if (found) return found;
+				}
+			}
+			return null;
+		}
+		return search(this, []);
+	}
+	/**
+	* Find a set of wrapping node types that would allow a node of the
+	* given type to appear at this position. The result may be empty
+	* (when it fits directly) and will be `None` when no such wrapping
+	* exists.
+	*/
+	findWrapping(target) {
+		return Option.fromNullishOr(this.findWrappingOrNull(target));
+	}
+	/** @internal */
+	findWrappingOrNull(target) {
+		for (let i = 0; i < this.wrapCache.length; i += 2) if (this.wrapCache[i] === target) return this.wrapCache[i + 1];
+		const computed = this.computeWrapping(target);
+		this.wrapCache.push(target, computed);
+		return computed;
+	}
+	/** @internal */
+	computeWrapping(target) {
+		const seen = Object.create(null);
+		const active = [{
+			match: this,
+			type: null,
+			via: null
+		}];
+		while (active.length) {
+			const current = active.shift();
+			const match = current.match;
+			if (match.matchTypeOrNull(target)) {
+				const result = [];
+				for (let obj = current; obj.type; obj = obj.via) result.push(obj.type);
+				return result.reverse();
+			}
+			for (let i = 0; i < match.next.length; i++) {
+				const { next, type } = match.next[i];
+				if (!type.isLeaf && !type.hasRequiredAttrs() && !(type.name in seen) && (!current.type || next.validEnd)) {
+					active.push({
+						match: type.contentMatch,
+						type,
+						via: current
+					});
+					seen[type.name] = true;
+				}
+			}
+		}
+		return null;
+	}
+	/** The number of outgoing edges this node has in the content automaton. */
+	get edgeCount() {
+		return this.next.length;
+	}
+	/** Get the _n_th outgoing edge from this node in the content automaton. */
+	edge(n) {
+		return Option.fromNullishOr(this.next[n]);
+	}
+	/** @internal */
+	toString() {
+		const seen = [];
+		function scan(m) {
+			seen.push(m);
+			for (let i = 0; i < m.next.length; i++) if (seen.indexOf(m.next[i].next) === -1) scan(m.next[i].next);
+		}
+		scan(this);
+		return seen.map((m, i) => {
+			let out = i + (m.validEnd ? "*" : " ") + " ";
+			for (let i = 0; i < m.next.length; i++) out += (i ? ", " : "") + m.next[i].type.name + "->" + seen.indexOf(m.next[i].next);
+			return out;
+		}).join("\n");
+	}
+	static {
+		this.empty = new ContentMatch(true);
+	}
+};
+const fail = (ctx, message) => {
+	throw new SchemaDefinitionError({ message: `${message} (in content expression '${ctx.source}' of node type '${ctx.typeName}')` });
+};
+function resolveName(ctx, name) {
+	const types = ctx.nodeTypes;
+	const type = types[name];
+	if (type) return [type];
+	const result = [];
+	for (const typeName in types) {
+		const type = types[typeName];
+		if (type.isInGroup(name)) result.push(type);
+	}
+	if (Arr.isArrayEmpty(result)) fail(ctx, "No node type or group '" + name + "' found");
+	return result;
+}
+function resolve(ast, ctx) {
+	return Match.valueTags(ast, {
+		Name: (ast) => {
+			const exprs = resolveName(ctx, ast.name).map((type) => {
+				if (ctx.inline === null) ctx.inline = type.isInline;
+				else if (ctx.inline !== type.isInline) fail(ctx, "Mixing inline and block content");
+				return {
+					type: "name",
+					value: type
+				};
+			});
+			return exprs.length === 1 ? exprs[0] : {
+				type: "choice",
+				exprs
+			};
+		},
+		Choice: (ast) => ({
+			type: "choice",
+			exprs: ast.exprs.map((e) => resolve(e, ctx))
+		}),
+		Seq: (ast) => ({
+			type: "seq",
+			exprs: ast.exprs.map((e) => resolve(e, ctx))
+		}),
+		Plus: (ast) => ({
+			type: "plus",
+			expr: resolve(ast.expr, ctx)
+		}),
+		Star: (ast) => ({
+			type: "star",
+			expr: resolve(ast.expr, ctx)
+		}),
+		Opt: (ast) => ({
+			type: "opt",
+			expr: resolve(ast.expr, ctx)
+		}),
+		Range: (ast) => {
+			if (ast.min < 0 || ast.max >= 0 && ast.max < ast.min || !Number.isInteger(ast.min)) fail(ctx, `Invalid repetition range {${ast.min},${ast.max}}`);
+			return {
+				type: "range",
+				min: ast.min,
+				max: ast.max,
+				expr: resolve(ast.expr, ctx)
+			};
+		}
+	});
+}
+function nfa(expr) {
+	const nfa = [[]];
+	connect(compile(expr, 0), node());
+	return nfa;
+	function node() {
+		return nfa.push([]) - 1;
+	}
+	function edge(from, to, term) {
+		const edge = {
+			term,
+			to
+		};
+		nfa[from].push(edge);
+		return edge;
+	}
+	function connect(edges, to) {
+		edges.forEach((edge) => edge.to = to);
+	}
+	function compile(expr, from) {
+		return Match.value(expr).pipe(Match.discriminatorsExhaustive("type")({
+			choice: (expr) => expr.exprs.reduce((out, expr) => out.concat(compile(expr, from)), []),
+			seq: (expr) => {
+				if (Arr.isReadonlyArrayEmpty(expr.exprs)) return [edge(from)];
+				let cur = from;
+				for (let i = 0;; i++) {
+					const next = compile(expr.exprs[i], cur);
+					if (i === expr.exprs.length - 1) return next;
+					connect(next, cur = node());
+				}
+			},
+			star: (expr) => {
+				const loop = node();
+				edge(from, loop);
+				connect(compile(expr.expr, loop), loop);
+				return [edge(loop)];
+			},
+			plus: (expr) => {
+				const loop = node();
+				connect(compile(expr.expr, from), loop);
+				connect(compile(expr.expr, loop), loop);
+				return [edge(loop)];
+			},
+			opt: (expr) => [edge(from)].concat(compile(expr.expr, from)),
+			range: (expr) => {
+				let cur = from;
+				for (let i = 0; i < expr.min; i++) {
+					const next = node();
+					connect(compile(expr.expr, cur), next);
+					cur = next;
+				}
+				if (expr.max === -1) connect(compile(expr.expr, cur), cur);
+				else for (let i = expr.min; i < expr.max; i++) {
+					const next = node();
+					edge(cur, next);
+					connect(compile(expr.expr, cur), next);
+					cur = next;
+				}
+				return [edge(cur)];
+			},
+			name: (expr) => [edge(from, void 0, expr.value)]
+		}));
+	}
+}
+const descending = Order.flip(Order.Number);
+function nullFrom(nfa, node) {
+	const result = [];
+	scan(node);
+	return Arr.sort(result, descending);
+	function scan(node) {
+		const edges = nfa[node];
+		if (edges.length === 1 && !edges[0].term) return scan(edges[0].to);
+		result.push(node);
+		for (let i = 0; i < edges.length; i++) {
+			const { term, to } = edges[i];
+			if (!term && result.indexOf(to) === -1) scan(to);
+		}
+	}
+}
+function dfa(nfa) {
+	const labeled = Object.create(null);
+	return explore(nullFrom(nfa, 0));
+	function explore(states) {
+		const out = [];
+		states.forEach((node) => {
+			nfa[node].forEach(({ term, to }) => {
+				if (!term) return;
+				let set;
+				for (let i = 0; i < out.length; i++) if (out[i][0] === term) set = out[i][1];
+				nullFrom(nfa, to).forEach((node) => {
+					if (!set) out.push([term, set = []]);
+					if (set.indexOf(node) === -1) set.push(node);
+				});
+			});
+		});
+		const state = labeled[states.join(",")] = new ContentMatch(states.indexOf(nfa.length - 1) > -1);
+		for (let i = 0; i < out.length; i++) {
+			const states = Arr.sort(out[i][1], descending);
+			state.next.push({
+				type: out[i][0],
+				next: labeled[states.join(",")] || explore(states)
+			});
+		}
+		return state;
+	}
+}
+function checkForDeadEnds(match, source) {
+	for (let i = 0, work = [match]; i < work.length; i++) {
+		const state = work[i];
+		let dead = !state.validEnd;
+		const nodes = [];
+		for (let j = 0; j < state.next.length; j++) {
+			const { next, type } = state.next[j];
+			nodes.push(type.name);
+			if (dead && !(type.isText || type.hasRequiredAttrs())) dead = false;
+			if (work.indexOf(next) === -1) work.push(next);
+		}
+		if (dead) throw new SchemaDefinitionError({ message: "Only non-generatable nodes (" + nodes.join(", ") + ") in a required position (see https://prosemirror.net/docs/guide/#generatable) (in content expression '" + source + "')" });
+	}
+}
+export { ContentMatch, choice, content_exports, format, isContentExpr, oneOrMore, optional, parse, ref, repeat, seq, zeroOrMore };

package/dist/model/diff.js

@@ -0,0 +1,66 @@
+// src/model/diff.ts
+/** @internal */
+function findDiffStart(a, b, pos) {
+	for (let i = 0;; i++) {
+		if (i === a.childCount || i === b.childCount) return a.childCount === b.childCount ? null : pos;
+		const childA = a.content[i], childB = b.content[i];
+		if (childA === childB) {
+			pos += childA.nodeSize;
+			continue;
+		}
+		if (!childA.sameMarkup(childB)) return pos;
+		if (childA.isText && childA.text !== childB.text) return pos + sameTextStart(childA.text, childB.text);
+		if (childA.content.size || childB.content.size) {
+			const inner = findDiffStart(childA.content, childB.content, pos + 1);
+			if (inner != null) return inner;
+		}
+		pos += childA.nodeSize;
+	}
+}
+/** @internal */
+function findDiffEnd(a, b, posA, posB) {
+	for (let iA = a.childCount, iB = b.childCount;;) {
+		if (iA === 0 || iB === 0) return iA === iB ? null : {
+			a: posA,
+			b: posB
+		};
+		const childA = a.content[--iA], childB = b.content[--iB], size = childA.nodeSize;
+		if (childA === childB) {
+			posA -= size;
+			posB -= size;
+			continue;
+		}
+		if (!childA.sameMarkup(childB)) return {
+			a: posA,
+			b: posB
+		};
+		if (childA.isText && childA.text !== childB.text) {
+			const same = sameTextEnd(childA.text, childB.text);
+			return {
+				a: posA - same,
+				b: posB - same
+			};
+		}
+		if (childA.content.size || childB.content.size) {
+			const inner = findDiffEnd(childA.content, childB.content, posA - 1, posB - 1);
+			if (inner) return inner;
+		}
+		posA -= size;
+		posB -= size;
+	}
+}
+function sameTextStart(ta, tb) {
+	let j = 0;
+	while (ta[j] === tb[j]) j++;
+	return j && j < ta.length && j < tb.length && splitsPair(ta, j) ? j - 1 : j;
+}
+function sameTextEnd(ta, tb) {
+	let same = 0;
+	while (same < ta.length && same < tb.length && ta[ta.length - same - 1] === tb[tb.length - same - 1]) same++;
+	const end = ta.length - same;
+	return end && same && same < tb.length && splitsPair(ta, end) ? same - 1 : same;
+}
+const splitsPair = (text, i) => surrogateHigh(text.charCodeAt(i - 1)) && surrogateLow(text.charCodeAt(i));
+const surrogateLow = (ch) => ch >= 56320 && ch < 57344;
+const surrogateHigh = (ch) => ch >= 55296 && ch < 56320;
+export { findDiffEnd, findDiffStart };

package/dist/model/dom.d.ts

@@ -0,0 +1,3 @@
+import { ParseRule, TagParseRule } from "./from_dom.js";
+import { DOMOutputSpec } from "./to_dom.js";
+export type { DOMOutputSpec, ParseRule, TagParseRule };