@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/markdown/errors.js

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+// src/markdown/errors.ts
+/**
+* Tagged errors raised by the Markdown parser and serializer.
+*
+* @since 0.1.0
+*/
+/**
+* A Markdown error: the tokenizer produced a token type the parser has
+* no handler for, a parser was configured with an invalid parsing
+* spec, or (in strict mode) the serializer met a node or mark type it
+* has no serializer for.
+*
+* Parsing reports unsupported tokens in the Effect error channel; the
+* other cases are programming errors and are thrown.
+*
+* @since 0.1.0
+* @category errors
+*/
+var MarkdownError = class extends Schema.TaggedError()("MarkdownError", { message: Schema.String }) {};
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isMarkdownError = (u) => u instanceof MarkdownError;
+export { MarkdownError, isMarkdownError };

package/dist/markdown/from_markdown.d.ts

@@ -0,0 +1,185 @@
+import { ModelError } from "../model/errors.js";
+import { AnySchema, Attrs, MarkNames, MarkType, NodeNames, NodeType } from "../model/schema.js";
+import { Mark } from "../model/mark.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import { MarkdownError } from "./errors.js";
+import { schema } from "./schema.js";
+import * as Effect from "effect/Effect";
+import { Env, MarkdownIt, Token } from "markdown-it";
+/**
+ * A function handling a markdown-it token while parsing.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type TokenHandler<Sc extends AnySchema = AnySchema> = (state: MarkdownParseState<Sc>, token: Token, tokens: Array<Token>, i: number) => void;
+interface StackEntry {
+  readonly type: NodeType<any, any>;
+  readonly attrs: Attrs | null;
+  readonly content: Array<Node<any, any>>;
+  marks: ReadonlyArray<Mark<any, any>>;
+}
+/**
+ * Object used to track the context of a running parse.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class MarkdownParseState<Sc extends AnySchema = AnySchema> {
+  /** The schema being parsed into. */
+  readonly schema: Sc;
+  /** @internal */
+  readonly tokenHandlers: {
+    readonly [token: string]: TokenHandler<Sc>;
+  };
+  /** @internal */
+  readonly stack: Array<StackEntry>;
+  /** @internal */
+  constructor(
+  /** The schema being parsed into. */
+  schema: Sc,
+  /** @internal */
+  tokenHandlers: {
+    readonly [token: string]: TokenHandler<Sc>;
+  });
+  /** @internal */
+  top(): StackEntry;
+  /** @internal */
+  push(elt: Node<any, any>): void;
+  /**
+   * Adds the given text to the current position in the document, using
+   * the current marks as styling.
+   */
+  addText(text: string): void;
+  /** Adds the given mark to the set of active marks. */
+  openMark(mark: Mark<Sc, any>): void;
+  /** Removes the given mark from the set of active marks. */
+  closeMark(mark: MarkType<Sc, any>): void;
+  /** Run the token handlers for the given tokens. Throws a `MarkdownError` for unsupported tokens. */
+  parseTokens(toks: Array<Token>): void;
+  /**
+   * Add a node at the current position. Returns `null` (adding nothing)
+   * when the content doesn't fit the node type.
+   */
+  addNode(type: NodeType<Sc, any>, attrs: Attrs | null, content?: ReadonlyArray<Node<Sc, any>>): Node<Sc, any> | null;
+  /** Wrap subsequent content in a node of the given type. */
+  openNode(type: NodeType<Sc, any>, attrs: Attrs | null): void;
+  /** Close and return the node that is currently on top of the stack. */
+  closeNode(): Node<Sc, any> | null;
+}
+/**
+ * Object type used to specify how Markdown tokens should be parsed.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ParseSpec<Sc extends AnySchema = AnySchema> {
+  /**
+   * This token maps to a single node, whose type can be looked up in the
+   * schema under the given name. Exactly one of `node`, `block`, or
+   * `mark` must be set.
+   */
+  readonly node?: NodeNames<Sc> | undefined;
+  /**
+   * This token (unless `noCloseToken` is true) comes in `_open` and
+   * `_close` variants (which are appended to the base token name
+   * provides a the object property), and wraps a block of content. The
+   * block should be wrapped in a node of the type named to by the
+   * property's value. If the token does not have `_open` or `_close`,
+   * use the `noCloseToken` option.
+   */
+  readonly block?: NodeNames<Sc> | undefined;
+  /**
+   * This token (again, unless `noCloseToken` is true) also comes in
+   * `_open` and `_close` variants, but should add a mark (named by the
+   * value) to its content, rather than wrapping it in a node.
+   */
+  readonly mark?: MarkNames<Sc> | undefined;
+  /** Attributes for the node or mark. When `getAttrs` is provided, it takes precedence. */
+  readonly attrs?: Attrs | null | undefined;
+  /**
+   * A function used to compute the attributes for the node or mark that
+   * takes a markdown-it token and returns an attribute object.
+   */
+  readonly getAttrs?: ((token: Token, tokenStream: Array<Token>, index: number) => Attrs | null) | undefined;
+  /**
+   * Indicates that the markdown-it token has no `_open` or `_close` for
+   * the nodes. This defaults to `true` for `code_inline`, `code_block`
+   * and `fence`.
+   */
+  readonly noCloseToken?: boolean | undefined;
+  /** When true, ignore content for the matched token. */
+  readonly ignore?: boolean | undefined;
+}
+/**
+ * A configuration of a Markdown parser. Such a parser uses
+ * [markdown-it](https://github.com/markdown-it/markdown-it) to tokenize
+ * a file, and then runs the custom rules it is given over the tokens to
+ * create a document tree.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class MarkdownParser<Sc extends AnySchema = AnySchema> {
+  /** The parser's document schema. */
+  readonly schema: Sc;
+  /** This parser's markdown-it tokenizer. */
+  readonly tokenizer: MarkdownIt;
+  /**
+   * The value of the `tokens` object used to construct this parser.
+   * Can be useful to copy and modify to base other parsers on.
+   */
+  readonly tokens: {
+    readonly [name: string]: ParseSpec<Sc>;
+  };
+  /** @internal */
+  readonly tokenHandlers: {
+    readonly [token: string]: TokenHandler<Sc>;
+  };
+  /**
+   * Create a parser with the given configuration. You can configure the
+   * markdown-it parser to parse the dialect you want, and provide a
+   * description of the entities those tokens map to in the `tokens`
+   * object, which maps token names to descriptions of what to do with
+   * them.
+   *
+   * Throws a `MarkdownError` for invalid parsing specs, and a
+   * `ContentError` for unknown node types.
+   */
+  constructor(
+  /** The parser's document schema. */
+  schema: Sc,
+  /** This parser's markdown-it tokenizer. */
+  tokenizer: MarkdownIt,
+  /**
+   * The value of the `tokens` object used to construct this parser.
+   * Can be useful to copy and modify to base other parsers on.
+   */
+  tokens: {
+    readonly [name: string]: ParseSpec<Sc>;
+  });
+  /**
+   * Parse a string as [CommonMark](http://commonmark.org/) markup, and
+   * create a document as prescribed by this parser's rules.
+   *
+   * The second argument, when given, is passed through to the
+   * [Markdown parser](https://markdown-it.github.io/markdown-it/#MarkdownIt.parse).
+   *
+   * Fails with a `MarkdownError` when the tokenizer produces a token
+   * the parser has no rule for, and with a `ModelError` when a rule
+   * produces invalid attributes.
+   */
+  parse(text: string, markdownEnv?: Env): Effect.Effect<Node<Sc>, MarkdownError | ModelError>;
+  /** Like `parse`, but throws a `MarkdownError` or `ModelError` on failure. */
+  parseUnsafe(text: string, markdownEnv?: Env): Node<Sc>;
+}
+/**
+ * A parser parsing unextended [CommonMark](http://commonmark.org/),
+ * without inline HTML, and producing a document in the Markdown schema.
+ *
+ * @since 0.1.0
+ * @category parsers
+ */
+export declare const defaultMarkdownParser: MarkdownParser<typeof schema>;
+export {};

