@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/compat/orderedmap.d.ts

@@ -0,0 +1,74 @@
+/**
+ * A port of the [`orderedmap`](https://github.com/marijnh/orderedmap)
+ * package (MIT, Marijn Haverbeke), used by the ProseMirror-compatible
+ * schema (`schema.spec.nodes` / `schema.spec.marks`). Code that imports
+ * `orderedmap` directly can alias it to this module.
+ *
+ * @since 0.1.0
+ */
+/**
+ * A persistent, ordered map from string keys to values.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class OrderedMap<T = any> {
+  readonly content: Array<string | T>;
+  /** @internal */
+  constructor(content: Array<string | T>);
+  /** @internal */
+  find(key: string): number;
+  /** Retrieve the value stored under `key`, or `undefined`. */
+  get(key: string): T | undefined;
+  /**
+   * Create a new map by replacing the value of `key` with a new value,
+   * or adding a binding to the end of the map. If `newKey` is given,
+   * the key of the binding will be replaced with that key.
+   */
+  update(key: string, value: T, newKey?: string): OrderedMap<T>;
+  /** Return a map with the given key removed, if it existed. */
+  remove(key: string): OrderedMap<T>;
+  /** Add a new key to the start of the map. */
+  addToStart(key: string, value: T): OrderedMap<T>;
+  /** Add a new key to the end of the map. */
+  addToEnd(key: string, value: T): OrderedMap<T>;
+  /**
+   * Add a key before the given key. If `place` is not found, the new key
+   * is added to the end.
+   */
+  addBefore(place: string, key: string, value: T): OrderedMap<T>;
+  /** Call the given function for each key/value pair in the map, in order. */
+  forEach(f: (key: string, value: T) => void): void;
+  /**
+   * Create a new map by prepending the keys in `map` that don't appear
+   * in this map before the keys in this map.
+   */
+  prepend(map: MapLike<T>): OrderedMap<T>;
+  /**
+   * Create a new map by appending the keys in `map` that don't appear
+   * in this map after the keys in this map.
+   */
+  append(map: MapLike<T>): OrderedMap<T>;
+  /** Create a map containing all the keys in this map that don't appear in `map`. */
+  subtract(map: MapLike<T>): OrderedMap<T>;
+  /** Turn the ordered map into a plain object. */
+  toObject(): Record<string, T>;
+  /** The amount of keys in this map. */
+  get size(): number;
+  /**
+   * Return a map with the given content. If null, create an empty map.
+   * If given an ordered map, return that map itself. If given an
+   * object, create a map from the object's properties.
+   */
+  static from<T>(map: MapLike<T>): OrderedMap<T>;
+}
+/**
+ * Anything that can be converted to an `OrderedMap`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type MapLike<T = any> = {
+  readonly [key: string]: T;
+} | OrderedMap<T> | null | undefined;
+export { OrderedMap as default };

package/dist/compat/orderedmap.js

@@ -0,0 +1,124 @@
+// src/compat/orderedmap.ts
+/**
+* A port of the [`orderedmap`](https://github.com/marijnh/orderedmap)
+* package (MIT, Marijn Haverbeke), used by the ProseMirror-compatible
+* schema (`schema.spec.nodes` / `schema.spec.marks`). Code that imports
+* `orderedmap` directly can alias it to this module.
+*
+* @since 0.1.0
+*/
+/**
+* A persistent, ordered map from string keys to values.
+*
+* @since 0.1.0
+* @category models
+*/
+var OrderedMap = class OrderedMap {
+	/** @internal */
+	constructor(content) {
+		this.content = content;
+	}
+	/** @internal */
+	find(key) {
+		for (let i = 0; i < this.content.length; i += 2) if (this.content[i] === key) return i;
+		return -1;
+	}
+	/** Retrieve the value stored under `key`, or `undefined`. */
+	get(key) {
+		const found = this.find(key);
+		return found === -1 ? void 0 : this.content[found + 1];
+	}
+	/**
+	* Create a new map by replacing the value of `key` with a new value,
+	* or adding a binding to the end of the map. If `newKey` is given,
+	* the key of the binding will be replaced with that key.
+	*/
+	update(key, value, newKey) {
+		const self = newKey && newKey !== key ? this.remove(newKey) : this;
+		const found = self.find(key), content = self.content.slice();
+		if (found === -1) content.push(newKey || key, value);
+		else {
+			content[found + 1] = value;
+			if (newKey) content[found] = newKey;
+		}
+		return new OrderedMap(content);
+	}
+	/** Return a map with the given key removed, if it existed. */
+	remove(key) {
+		const found = this.find(key);
+		if (found === -1) return this;
+		const content = this.content.slice();
+		content.splice(found, 2);
+		return new OrderedMap(content);
+	}
+	/** Add a new key to the start of the map. */
+	addToStart(key, value) {
+		return new OrderedMap([key, value].concat(this.remove(key).content));
+	}
+	/** Add a new key to the end of the map. */
+	addToEnd(key, value) {
+		const content = this.remove(key).content.slice();
+		content.push(key, value);
+		return new OrderedMap(content);
+	}
+	/**
+	* Add a key before the given key. If `place` is not found, the new key
+	* is added to the end.
+	*/
+	addBefore(place, key, value) {
+		const without = this.remove(key), content = without.content.slice();
+		const found = without.find(place);
+		content.splice(found === -1 ? content.length : found, 0, key, value);
+		return new OrderedMap(content);
+	}
+	/** Call the given function for each key/value pair in the map, in order. */
+	forEach(f) {
+		for (let i = 0; i < this.content.length; i += 2) f(this.content[i], this.content[i + 1]);
+	}
+	/**
+	* Create a new map by prepending the keys in `map` that don't appear
+	* in this map before the keys in this map.
+	*/
+	prepend(map) {
+		const other = OrderedMap.from(map);
+		if (!other.size) return this;
+		return new OrderedMap(other.content.concat(this.subtract(other).content));
+	}
+	/**
+	* Create a new map by appending the keys in `map` that don't appear
+	* in this map after the keys in this map.
+	*/
+	append(map) {
+		const other = OrderedMap.from(map);
+		if (!other.size) return this;
+		return new OrderedMap(this.subtract(other).content.concat(other.content));
+	}
+	/** Create a map containing all the keys in this map that don't appear in `map`. */
+	subtract(map) {
+		return OrderedMap.from(map).content.reduce((result, key, i) => i % 2 === 0 ? result.remove(key) : result, this);
+	}
+	/** Turn the ordered map into a plain object. */
+	toObject() {
+		const result = {};
+		this.forEach((key, value) => {
+			result[key] = value;
+		});
+		return result;
+	}
+	/** The amount of keys in this map. */
+	get size() {
+		return this.content.length >> 1;
+	}
+	/**
+	* Return a map with the given content. If null, create an empty map.
+	* If given an ordered map, return that map itself. If given an
+	* object, create a map from the object's properties.
+	*/
+	static from(map) {
+		if (map instanceof OrderedMap) return map;
+		const content = [];
+		if (map) for (const prop in map) content.push(prop, map[prop]);
+		return new OrderedMap(content);
+	}
+};
+export { OrderedMap, OrderedMap as default };

