@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/markdown/schema.js

@@ -0,0 +1,292 @@
+import { choice, oneOrMore, zeroOrMore } from "../model/content.js";
+import { DocSchema, markSpec, nodeSpec } from "../model/schema.js";
+import * as S from "effect/Schema";
+// src/markdown/schema.ts
+/**
+* The document schema used by CommonMark.
+*
+* @since 0.1.0
+*/
+/**
+* The node specs of the Markdown schema.
+*
+* @since 0.1.0
+* @category specs
+*/
+const nodes = {
+	doc: nodeSpec({ content: oneOrMore("block") }),
+	paragraph: nodeSpec({
+		content: zeroOrMore("inline"),
+		group: "block",
+		parseDOM: [{ tag: "p" }],
+		toDOM() {
+			return ["p", 0];
+		}
+	}),
+	blockquote: nodeSpec({
+		content: oneOrMore("block"),
+		group: "block",
+		parseDOM: [{ tag: "blockquote" }],
+		toDOM() {
+			return ["blockquote", 0];
+		}
+	}),
+	horizontal_rule: nodeSpec({
+		group: "block",
+		parseDOM: [{ tag: "hr" }],
+		toDOM() {
+			return ["div", ["hr"]];
+		}
+	}),
+	heading: nodeSpec({
+		attrs: { level: {
+			schema: S.Number,
+			default: 1
+		} },
+		content: zeroOrMore(choice("text", "image")),
+		group: "block",
+		defining: true,
+		parseDOM: [
+			{
+				tag: "h1",
+				attrs: { level: 1 }
+			},
+			{
+				tag: "h2",
+				attrs: { level: 2 }
+			},
+			{
+				tag: "h3",
+				attrs: { level: 3 }
+			},
+			{
+				tag: "h4",
+				attrs: { level: 4 }
+			},
+			{
+				tag: "h5",
+				attrs: { level: 5 }
+			},
+			{
+				tag: "h6",
+				attrs: { level: 6 }
+			}
+		],
+		toDOM(node) {
+			return ["h" + node.attrs.level, 0];
+		}
+	}),
+	code_block: nodeSpec({
+		content: zeroOrMore("text"),
+		group: "block",
+		code: true,
+		defining: true,
+		marks: "",
+		attrs: { params: {
+			schema: S.String,
+			default: ""
+		} },
+		parseDOM: [{
+			tag: "pre",
+			preserveWhitespace: "full",
+			getAttrs: (node) => ({ params: node.getAttribute("data-params") || "" })
+		}],
+		toDOM(node) {
+			return [
+				"pre",
+				node.attrs.params ? { "data-params": node.attrs.params } : {},
+				["code", 0]
+			];
+		}
+	}),
+	ordered_list: nodeSpec({
+		content: oneOrMore("list_item"),
+		group: "block",
+		attrs: {
+			order: {
+				schema: S.Number,
+				default: 1
+			},
+			tight: {
+				schema: S.Boolean,
+				default: false
+			}
+		},
+		parseDOM: [{
+			tag: "ol",
+			getAttrs(dom) {
+				return {
+					order: dom.hasAttribute("start") ? +dom.getAttribute("start") : 1,
+					tight: dom.hasAttribute("data-tight")
+				};
+			}
+		}],
+		toDOM(node) {
+			return [
+				"ol",
+				{
+					start: node.attrs.order == 1 ? null : node.attrs.order,
+					"data-tight": node.attrs.tight ? "true" : null
+				},
+				0
+			];
+		}
+	}),
+	bullet_list: nodeSpec({
+		content: oneOrMore("list_item"),
+		group: "block",
+		attrs: { tight: {
+			schema: S.Boolean,
+			default: false
+		} },
+		parseDOM: [{
+			tag: "ul",
+			getAttrs: (dom) => ({ tight: dom.hasAttribute("data-tight") })
+		}],
+		toDOM(node) {
+			return [
+				"ul",
+				{ "data-tight": node.attrs.tight ? "true" : null },
+				0
+			];
+		}
+	}),
+	list_item: nodeSpec({
+		content: oneOrMore("block"),
+		defining: true,
+		parseDOM: [{ tag: "li" }],
+		toDOM() {
+			return ["li", 0];
+		}
+	}),
+	text: nodeSpec({ group: "inline" }),
+	image: nodeSpec({
+		inline: true,
+		attrs: {
+			src: S.String,
+			alt: {
+				schema: S.NullOr(S.String),
+				default: null
+			},
+			title: {
+				schema: S.NullOr(S.String),
+				default: null
+			}
+		},
+		group: "inline",
+		draggable: true,
+		parseDOM: [{
+			tag: "img[src]",
+			getAttrs(dom) {
+				return {
+					src: dom.getAttribute("src"),
+					title: dom.getAttribute("title"),
+					alt: dom.getAttribute("alt")
+				};
+			}
+		}],
+		toDOM(node) {
+			const { alt, src, title } = node.attrs;
+			return ["img", {
+				src,
+				alt,
+				title
+			}];
+		}
+	}),
+	hard_break: nodeSpec({
+		inline: true,
+		group: "inline",
+		selectable: false,
+		parseDOM: [{ tag: "br" }],
+		toDOM() {
+			return ["br"];
+		}
+	})
+};
+/**
+* The mark specs of the Markdown schema.
+*
+* @since 0.1.0
+* @category specs
+*/
+const marks = {
+	em: markSpec({
+		parseDOM: [
+			{ tag: "i" },
+			{ tag: "em" },
+			{ style: "font-style=italic" },
+			{
+				style: "font-style=normal",
+				clearMark: (m) => m.type.name === "em"
+			}
+		],
+		toDOM() {
+			return ["em"];
+		}
+	}),
+	strong: markSpec({
+		parseDOM: [
+			{ tag: "strong" },
+			{
+				tag: "b",
+				getAttrs: (node) => node.style.fontWeight !== "normal" && null
+			},
+			{
+				style: "font-weight=400",
+				clearMark: (m) => m.type.name === "strong"
+			},
+			{
+				style: "font-weight",
+				getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null
+			}
+		],
+		toDOM() {
+			return ["strong"];
+		}
+	}),
+	link: markSpec({
+		attrs: {
+			href: S.String,
+			title: {
+				schema: S.NullOr(S.String),
+				default: null
+			}
+		},
+		inclusive: false,
+		parseDOM: [{
+			tag: "a[href]",
+			getAttrs(dom) {
+				return {
+					href: dom.getAttribute("href"),
+					title: dom.getAttribute("title")
+				};
+			}
+		}],
+		toDOM(node) {
+			const { href, title } = node.attrs;
+			return ["a", {
+				href,
+				title
+			}];
+		}
+	}),
+	code: markSpec({
+		code: true,
+		parseDOM: [{ tag: "code" }],
+		toDOM() {
+			return ["code"];
+		}
+	})
+};
+/**
+* Document schema for the data model used by CommonMark.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const schema = DocSchema.makeUnsafe({
+	nodes,
+	marks
+});
+export { marks, nodes, schema };

package/dist/markdown/to_markdown.d.ts

@@ -0,0 +1,251 @@
+import { AnySchema } from "../model/schema.js";
+import { Mark } from "../model/mark.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+/**
+ * A function serializing a node to Markdown, by calling methods on the
+ * serializer state.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type NodeSerializer<Sc extends AnySchema = AnySchema> = (state: MarkdownSerializerState<Sc>, node: Node<Sc, any>, parent: Node<Sc, any>, index: number) => void;
+/**
+ * Describes how to serialize a mark to Markdown.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface MarkSerializerSpec<Sc extends AnySchema = AnySchema> {
+  /**
+   * The string that should appear before a piece of content marked by
+   * this mark, either directly or as a function that returns an
+   * appropriate string.
+   */
+  readonly open: string | ((state: MarkdownSerializerState<Sc>, mark: Mark<Sc, any>, parent: Node<Sc, any>, index: number) => string);
+  /** The string that should appear after a piece of content marked by this mark. */
+  readonly close: string | ((state: MarkdownSerializerState<Sc>, mark: Mark<Sc, any>, parent: Node<Sc, any>, index: number) => string);
+  /**
+   * When `true`, this indicates that the order in which the mark's
+   * opening and closing syntax appears relative to other mixable marks
+   * can be varied. (For example, you can say `**a *b***` and `*a **b***`,
+   * but not `` `a *b*` ``.)
+   */
+  readonly mixable?: boolean | undefined;
+  /**
+   * When enabled, causes the serializer to move enclosing whitespace
+   * from inside the marks to outside the marks. This is necessary for
+   * emphasis marks as CommonMark does not permit enclosing whitespace
+   * inside emphasis marks, see:
+   * http://spec.commonmark.org/0.26/#example-330
+   */
+  readonly expelEnclosingWhitespace?: boolean | undefined;
+  /**
+   * Can be set to `false` to disable character escaping in a mark. A
+   * non-escaping mark has to have the highest precedence (must always
+   * be the innermost mark).
+   */
+  readonly escape?: boolean | undefined;
+}
+/**
+ * Options for a `MarkdownSerializer`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface MarkdownSerializerOptions {
+  /**
+   * Extra characters can be added for escaping. This is passed directly
+   * to `String.replace()`, and the matching characters are preceded by
+   * a backslash.
+   */
+  readonly escapeExtraCharacters?: RegExp | undefined;
+  /** Specify the node name of hard breaks. Defaults to `"hard_break"`. */
+  readonly hardBreakNodeName?: string | undefined;
+  /**
+   * By default, the serializer throws a `MarkdownError` when it finds a
+   * node or mark type for which no serializer is defined. Set this to
+   * `false` to make it just ignore such elements, rendering only their
+   * content.
+   */
+  readonly strict?: boolean | undefined;
+}
+/**
+ * Options for `MarkdownSerializer.serialize`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface MarkdownSerializeOptions {
+  /**
+   * Whether to render lists in a tight style. This can be overridden on
+   * a node level by specifying a tight attribute on the node. Defaults
+   * to false.
+   */
+  readonly tightLists?: boolean | undefined;
+}
+/**
+ * The options available on a `MarkdownSerializerState`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface MarkdownSerializerStateOptions extends MarkdownSerializerOptions {
+  readonly tightLists: boolean;
+  readonly hardBreakNodeName: string;
+}
+/**
+ * A specification for serializing a document as Markdown/CommonMark
+ * text.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class MarkdownSerializer<Sc extends AnySchema = AnySchema> {
+  /** The node serializer functions for this serializer. */
+  readonly nodes: {
+    readonly [node: string]: NodeSerializer<Sc>;
+  };
+  /** The mark serializer info. */
+  readonly marks: {
+    readonly [mark: string]: MarkSerializerSpec<Sc>;
+  };
+  readonly options: MarkdownSerializerOptions;
+  /**
+   * 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(
+  /** The node serializer functions for this serializer. */
+  nodes: {
+    readonly [node: string]: NodeSerializer<Sc>;
+  },
+  /** The mark serializer info. */
+  marks: {
+    readonly [mark: string]: MarkSerializerSpec<Sc>;
+  }, options?: MarkdownSerializerOptions);
+  /**
+   * 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: Node<Sc, any>, options?: MarkdownSerializeOptions): string;
+}
+/**
+ * A serializer for the Markdown schema (or any schema using the same
+ * node and mark names).
+ *
+ * @since 0.1.0
+ * @category serializers
+ */
+export declare const defaultMarkdownSerializer: MarkdownSerializer;
+/**
+ * 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
+ */
+export declare class MarkdownSerializerState<Sc extends AnySchema = AnySchema> {
+  /** @internal */
+  readonly nodes: {
+    readonly [node: string]: NodeSerializer<Sc>;
+  };
+  /** @internal */
+  readonly marks: {
+    readonly [mark: string]: MarkSerializerSpec<Sc>;
+  };
+  /** @internal */
+  delim: string;
+  /** @internal */
+  out: string;
+  /** @internal */
+  closed: Node<Sc, any> | null;
+  /** @internal */
+  inAutolink: boolean | undefined;
+  /** @internal */
+  atBlockStart: boolean;
+  /** @internal */
+  inTightList: boolean;
+  /** The options passed to the serializer. */
+  readonly options: MarkdownSerializerStateOptions;
+  /** @internal */
+  constructor(
+  /** @internal */
+  nodes: {
+    readonly [node: string]: NodeSerializer<Sc>;
+  },
+  /** @internal */
+  marks: {
+    readonly [mark: string]: MarkSerializerSpec<Sc>;
+  }, options: MarkdownSerializerOptions & MarkdownSerializeOptions);
+  /** @internal */
+  flushClose(size?: number): void;
+  /** @internal */
+  getMark(name: string): MarkSerializerSpec<Sc>;
+  /**
+   * 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: string, firstDelim: string | null, node: Node<Sc, any>, f: () => void): void;
+  /** @internal */
+  atBlank(): boolean;
+  /** Ensure the current content ends with a newline. */
+  ensureNewLine(): void;
+  /**
+   * 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?: string): void;
+  /** Close the block for the given node. */
+  closeBlock(node: Node<Sc, any>): void;
+  /** Add the given text to the document. When escape is not `false`, it will be escaped. */
+  text(text: string, escape?: boolean): void;
+  /**
+   * Render the given node as a block. In strict mode, throws a
+   * `MarkdownError` for node types without a serializer.
+   */
+  render(node: Node<Sc, any>, parent: Node<Sc, any>, index: number): void;
+  /** Render the contents of `parent` as block nodes. */
+  renderContent(parent: Node<Sc, any>): void;
+  /** Render the contents of `parent` as inline content. */
+  renderInline(parent: Node<Sc, any>, fromBlockStart?: boolean): void;
+  /**
+   * 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: Node<Sc, any>, delim: string, firstDelim: (index: number) => string): void;
+  /**
+   * 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: string, startOfLine?: boolean): string;
+  /** @internal */
+  quote(str: string): string;
+  /** Repeat the given string `n` times. */
+  repeat(str: string, n: number): string;
+  /** Get the markdown string for a given opening or closing mark. */
+  markString(mark: Mark<Sc, any>, open: boolean, parent: Node<Sc, any>, index: number): string;
+  /**
+   * 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: string): {
+    leading?: string | undefined;
+    trailing?: string | undefined;
+  };
+  /** @internal */
+  isMarkAhead(parent: Node<Sc, any>, index: number, marks: ReadonlyArray<Mark<Sc, any>>): boolean;
+}