package/dist/markdown/from_markdown.js

@@ -0,0 +1,266 @@
+import { attempt } from "../internal/attempt.js";
+import { showJson } from "../internal/json.js";
+import { isModelError } from "../model/errors.js";
+import { Mark } from "../model/mark.js";
+import { MarkdownError, isMarkdownError } from "./errors.js";
+import { schema } from "./schema.js";
+import * as Predicate from "effect/Predicate";
+import MarkdownIt$1 from "markdown-it";
+// src/markdown/from_markdown.ts
+function maybeMerge(a, b) {
+	if (a.isText && b.isText && Mark.sameSet(a.marks, b.marks)) return a.withText(a.text + b.text);
+}
+/**
+* Object used to track the context of a running parse.
+*
+* @since 0.1.0
+* @category models
+*/
+var MarkdownParseState = class {
+	/** @internal */
+	constructor(schema, tokenHandlers) {
+		this.schema = schema;
+		this.tokenHandlers = tokenHandlers;
+		this.stack = [{
+			type: schema.topNodeType,
+			attrs: null,
+			content: [],
+			marks: Mark.none
+		}];
+	}
+	/** @internal */
+	top() {
+		return this.stack[this.stack.length - 1];
+	}
+	/** @internal */
+	push(elt) {
+		if (this.stack.length) this.top().content.push(elt);
+	}
+	/**
+	* Adds the given text to the current position in the document, using
+	* the current marks as styling.
+	*/
+	addText(text) {
+		if (!text) return;
+		const top = this.top(), nodes = top.content, last = nodes[nodes.length - 1];
+		const node = this.schema.textUnsafe(text, top.marks);
+		const merged = last && maybeMerge(last, node);
+		if (merged) nodes[nodes.length - 1] = merged;
+		else nodes.push(node);
+	}
+	/** Adds the given mark to the set of active marks. */
+	openMark(mark) {
+		const top = this.top();
+		top.marks = mark.addToSet(top.marks);
+	}
+	/** Removes the given mark from the set of active marks. */
+	closeMark(mark) {
+		const top = this.top();
+		top.marks = mark.removeFromSet(top.marks);
+	}
+	/** Run the token handlers for the given tokens. Throws a `MarkdownError` for unsupported tokens. */
+	parseTokens(toks) {
+		for (let i = 0; i < toks.length; i++) {
+			const tok = toks[i];
+			const handler = this.tokenHandlers[tok.type];
+			if (!handler) throw new MarkdownError({ message: "Token type `" + tok.type + "` not supported by Markdown parser" });
+			handler(this, tok, toks, i);
+		}
+	}
+	/**
+	* Add a node at the current position. Returns `null` (adding nothing)
+	* when the content doesn't fit the node type.
+	*/
+	addNode(type, attrs, content) {
+		const top = this.top();
+		const node = type.createAndFillOrNull(attrs, content, top ? top.marks : []);
+		if (!node) return null;
+		this.push(node);
+		return node;
+	}
+	/** Wrap subsequent content in a node of the given type. */
+	openNode(type, attrs) {
+		this.stack.push({
+			type,
+			attrs,
+			content: [],
+			marks: Mark.none
+		});
+	}
+	/** Close and return the node that is currently on top of the stack. */
+	closeNode() {
+		const info = this.stack.pop();
+		return this.addNode(info.type, info.attrs, info.content);
+	}
+};
+function attrs(spec, token, tokens, i) {
+	if (spec.getAttrs) return spec.getAttrs(token, tokens, i);
+	else if (Predicate.isFunction(spec.attrs)) return spec.attrs(token);
+	else return spec.attrs ?? null;
+}
+function noCloseToken(spec, type) {
+	return spec.noCloseToken || type == "code_inline" || type == "code_block" || type == "fence";
+}
+function withoutTrailingNewline(str) {
+	return str[str.length - 1] == "\n" ? str.slice(0, str.length - 1) : str;
+}
+function noOp() {}
+function tokenHandlers(schema, tokens) {
+	const handlers = Object.create(null);
+	for (const type in tokens) {
+		const spec = tokens[type];
+		if (spec.block) {
+			const nodeType = schema.nodeType(spec.block);
+			if (noCloseToken(spec, type)) handlers[type] = (state, tok, tokens, i) => {
+				state.openNode(nodeType, attrs(spec, tok, tokens, i));
+				state.addText(withoutTrailingNewline(tok.content));
+				state.closeNode();
+			};
+			else {
+				handlers[type + "_open"] = (state, tok, tokens, i) => state.openNode(nodeType, attrs(spec, tok, tokens, i));
+				handlers[type + "_close"] = (state) => state.closeNode();
+			}
+		} else if (spec.node) {
+			const nodeType = schema.nodeType(spec.node);
+			handlers[type] = (state, tok, tokens, i) => state.addNode(nodeType, attrs(spec, tok, tokens, i));
+		} else if (spec.mark) {
+			const markType = schema.marks[spec.mark];
+			if (!markType) throw new MarkdownError({ message: "Unknown mark type: " + spec.mark });
+			if (noCloseToken(spec, type)) handlers[type] = (state, tok, tokens, i) => {
+				state.openMark(markType.createUnsafe(attrs(spec, tok, tokens, i) ?? void 0));
+				state.addText(withoutTrailingNewline(tok.content));
+				state.closeMark(markType);
+			};
+			else {
+				handlers[type + "_open"] = (state, tok, tokens, i) => state.openMark(markType.createUnsafe(attrs(spec, tok, tokens, i) ?? void 0));
+				handlers[type + "_close"] = (state) => state.closeMark(markType);
+			}
+		} else if (spec.ignore) {
+			if (noCloseToken(spec, type)) handlers[type] = noOp;
+			else {
+				handlers[type + "_open"] = noOp;
+				handlers[type + "_close"] = noOp;
+			}
+		} else throw new MarkdownError({ message: "Unrecognized parsing spec " + showJson(spec) });
+	}
+	handlers.text = (state, tok) => state.addText(tok.content);
+	handlers.inline = (state, tok) => state.parseTokens(tok.children);
+	handlers.softbreak = handlers.softbreak || ((state) => state.addText(" "));
+	return handlers;
+}
+/**
+* A configuration of a Markdown parser. Such a parser uses
+* [markdown-it](https://github.com/markdown-it/markdown-it) to tokenize
+* a file, and then runs the custom rules it is given over the tokens to
+* create a document tree.
+*
+* @since 0.1.0
+* @category models
+*/
+var MarkdownParser = class {
+	/**
+	* Create a parser with the given configuration. You can configure the
+	* markdown-it parser to parse the dialect you want, and provide a
+	* description of the entities those tokens map to in the `tokens`
+	* object, which maps token names to descriptions of what to do with
+	* them.
+	*
+	* Throws a `MarkdownError` for invalid parsing specs, and a
+	* `ContentError` for unknown node types.
+	*/
+	constructor(schema, tokenizer, tokens) {
+		this.schema = schema;
+		this.tokenizer = tokenizer;
+		this.tokens = tokens;
+		this.tokenHandlers = tokenHandlers(schema, tokens);
+	}
+	/**
+	* Parse a string as [CommonMark](http://commonmark.org/) markup, and
+	* create a document as prescribed by this parser's rules.
+	*
+	* The second argument, when given, is passed through to the
+	* [Markdown parser](https://markdown-it.github.io/markdown-it/#MarkdownIt.parse).
+	*
+	* Fails with a `MarkdownError` when the tokenizer produces a token
+	* the parser has no rule for, and with a `ModelError` when a rule
+	* produces invalid attributes.
+	*/
+	parse(text, markdownEnv = {}) {
+		return attempt(() => this.parseUnsafe(text, markdownEnv), (u) => isMarkdownError(u) || isModelError(u));
+	}
+	/** Like `parse`, but throws a `MarkdownError` or `ModelError` on failure. */
+	parseUnsafe(text, markdownEnv = {}) {
+		const state = new MarkdownParseState(this.schema, this.tokenHandlers);
+		let doc;
+		state.parseTokens(this.tokenizer.parse(text, markdownEnv));
+		do
+			doc = state.closeNode();
+		while (state.stack.length);
+		return doc || this.schema.topNodeType.createAndFillOrNull();
+	}
+};
+function listIsTight(tokens, i) {
+	while (++i < tokens.length) if (tokens[i].type != "list_item_open") return tokens[i].hidden;
+	return false;
+}
+const attrString = (value) => value == null ? null : String(value);
+/**
+* A parser parsing unextended [CommonMark](http://commonmark.org/),
+* without inline HTML, and producing a document in the Markdown schema.
+*
+* @since 0.1.0
+* @category parsers
+*/
+const defaultMarkdownParser = new MarkdownParser(schema, new MarkdownIt$1("commonmark", { html: false }), {
+	blockquote: { block: "blockquote" },
+	paragraph: { block: "paragraph" },
+	list_item: { block: "list_item" },
+	bullet_list: {
+		block: "bullet_list",
+		getAttrs: (_, tokens, i) => ({ tight: listIsTight(tokens, i) })
+	},
+	ordered_list: {
+		block: "ordered_list",
+		getAttrs: (tok, tokens, i) => ({
+			order: +tok.attrGet("start") || 1,
+			tight: listIsTight(tokens, i)
+		})
+	},
+	heading: {
+		block: "heading",
+		getAttrs: (tok) => ({ level: +tok.tag.slice(1) })
+	},
+	code_block: {
+		block: "code_block",
+		noCloseToken: true
+	},
+	fence: {
+		block: "code_block",
+		getAttrs: (tok) => ({ params: tok.info || "" }),
+		noCloseToken: true
+	},
+	hr: { node: "horizontal_rule" },
+	image: {
+		node: "image",
+		getAttrs: (tok) => ({
+			src: attrString(tok.attrGet("src")),
+			title: attrString(tok.attrGet("title")) || null,
+			alt: tok.children[0] && tok.children[0].content || null
+		})
+	},
+	hardbreak: { node: "hard_break" },
+	em: { mark: "em" },
+	strong: { mark: "strong" },
+	link: {
+		mark: "link",
+		getAttrs: (tok) => ({
+			href: attrString(tok.attrGet("href")),
+			title: attrString(tok.attrGet("title")) || null
+		})
+	},
+	code_inline: {
+		mark: "code",
+		noCloseToken: true
+	}
+});
+export { MarkdownParseState, MarkdownParser, defaultMarkdownParser };