package/dist/compat/schema-basic.d.ts

@@ -0,0 +1,38 @@
+import { MarkSpec, NodeSpec, Schema } from "./model.js";
+/**
+ * Specs for the nodes defined in this schema.
+ *
+ * @since 0.1.0
+ * @category specs
+ */
+export declare const nodes: {
+  doc: NodeSpec;
+  paragraph: NodeSpec;
+  blockquote: NodeSpec;
+  horizontal_rule: NodeSpec;
+  heading: NodeSpec;
+  code_block: NodeSpec;
+  text: NodeSpec;
+  image: NodeSpec;
+  hard_break: NodeSpec;
+};
+/**
+ * Specs for the marks in the schema.
+ *
+ * @since 0.1.0
+ * @category specs
+ */
+export declare const marks: {
+  link: MarkSpec;
+  em: MarkSpec;
+  strong: MarkSpec;
+  code: MarkSpec;
+};
+/**
+ * This schema roughly corresponds to the document schema used by
+ * CommonMark, minus the list elements.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const schema: Schema<keyof typeof nodes, keyof typeof marks>;

package/dist/compat/schema-basic.js

@@ -0,0 +1,238 @@
+import { Schema } from "./model.js";
+// src/compat/schema-basic.ts
+/**
+* A `prosemirror-schema-basic`-compatible module: the basic schema
+* specs, built with the compat `Schema`.
+*
+* Ported from prosemirror-schema-basic (MIT, Marijn Haverbeke and others).
+*
+* @since 0.1.0
+*/
+const pDOM = ["p", 0];
+const blockquoteDOM = ["blockquote", 0];
+const hrDOM = ["hr"];
+const preDOM = ["pre", ["code", 0]];
+const brDOM = ["br"];
+/**
+* Specs for the nodes defined in this schema.
+*
+* @since 0.1.0
+* @category specs
+*/
+const nodes = {
+	doc: { content: "block+" },
+	paragraph: {
+		content: "inline*",
+		group: "block",
+		parseDOM: [{ tag: "p" }],
+		toDOM() {
+			return pDOM;
+		}
+	},
+	blockquote: {
+		content: "block+",
+		group: "block",
+		defining: true,
+		parseDOM: [{ tag: "blockquote" }],
+		toDOM() {
+			return blockquoteDOM;
+		}
+	},
+	horizontal_rule: {
+		group: "block",
+		parseDOM: [{ tag: "hr" }],
+		toDOM() {
+			return hrDOM;
+		}
+	},
+	heading: {
+		attrs: { level: {
+			default: 1,
+			validate: "number"
+		} },
+		content: "inline*",
+		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: {
+		content: "text*",
+		marks: "",
+		group: "block",
+		code: true,
+		defining: true,
+		parseDOM: [{
+			tag: "pre",
+			preserveWhitespace: "full"
+		}],
+		toDOM() {
+			return preDOM;
+		}
+	},
+	text: { group: "inline" },
+	image: {
+		inline: true,
+		attrs: {
+			src: { validate: "string" },
+			alt: {
+				default: null,
+				validate: "string|null"
+			},
+			title: {
+				default: null,
+				validate: "string|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: {
+		inline: true,
+		group: "inline",
+		selectable: false,
+		parseDOM: [{ tag: "br" }],
+		toDOM() {
+			return brDOM;
+		}
+	}
+};
+const emDOM = ["em", 0];
+const strongDOM = ["strong", 0];
+const codeDOM = ["code", 0];
+/**
+* Specs for the marks in the schema.
+*
+* @since 0.1.0
+* @category specs
+*/
+const marks = {
+	link: {
+		attrs: {
+			href: { validate: "string" },
+			title: {
+				default: null,
+				validate: "string|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
+				},
+				0
+			];
+		}
+	},
+	em: {
+		parseDOM: [
+			{ tag: "i" },
+			{ tag: "em" },
+			{ style: "font-style=italic" },
+			{
+				style: "font-style=normal",
+				clearMark: (m) => m.type.name == "em"
+			}
+		],
+		toDOM() {
+			return emDOM;
+		}
+	},
+	strong: {
+		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 strongDOM;
+		}
+	},
+	code: {
+		code: true,
+		parseDOM: [{ tag: "code" }],
+		toDOM() {
+			return codeDOM;
+		}
+	}
+};
+/**
+* This schema roughly corresponds to the document schema used by
+* CommonMark, minus the list elements.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const schema = new Schema({
+	nodes,
+	marks
+});
+export { marks, nodes, schema };

package/dist/compat/schema-list.d.ts

@@ -0,0 +1,81 @@
+import { Attrs, NodeRange, NodeSpec, NodeType } from "./model.js";
+import { OrderedMap } from "./orderedmap.js";
+import { Command, Transaction } from "./state.js";
+/**
+ * An ordered list node spec.
+ *
+ * @since 0.1.0
+ * @category specs
+ */
+export declare const orderedList: NodeSpec;
+/**
+ * A bullet list node spec.
+ *
+ * @since 0.1.0
+ * @category specs
+ */
+export declare const bulletList: NodeSpec;
+/**
+ * A list item node spec.
+ *
+ * @since 0.1.0
+ * @category specs
+ */
+export declare const listItem: NodeSpec;
+/**
+ * Convenience function for adding list-related node types to a map
+ * specifying the nodes for a schema.
+ *
+ * @since 0.1.0
+ * @category specs
+ */
+export declare function addListNodes(nodes: OrderedMap<NodeSpec>, itemContent: string, listGroup?: string): OrderedMap<NodeSpec>;
+/**
+ * Returns a command function that wraps the selection in a list with
+ * the given type and attributes.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare function wrapInList(listType: NodeType, attrs?: Attrs | null): Command;
+/**
+ * Try to wrap the given node range in a list of the given type.
+ * Return `true` when this is possible, `false` otherwise. When `tr` is
+ * non-null, the wrapping is added to that transaction.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare function wrapRangeInList(tr: Transaction | null, range: NodeRange, listType: NodeType, attrs?: Attrs | null): boolean;
+/**
+ * Build a command that splits a non-empty textblock at the top level
+ * of a list item by also splitting that list item.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare function splitListItem(itemType: NodeType | ReadonlyArray<NodeType>, itemAttrs?: Attrs): Command;
+/**
+ * Acts like `splitListItem`, but without resetting the set of active
+ * marks at the cursor.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare function splitListItemKeepMarks(itemType: NodeType | ReadonlyArray<NodeType>, itemAttrs?: Attrs): Command;
+/**
+ * Create a command to lift the list item around the selection up into
+ * a wrapping list.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare function liftListItem(itemType: NodeType | ReadonlyArray<NodeType>): Command;
+/**
+ * Create a command to sink the list item around the selection down
+ * into an inner list.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare function sinkListItem(itemType: NodeType | ReadonlyArray<NodeType>): Command;

package/dist/compat/schema-list.js

@@ -0,0 +1,156 @@
+import { liftListItem as liftListItem$1, sinkListItem as sinkListItem$1, splitListItem as splitListItem$1, splitListItemKeepMarks as splitListItemKeepMarks$1, wrapInList as wrapInList$1, wrapRangeInList as wrapRangeInList$1 } from "../schema-list/commands.js";
+import { fromCoreCommand } from "./state.js";
+import { CORE } from "./internal/core.js";
+import { NodeType } from "./model.js";
+// src/compat/schema-list.ts
+/**
+* A `prosemirror-schema-list`-compatible module: list node specs,
+* `addListNodes`, and the list commands (bridged to the core
+* `@thomasfosterau/effect-richtext/schema-list` commands).
+*
+* Ported from prosemirror-schema-list (MIT, Marijn Haverbeke and others).
+*
+* @since 0.1.0
+*/
+const olDOM = ["ol", 0];
+const ulDOM = ["ul", 0];
+const liDOM = ["li", 0];
+/**
+* An ordered list node spec.
+*
+* @since 0.1.0
+* @category specs
+*/
+const orderedList = {
+	attrs: { order: {
+		default: 1,
+		validate: "number"
+	} },
+	parseDOM: [{
+		tag: "ol",
+		getAttrs(dom) {
+			return { order: dom.hasAttribute("start") ? +dom.getAttribute("start") : 1 };
+		}
+	}],
+	toDOM(node) {
+		return node.attrs.order == 1 ? olDOM : [
+			"ol",
+			{ start: node.attrs.order },
+			0
+		];
+	}
+};
+/**
+* A bullet list node spec.
+*
+* @since 0.1.0
+* @category specs
+*/
+const bulletList = {
+	parseDOM: [{ tag: "ul" }],
+	toDOM() {
+		return ulDOM;
+	}
+};
+/**
+* A list item node spec.
+*
+* @since 0.1.0
+* @category specs
+*/
+const listItem = {
+	parseDOM: [{ tag: "li" }],
+	toDOM() {
+		return liDOM;
+	},
+	defining: true
+};
+function add(obj, props) {
+	const copy = {};
+	for (const prop in obj) copy[prop] = obj[prop];
+	for (const prop in props) copy[prop] = props[prop];
+	return copy;
+}
+/**
+* Convenience function for adding list-related node types to a map
+* specifying the nodes for a schema.
+*
+* @since 0.1.0
+* @category specs
+*/
+function addListNodes(nodes, itemContent, listGroup) {
+	return nodes.append({
+		ordered_list: add(orderedList, {
+			content: "list_item+",
+			group: listGroup
+		}),
+		bullet_list: add(bulletList, {
+			content: "list_item+",
+			group: listGroup
+		}),
+		list_item: add(listItem, { content: itemContent })
+	});
+}
+/**
+* Returns a command function that wraps the selection in a list with
+* the given type and attributes.
+*
+* @since 0.1.0
+* @category commands
+*/
+function wrapInList(listType, attrs = null) {
+	return fromCoreCommand(wrapInList$1(listType[CORE], attrs));
+}
+/**
+* Try to wrap the given node range in a list of the given type.
+* Return `true` when this is possible, `false` otherwise. When `tr` is
+* non-null, the wrapping is added to that transaction.
+*
+* @since 0.1.0
+* @category commands
+*/
+function wrapRangeInList(tr, range, listType, attrs = null) {
+	return wrapRangeInList$1(tr ? tr[CORE] : null, range[CORE], listType[CORE], attrs);
+}
+const coreItemTypes = (itemType) => itemType instanceof NodeType ? itemType[CORE] : itemType.map((t) => t[CORE]);
+/**
+* Build a command that splits a non-empty textblock at the top level
+* of a list item by also splitting that list item.
+*
+* @since 0.1.0
+* @category commands
+*/
+function splitListItem(itemType, itemAttrs) {
+	return fromCoreCommand(splitListItem$1(coreItemTypes(itemType), itemAttrs));
+}
+/**
+* Acts like `splitListItem`, but without resetting the set of active
+* marks at the cursor.
+*
+* @since 0.1.0
+* @category commands
+*/
+function splitListItemKeepMarks(itemType, itemAttrs) {
+	return fromCoreCommand(splitListItemKeepMarks$1(coreItemTypes(itemType), itemAttrs));
+}
+/**
+* Create a command to lift the list item around the selection up into
+* a wrapping list.
+*
+* @since 0.1.0
+* @category commands
+*/
+function liftListItem(itemType) {
+	return fromCoreCommand(liftListItem$1(coreItemTypes(itemType)));
+}
+/**
+* Create a command to sink the list item around the selection down
+* into an inner list.
+*
+* @since 0.1.0
+* @category commands
+*/
+function sinkListItem(itemType) {
+	return fromCoreCommand(sinkListItem$1(coreItemTypes(itemType)));
+}
+export { addListNodes, bulletList, liftListItem, listItem, orderedList, sinkListItem, splitListItem, splitListItemKeepMarks, wrapInList, wrapRangeInList };