@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/markdown/to_markdown.js

@@ -0,0 +1,413 @@
+import { Mark } from "../model/mark.js";
+import { MarkdownError } from "./errors.js";
+import * as Arr from "effect/Array";
+import * as Order from "effect/Order";
+// src/markdown/to_markdown.ts
+/**
+* Serializing documents to Markdown.
+*
+* @since 0.1.0
+*/
+const blankMark = {
+	open: "",
+	close: "",
+	mixable: true
+};
+/**
+* A specification for serializing a document as Markdown/CommonMark
+* text.
+*
+* @since 0.1.0
+* @category models
+*/
+var MarkdownSerializer = class {
+	/**
+	* Construct a serializer with the given configuration. The `nodes`
+	* object should map node names in a given schema to function that
+	* take a serializer state and such a node, and serialize the node.
+	*/
+	constructor(nodes, marks, options = {}) {
+		this.nodes = nodes;
+		this.marks = marks;
+		this.options = options;
+	}
+	/**
+	* Serialize the content of the given node to
+	* [CommonMark](http://commonmark.org/).
+	*
+	* Serialization can't fail for nodes that the serializer knows; in
+	* strict mode (the default) an unknown node or mark type is a
+	* programming error and throws a `MarkdownError`.
+	*/
+	serialize(content, options = {}) {
+		const state = new MarkdownSerializerState(this.nodes, this.marks, {
+			...this.options,
+			...options
+		});
+		state.renderContent(content);
+		return state.out;
+	}
+};
+function backticksFor(node, side) {
+	const ticks = /`+/g;
+	let m, len = 0;
+	if (node.isText) while (m = ticks.exec(node.text)) len = Math.max(len, m[0].length);
+	let result = len > 0 && side > 0 ? " `" : "`";
+	for (let i = 0; i < len; i++) result += "`";
+	if (len > 0 && side < 0) result += " ";
+	return result;
+}
+function isPlainURL(link, parent, index) {
+	if (link.attrs.title || !/^\w+:/.test(link.attrs.href)) return false;
+	const content = parent.childUnsafe(index);
+	if (!content.isText || content.text != link.attrs.href || content.marks[content.marks.length - 1] != link) return false;
+	return index == parent.childCount - 1 || !link.isInSet(parent.childUnsafe(index + 1).marks);
+}
+/**
+* A serializer for the Markdown schema (or any schema using the same
+* node and mark names).
+*
+* @since 0.1.0
+* @category serializers
+*/
+const defaultMarkdownSerializer = new MarkdownSerializer({
+	blockquote(state, node) {
+		state.wrapBlock("> ", null, node, () => state.renderContent(node));
+	},
+	code_block(state, node) {
+		const backticks = node.textContent.match(/`{3,}/gm);
+		const fence = backticks ? Arr.sort(backticks, Order.String).slice(-1)[0] + "`" : "```";
+		state.write(fence + (node.attrs.params || "") + "\n");
+		state.text(node.textContent, false);
+		state.write("\n");
+		state.write(fence);
+		state.closeBlock(node);
+	},
+	heading(state, node) {
+		state.write(state.repeat("#", node.attrs.level) + " ");
+		state.renderInline(node, false);
+		state.closeBlock(node);
+	},
+	horizontal_rule(state, node) {
+		state.write(node.attrs.markup || "---");
+		state.closeBlock(node);
+	},
+	bullet_list(state, node) {
+		state.renderList(node, "  ", () => (node.attrs.bullet || "*") + " ");
+	},
+	ordered_list(state, node) {
+		const start = node.attrs.order ?? 1;
+		const maxW = String(start + node.childCount - 1).length;
+		const space = state.repeat(" ", maxW + 2);
+		state.renderList(node, space, (i) => {
+			const nStr = String(start + i);
+			return state.repeat(" ", maxW - nStr.length) + nStr + ". ";
+		});
+	},
+	list_item(state, node) {
+		state.renderContent(node);
+	},
+	paragraph(state, node) {
+		state.renderInline(node);
+		state.closeBlock(node);
+	},
+	image(state, node) {
+		state.write("![" + state.esc(node.attrs.alt || "") + "](" + node.attrs.src.replace(/[()]/g, "\\$&") + (node.attrs.title ? " \"" + node.attrs.title.replace(/"/g, "\\\"") + "\"" : "") + ")");
+	},
+	hard_break(state, node, parent, index) {
+		for (let i = index + 1; i < parent.childCount; i++) if (parent.childUnsafe(i).type != node.type) {
+			state.write("\\\n");
+			return;
+		}
+	},
+	text(state, node) {
+		state.text(node.text, !state.inAutolink);
+	}
+}, {
+	em: {
+		open: "*",
+		close: "*",
+		mixable: true,
+		expelEnclosingWhitespace: true
+	},
+	strong: {
+		open: "**",
+		close: "**",
+		mixable: true,
+		expelEnclosingWhitespace: true
+	},
+	link: {
+		open(state, mark, parent, index) {
+			state.inAutolink = isPlainURL(mark, parent, index);
+			return state.inAutolink ? "<" : "[";
+		},
+		close(state, mark) {
+			const { inAutolink } = state;
+			state.inAutolink = void 0;
+			return inAutolink ? ">" : "](" + mark.attrs.href.replace(/[()"]/g, "\\$&") + (mark.attrs.title ? ` "${mark.attrs.title.replace(/"/g, "\\\"")}"` : "") + ")";
+		},
+		mixable: true
+	},
+	code: {
+		open(_state, _mark, parent, index) {
+			return backticksFor(parent.childUnsafe(index), -1);
+		},
+		close(_state, _mark, parent, index) {
+			return backticksFor(parent.childUnsafe(index - 1), 1);
+		},
+		escape: false
+	}
+});
+/**
+* This is an object used to track state and expose methods related to
+* markdown serialization. Instances are passed to node and mark
+* serialization methods.
+*
+* @since 0.1.0
+* @category models
+*/
+var MarkdownSerializerState = class {
+	/** @internal */
+	constructor(nodes, marks, options) {
+		this.nodes = nodes;
+		this.marks = marks;
+		this.delim = "";
+		this.out = "";
+		this.closed = null;
+		this.inAutolink = void 0;
+		this.atBlockStart = false;
+		this.inTightList = false;
+		this.options = {
+			...options,
+			tightLists: options.tightLists ?? false,
+			hardBreakNodeName: options.hardBreakNodeName ?? "hard_break"
+		};
+	}
+	/** @internal */
+	flushClose(size = 2) {
+		if (this.closed) {
+			if (!this.atBlank()) this.out += "\n";
+			if (size > 1) {
+				let delimMin = this.delim;
+				const trim = /\s+$/.exec(delimMin);
+				if (trim) delimMin = delimMin.slice(0, delimMin.length - trim[0].length);
+				for (let i = 1; i < size; i++) this.out += delimMin + "\n";
+			}
+			this.closed = null;
+		}
+	}
+	/** @internal */
+	getMark(name) {
+		let info = this.marks[name];
+		if (!info) {
+			if (this.options.strict !== false) throw new MarkdownError({ message: `Mark type \`${name}\` not supported by Markdown renderer` });
+			info = blankMark;
+		}
+		return info;
+	}
+	/**
+	* Render a block, prefixing each line with `delim`, and the first line
+	* in `firstDelim`. `node` should be the node that is closed at the end
+	* of the block, and `f` is a function that renders the content of the
+	* block.
+	*/
+	wrapBlock(delim, firstDelim, node, f) {
+		const old = this.delim;
+		this.write(firstDelim != null ? firstDelim : delim);
+		this.delim += delim;
+		f();
+		this.delim = old;
+		this.closeBlock(node);
+	}
+	/** @internal */
+	atBlank() {
+		return !this.out || this.out[this.out.length - 1] == "\n";
+	}
+	/** Ensure the current content ends with a newline. */
+	ensureNewLine() {
+		if (!this.atBlank()) this.out += "\n";
+	}
+	/**
+	* Prepare the state for writing output (closing closed paragraphs,
+	* adding delimiters, and so on), and then optionally add content
+	* (unescaped) to the output.
+	*/
+	write(content) {
+		this.flushClose();
+		if (this.delim && this.atBlank()) this.out += this.delim;
+		if (content) this.out += content;
+	}
+	/** Close the block for the given node. */
+	closeBlock(node) {
+		this.closed = node;
+	}
+	/** Add the given text to the document. When escape is not `false`, it will be escaped. */
+	text(text, escape = true) {
+		const lines = text.split("\n");
+		for (let i = 0; i < lines.length; i++) {
+			this.write();
+			if (!escape && lines[i][0] == "[" && /(^|[^\\])!$/.test(this.out.slice(-2))) this.out = this.out.slice(0, this.out.length - 1) + "\\!";
+			this.out += escape ? this.esc(lines[i], this.atBlockStart) : lines[i];
+			if (i != lines.length - 1) this.out += "\n";
+		}
+	}
+	/**
+	* Render the given node as a block. In strict mode, throws a
+	* `MarkdownError` for node types without a serializer.
+	*/
+	render(node, parent, index) {
+		const serializer = this.nodes[node.type.name];
+		if (serializer) serializer(this, node, parent, index);
+		else if (this.options.strict !== false) throw new MarkdownError({ message: "Token type `" + node.type.name + "` not supported by Markdown renderer" });
+		else if (!node.type.isLeaf) {
+			if (node.type.inlineContent) this.renderInline(node);
+			else this.renderContent(node);
+			if (node.isBlock) this.closeBlock(node);
+		}
+	}
+	/** Render the contents of `parent` as block nodes. */
+	renderContent(parent) {
+		parent.forEach((node, _, i) => this.render(node, parent, i));
+	}
+	/** Render the contents of `parent` as inline content. */
+	renderInline(parent, fromBlockStart = true) {
+		this.atBlockStart = fromBlockStart;
+		const active = [];
+		let trailing = "";
+		const progress = (node, _offset, index) => {
+			let marks = node ? node.marks : [];
+			if (node && node.type.name === this.options.hardBreakNodeName) marks = marks.filter((m) => {
+				if (index + 1 == parent.childCount) return false;
+				const next = parent.childUnsafe(index + 1);
+				return m.isInSet(next.marks) && (!next.isText || /\S/.test(next.text));
+			});
+			const inner = marks.length ? marks[marks.length - 1] : null;
+			const noEsc = inner && this.getMark(inner.type.name).escape === false;
+			const len = marks.length - (noEsc ? 1 : 0);
+			outer: for (let i = 0; i < len; i++) {
+				const mark = marks[i];
+				if (!this.getMark(mark.type.name).mixable) break;
+				for (let j = 0; j < active.length; j++) {
+					const other = active[j];
+					if (!this.getMark(other.type.name).mixable) break;
+					if (mark.eq(other)) {
+						if (i > j) marks = marks.slice(0, j).concat(mark).concat(marks.slice(j, i)).concat(marks.slice(i + 1, len));
+						else if (j > i) marks = marks.slice(0, i).concat(marks.slice(i + 1, j)).concat(mark).concat(marks.slice(j, len));
+						continue outer;
+					}
+				}
+			}
+			let keep = 0;
+			while (keep < Math.min(active.length, len) && marks[keep].eq(active[keep])) ++keep;
+			let leading = trailing;
+			trailing = "";
+			if (node && node.isText && marks.some((mark) => {
+				const info = this.getMark(mark.type.name);
+				return info && info.expelEnclosingWhitespace && !active.some((m, i) => i < keep && m.eq(mark));
+			})) {
+				const [_, lead, rest] = /^(\s*)(.*)$/m.exec(node.text);
+				if (lead) {
+					leading += lead;
+					node = rest ? node.withText(rest) : null;
+					if (!node) marks = active;
+				}
+			}
+			if (node && node.isText && marks.some((mark, i) => {
+				const info = this.getMark(mark.type.name);
+				return info && info.expelEnclosingWhitespace && !this.isMarkAhead(parent, index + 1, marks.slice(0, i + 1));
+			})) {
+				const [_, rest, trail] = /^(.*?)(\s*)$/m.exec(node.text);
+				if (trail) {
+					trailing = trail;
+					node = rest ? node.withText(rest) : null;
+					if (!node) marks = active;
+				}
+			}
+			if (node || index == parent.childCount) while (keep < active.length) this.text(this.markString(active.pop(), false, parent, index), false);
+			if (leading) this.text(leading);
+			if (node) {
+				while (active.length < len) {
+					const add = marks[active.length];
+					active.push(add);
+					this.text(this.markString(add, true, parent, index), false);
+					this.atBlockStart = false;
+				}
+				if (noEsc && node.isText) this.text(this.markString(inner, true, parent, index) + node.text + this.markString(inner, false, parent, index + 1), false);
+				else this.render(node, parent, index);
+				this.atBlockStart = false;
+				if (node.isText && node.nodeSize > 0) this.atBlockStart = false;
+			}
+		};
+		parent.forEach(progress);
+		progress(null, 0, parent.childCount);
+		this.atBlockStart = false;
+	}
+	/**
+	* Render a node's content as a list. `delim` should be the extra
+	* indentation added to all lines except the first in an item,
+	* `firstDelim` is a function going from an item index to a delimiter
+	* for the first line of the item.
+	*/
+	renderList(node, delim, firstDelim) {
+		if (this.closed && this.closed.type == node.type) this.flushClose(3);
+		else if (this.inTightList) this.flushClose(1);
+		const attrs = node.attrs;
+		const isTight = typeof attrs.tight != "undefined" ? attrs.tight : this.options.tightLists;
+		const prevTight = this.inTightList;
+		this.inTightList = isTight;
+		node.forEach((child, _, i) => {
+			if (i && isTight) this.flushClose(1);
+			this.wrapBlock(delim, firstDelim(i), node, () => this.render(child, node, i));
+		});
+		this.inTightList = prevTight;
+	}
+	/**
+	* Escape the given string so that it can safely appear in Markdown
+	* content. If `startOfLine` is true, also escape characters that have
+	* special meaning only at the start of the line.
+	*/
+	esc(str, startOfLine = false) {
+		str = str.replace(/[`*\\~[\]_]/g, (m, i) => m == "_" && i > 0 && i + 1 < str.length && str[i - 1].match(/\w/) && str[i + 1].match(/\w/) ? m : "\\" + m);
+		if (startOfLine) str = str.replace(/^(\+[ ]|[-*>])/, "\\$&").replace(/^(\s*)(#{1,6})(\s|$)/, "$1\\$2$3").replace(/^(\s*\d+)\.\s/, "$1\\. ");
+		if (this.options.escapeExtraCharacters) str = str.replace(this.options.escapeExtraCharacters, "\\$&");
+		return str;
+	}
+	/** @internal */
+	quote(str) {
+		const wrap = str.indexOf("\"") == -1 ? "\"\"" : str.indexOf("'") == -1 ? "''" : "()";
+		return wrap[0] + str + wrap[1];
+	}
+	/** Repeat the given string `n` times. */
+	repeat(str, n) {
+		let out = "";
+		for (let i = 0; i < n; i++) out += str;
+		return out;
+	}
+	/** Get the markdown string for a given opening or closing mark. */
+	markString(mark, open, parent, index) {
+		const info = this.getMark(mark.type.name);
+		const value = open ? info.open : info.close;
+		return typeof value == "string" ? value : value(this, mark, parent, index);
+	}
+	/**
+	* Get leading and trailing whitespace from a string. Values of leading
+	* or trailing property of the return object will be undefined if there
+	* is no match.
+	*/
+	getEnclosingWhitespace(text) {
+		return {
+			leading: (text.match(/^(\s+)/) || [void 0])[0],
+			trailing: (text.match(/(\s+)$/) || [void 0])[0]
+		};
+	}
+	/** @internal */
+	isMarkAhead(parent, index, marks) {
+		for (;; index++) {
+			if (index >= parent.childCount) return false;
+			const next = parent.childUnsafe(index);
+			if (next.type.name != this.options.hardBreakNodeName) return next.marks.length >= marks.length && Mark.sameSet(next.marks.slice(0, marks.length), marks);
+			index++;
+		}
+	}
+};
+export { MarkdownSerializer, MarkdownSerializerState, defaultMarkdownSerializer };

package/dist/markdown.d.ts

@@ -0,0 +1,5 @@
+import { MarkdownError, isMarkdownError } from "./markdown/errors.js";
+import { MarkdownParseState, MarkdownParser, ParseSpec, TokenHandler, defaultMarkdownParser } from "./markdown/from_markdown.js";
+import { MarkdownSchema, marks, nodes, schema } from "./markdown/schema.js";
+import { MarkSerializerSpec, MarkdownSerializeOptions, MarkdownSerializer, MarkdownSerializerOptions, MarkdownSerializerState, MarkdownSerializerStateOptions, NodeSerializer, defaultMarkdownSerializer } from "./markdown/to_markdown.js";
+export { MarkSerializerSpec, MarkdownError, MarkdownParseState, MarkdownParser, MarkdownSchema, MarkdownSerializeOptions, MarkdownSerializer, MarkdownSerializerOptions, MarkdownSerializerState, MarkdownSerializerStateOptions, NodeSerializer, ParseSpec, TokenHandler, defaultMarkdownParser, defaultMarkdownSerializer, isMarkdownError, marks, nodes, schema };

package/dist/markdown.js

@@ -0,0 +1,5 @@
+import { MarkdownError, isMarkdownError } from "./markdown/errors.js";
+import { MarkdownParseState, MarkdownParser, defaultMarkdownParser } from "./markdown/from_markdown.js";
+import { marks, nodes, schema } from "./markdown/schema.js";
+import { MarkdownSerializer, MarkdownSerializerState, defaultMarkdownSerializer } from "./markdown/to_markdown.js";
+export { MarkdownError, MarkdownParseState, MarkdownParser, MarkdownSerializer, MarkdownSerializerState, defaultMarkdownParser, defaultMarkdownSerializer, isMarkdownError, marks, nodes, schema };

package/dist/model/attrsCodec.js

@@ -0,0 +1,48 @@
+import * as S from "effect/Schema";
+// src/model/attrsCodec.ts
+const encoderCache = /* @__PURE__ */ new WeakMap();
+const decoderCache = /* @__PURE__ */ new WeakMap();
+const encoder = (schema) => {
+	let enc = encoderCache.get(schema);
+	if (!enc) {
+		enc = S.encodeUnknownSync(schema);
+		encoderCache.set(schema, enc);
+	}
+	return enc;
+};
+const decoder = (schema) => {
+	let dec = decoderCache.get(schema);
+	if (!dec) {
+		dec = S.decodeUnknownSync(schema);
+		decoderCache.set(schema, dec);
+	}
+	return dec;
+};
+const mapAttrs = (defs, attrs, decode) => {
+	let out;
+	for (const name in attrs) {
+		const def = defs[name];
+		if (!def?.schema || def.identityCodec && (!decode || def.is !== void 0 && def.is(attrs[name]))) continue;
+		const value = (decode ? decoder : encoder)(def.schema)(attrs[name]);
+		if (value !== attrs[name]) {
+			if (!out) out = { ...attrs };
+			out[name] = value;
+		}
+	}
+	return out ?? attrs;
+};
+/**
+* Encode attribute values with their schemas, for JSON output. Returns
+* the input object when nothing changed.
+*
+* @internal
+*/
+const encodeAttrs = (defs, attrs) => mapAttrs(defs, attrs, false);
+/**
+* Decode attribute values from JSON with their schemas. Throws the
+* schema error on failure.
+*
+* @internal
+*/
+const decodeAttrs = (defs, attrs) => mapAttrs(defs, attrs, true);
+export { decodeAttrs, encodeAttrs };

package/dist/model/comparedeep.js

@@ -0,0 +1,17 @@
+import * as Predicate from "effect/Predicate";
+// src/model/comparedeep.ts
+/** @internal */
+function compareDeep(a, b) {
+	if (a === b) return true;
+	if (!Predicate.isObjectOrArray(a) || !Predicate.isObjectOrArray(b)) return false;
+	if (Array.isArray(a)) {
+		if (!Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!compareDeep(a[i], b[i])) return false;
+	} else {
+		if (Array.isArray(b)) return false;
+		for (const p in a) if (!(p in b) || !compareDeep(a[p], b[p])) return false;
+		for (const p in b) if (!(p in a)) return false;
+	}
+	return true;
+}
+export { compareDeep };