@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/model/to_dom.js

@@ -0,0 +1,238 @@
+import { attempt } from "../internal/attempt.js";
+import { DOMSpecError } from "./errors.js";
+import * as Option from "effect/Option";
+// src/model/to_dom.ts
+/**
+* A DOM serializer knows how to convert nodes and marks of various
+* types to DOM nodes.
+*
+* The serialization methods are synchronous and infallible for valid
+* specs. An invalid output spec returned by a `toDOM` function is a
+* programming error: the serialization methods then throw a
+* `DOMSpecError` (a defect). Use [`renderSpec`](#DOMSerializer.renderSpec)
+* to check specs in the Effect error channel.
+*
+* @since 0.1.0
+* @category models
+*/
+var DOMSerializer = class DOMSerializer {
+	/**
+	* Create a serializer. `nodes` should map node names to functions
+	* that take a node and return a description of the corresponding
+	* DOM. `marks` does the same for mark names, but also gets an
+	* argument that tells it whether the mark's content is block or
+	* inline content (for typical use, it'll always be inline). A mark
+	* serializer may be `null` to indicate that marks of that type
+	* should not be serialized.
+	*/
+	constructor(nodes, marks) {
+		this.nodes = nodes;
+		this.marks = marks;
+	}
+	/**
+	* Serialize the content of this fragment to a DOM fragment. When
+	* not in the browser, the `document` option, containing a DOM
+	* document, should be passed so that the serializer can create
+	* nodes.
+	*
+	* Throws a `DOMSpecError` (as a defect) for invalid output specs.
+	*/
+	serializeFragment(fragment, options = {}, target) {
+		if (!target) target = doc(options).createDocumentFragment();
+		let top = target;
+		const active = [];
+		fragment.forEach((node) => {
+			if (active.length || node.marks.length) {
+				let keep = 0, rendered = 0;
+				while (keep < active.length && rendered < node.marks.length) {
+					const next = node.marks[rendered];
+					if (!this.marks[next.type.name]) {
+						rendered++;
+						continue;
+					}
+					if (!next.eq(active[keep][0]) || next.type.spec.spanning === false) break;
+					keep++;
+					rendered++;
+				}
+				while (keep < active.length) top = active.pop()[1];
+				while (rendered < node.marks.length) {
+					const add = node.marks[rendered++];
+					const markDOM = this.serializeMarkOrNull(add, node.isInline, options);
+					if (markDOM) {
+						active.push([add, top]);
+						top.appendChild(markDOM.dom);
+						top = markDOM.contentDOM || markDOM.dom;
+					}
+				}
+			}
+			top.appendChild(this.serializeNodeInner(node, options));
+		});
+		return target;
+	}
+	/** @internal */
+	serializeNodeInner(node, options) {
+		if (node.isText) return doc(options).createTextNode(node.text);
+		const toDOM = this.nodes[node.type.name];
+		if (!toDOM) throw new DOMSpecError({ message: `No serializer for node type ${node.type.name}` });
+		const { contentDOM, dom } = renderSpecInner(doc(options), toDOM(node), null, node.attrs);
+		if (contentDOM) {
+			if (node.isLeaf) throw new DOMSpecError({ message: "Content hole not allowed in a leaf node spec" });
+			this.serializeFragment(node.content, options, contentDOM);
+		}
+		return dom;
+	}
+	/**
+	* Serialize this node to a DOM node. This can be useful when you
+	* need to serialize a part of a document, as opposed to the whole
+	* document. To serialize a whole document, use
+	* [`serializeFragment`](#DOMSerializer.serializeFragment) on its
+	* `content`.
+	*
+	* Throws a `DOMSpecError` (as a defect) for invalid output specs.
+	*/
+	serializeNode(node, options = {}) {
+		let dom = this.serializeNodeInner(node, options);
+		for (let i = node.marks.length - 1; i >= 0; i--) {
+			const wrap = this.serializeMarkOrNull(node.marks[i], node.isInline, options);
+			if (wrap) {
+				(wrap.contentDOM || wrap.dom).appendChild(dom);
+				dom = wrap.dom;
+			}
+		}
+		return dom;
+	}
+	/**
+	* Serialize a mark. Returns `None` when there is no serializer for
+	* the mark's type.
+	*
+	* Throws a `DOMSpecError` (as a defect) for invalid output specs.
+	*/
+	serializeMark(mark, inline, options = {}) {
+		return Option.fromNullishOr(this.serializeMarkOrNull(mark, inline, options));
+	}
+	/** @internal */
+	serializeMarkOrNull(mark, inline, options = {}) {
+		const toDOM = this.marks[mark.type.name];
+		return toDOM ? renderSpecInner(doc(options), toDOM(mark, inline), null, mark.attrs) : null;
+	}
+	/**
+	* Render an [output spec](#DOMOutputSpec) to a DOM node. If the spec
+	* has a hole (zero) in it, `contentDOM` will point at the node with
+	* the hole. Fails with a `DOMSpecError` for invalid specs.
+	*/
+	static renderSpec(doc, structure, xmlNS = null) {
+		return attempt(() => DOMSerializer.renderSpecUnsafe(doc, structure, xmlNS), isDOMSpecError);
+	}
+	/**
+	* Like `renderSpec`, but throws a `DOMSpecError` for invalid specs.
+	* When `blockArraysIn` (usually the attributes of the node or mark
+	* being rendered) is given, arrays found in it are refused as specs.
+	*/
+	static renderSpecUnsafe(doc, structure, xmlNS = null, blockArraysIn) {
+		if (typeof structure == "string") return { dom: doc.createTextNode(structure) };
+		return renderSpecInner(doc, structure, xmlNS, blockArraysIn);
+	}
+	/**
+	* Build a serializer using the [`toDOM`](#NodeSpec.toDOM) properties
+	* in a schema's node and mark specs. The result is cached on the
+	* schema.
+	*/
+	static fromSchema(schema) {
+		return schema.cached.domSerializer || (schema.cached.domSerializer = new DOMSerializer(DOMSerializer.nodesFromSchema(schema), DOMSerializer.marksFromSchema(schema)));
+	}
+	/**
+	* Gather the serializers in a schema's node specs into an object.
+	* This can be useful as a base to build a custom serializer from.
+	*/
+	static nodesFromSchema(schema) {
+		const result = gatherToDOM(schema.nodes);
+		if (!result.text) result.text = (node) => node.text;
+		return result;
+	}
+	/** Gather the serializers in a schema's mark specs into an object. */
+	static marksFromSchema(schema) {
+		return gatherToDOM(schema.marks);
+	}
+};
+const isDOMSpecError = (u) => u instanceof DOMSpecError;
+function gatherToDOM(obj) {
+	const result = {};
+	for (const name in obj) {
+		const toDOM = obj[name].spec.toDOM;
+		if (toDOM) result[name] = toDOM;
+	}
+	return result;
+}
+function doc(options) {
+	return options.document || globalThis.document;
+}
+const suspiciousAttributeCache = /* @__PURE__ */ new WeakMap();
+function suspiciousAttributes(attrs) {
+	let value = suspiciousAttributeCache.get(attrs);
+	if (value === void 0) suspiciousAttributeCache.set(attrs, value = suspiciousAttributesInner(attrs));
+	return value;
+}
+function suspiciousAttributesInner(attrs) {
+	let result = null;
+	function scan(value) {
+		if (value && typeof value == "object") {
+			if (Array.isArray(value)) {
+				if (typeof value[0] == "string") {
+					if (!result) result = [];
+					result.push(value);
+				} else for (let i = 0; i < value.length; i++) scan(value[i]);
+			} else for (const prop in value) scan(value[prop]);
+		}
+	}
+	scan(attrs);
+	return result;
+}
+function renderSpecInner(doc, structure, xmlNS, blockArraysIn) {
+	if (structure.nodeType === 1) return { dom: structure };
+	if (structure.dom && structure.dom.nodeType === 1) return structure;
+	let tagName = structure[0], suspicious;
+	if (typeof tagName != "string") throw new DOMSpecError({ message: "Invalid array passed to renderSpec" });
+	if (blockArraysIn && (suspicious = suspiciousAttributes(blockArraysIn)) && suspicious.indexOf(structure) > -1) throw new DOMSpecError({ message: "Using an array from an attribute object as a DOM spec. This may be an attempted cross site scripting attack." });
+	const space = tagName.indexOf(" ");
+	if (space > 0) {
+		xmlNS = tagName.slice(0, space);
+		tagName = tagName.slice(space + 1);
+	}
+	let contentDOM;
+	const dom = xmlNS ? doc.createElementNS(xmlNS, tagName) : doc.createElement(tagName);
+	const spec = structure;
+	const attrs = spec[1];
+	let start = 1;
+	if (attrs && typeof attrs == "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
+		start = 2;
+		for (const name in attrs) if (attrs[name] != null) {
+			const space = name.indexOf(" ");
+			if (space > 0) dom.setAttributeNS(name.slice(0, space), name.slice(space + 1), attrs[name]);
+			else if (name == "style" && dom.style) dom.style.cssText = attrs[name];
+			else dom.setAttribute(name, attrs[name]);
+		}
+	}
+	for (let i = start; i < spec.length; i++) {
+		const child = spec[i];
+		if (child === 0) {
+			if (i < spec.length - 1 || i > start) throw new DOMSpecError({ message: "Content hole must be the only child of its parent node" });
+			return {
+				dom,
+				contentDOM: dom
+			};
+		} else if (typeof child == "string") dom.appendChild(doc.createTextNode(child));
+		else {
+			const { contentDOM: innerContent, dom: inner } = renderSpecInner(doc, child, xmlNS, blockArraysIn);
+			dom.appendChild(inner);
+			if (innerContent) {
+				if (contentDOM) throw new DOMSpecError({ message: "Multiple content holes" });
+				contentDOM = innerContent;
+			}
+		}
+	}
+	return {
+		dom,
+		contentDOM
+	};
+}
+export { DOMSerializer };

package/dist/model.d.ts

@@ -0,0 +1,12 @@
+import { ContentExpr, ContentInput, ContentMatch, MatchEdge, content_d_exports } from "./model/content.js";
+import { AttributeError, ContentError, DOMSpecError, JSONError, ModelError, PositionError, ReplaceError, SchemaDefinitionError, isModelError } from "./model/errors.js";
+import { Fragment, NodeVisitor } from "./model/fragment.js";
+import { DOMParser, DOMPosition, GenericParseRule, ParseOptions, ParseRule, RuleContext, StyleParseRule, TagParseRule } from "./model/from_dom.js";
+import { DocFromJSON, NodeFromJSON, fragmentFromJSON, markFromJSON, nodeFromJSON, sliceFromJSON } from "./model/json.js";
+import { Mark, MarkJSON } from "./model/mark.js";
+import { ChildInfo, Node, NodeJSON, TextNode } from "./model/node.js";
+import { Slice, SliceJSON, replace } from "./model/replace.js";
+import { NodeRange, ResolvedPos } from "./model/resolvedpos.js";
+import { AnySchema, Attribute, AttributeDefinition, AttributeDefinitions, AttributeSpec, AttributeType, Attrs, AttrsInputOfSpec, AttrsOfSpec, AttrsOptional, ChildNames, ContentRefsOf, DocSchema, FragmentInput, GroupsOf, MarkAttrs, MarkAttrsInput, MarkNames, MarkSpec, MarkSpecOf, MarkSpecs, MarkSpecsOf, MarkType, MarksInGroup, MarksInput, MarksWithOptionalAttrs, NodeAttrs, NodeAttrsInput, NodeNames, NodeSpec, NodeSpecOf, NodeSpecs, NodeSpecsOf, NodeType, NodesInGroup, NodesWithOptionalAttrs, ResolveRefs, SchemaSpec, SchemaSpecCheck, checkAttrs, computeAttrs, make, makeUnsafe, markSpec, nodeSpec } from "./model/schema.js";
+import { DOMOutputSpec, DOMSerializer, MarkSerializer, NodeSerializer, RenderedSpec, SerializeOptions } from "./model/to_dom.js";
+export { AnySchema, Attribute, AttributeDefinition, AttributeDefinitions, AttributeError, AttributeSpec, AttributeType, Attrs, AttrsInputOfSpec, AttrsOfSpec, AttrsOptional, ChildInfo, ChildNames, content_d_exports as Content, ContentError, type ContentExpr, type ContentInput, ContentMatch, ContentRefsOf, DOMOutputSpec, DOMParser, DOMPosition, DOMSerializer, DOMSpecError, DocFromJSON, DocSchema, Fragment, FragmentInput, GenericParseRule, GroupsOf, JSONError, Mark, MarkAttrs, MarkAttrsInput, MarkJSON, MarkNames, MarkSerializer, MarkSpec, MarkSpecOf, MarkSpecs, MarkSpecsOf, MarkType, MarksInGroup, MarksInput, MarksWithOptionalAttrs, type MatchEdge, ModelError, Node, NodeAttrs, NodeAttrsInput, NodeFromJSON, NodeJSON, NodeNames, NodeRange, NodeSerializer, NodeSpec, NodeSpecOf, NodeSpecs, NodeSpecsOf, NodeType, NodeVisitor, NodesInGroup, NodesWithOptionalAttrs, ParseOptions, ParseRule, PositionError, RenderedSpec, ReplaceError, ResolveRefs, ResolvedPos, RuleContext, SchemaDefinitionError, SchemaSpec, SchemaSpecCheck, SerializeOptions, Slice, SliceJSON, StyleParseRule, TagParseRule, TextNode, checkAttrs, computeAttrs, fragmentFromJSON, isModelError, make, makeUnsafe, markFromJSON, markSpec, nodeFromJSON, nodeSpec, replace, sliceFromJSON };

package/dist/model.js

@@ -0,0 +1,12 @@
+import { ContentMatch, content_exports } from "./model/content.js";
+import { AttributeError, ContentError, DOMSpecError, JSONError, PositionError, ReplaceError, SchemaDefinitionError, isModelError } from "./model/errors.js";
+import { Fragment } from "./model/fragment.js";
+import { DOMParser } from "./model/from_dom.js";
+import { DocFromJSON, NodeFromJSON, fragmentFromJSON, markFromJSON, nodeFromJSON, sliceFromJSON } from "./model/json.js";
+import { Mark } from "./model/mark.js";
+import { Node, TextNode } from "./model/node.js";
+import { Slice, replace } from "./model/replace.js";
+import { NodeRange, ResolvedPos } from "./model/resolvedpos.js";
+import { Attribute, DocSchema, MarkType, NodeType, checkAttrs, computeAttrs, make, makeUnsafe, markSpec, nodeSpec } from "./model/schema.js";
+import { DOMSerializer } from "./model/to_dom.js";
+export { Attribute, AttributeError, content_exports as Content, ContentError, ContentMatch, DOMParser, DOMSerializer, DOMSpecError, DocFromJSON, DocSchema, Fragment, JSONError, Mark, MarkType, Node, NodeFromJSON, NodeRange, NodeType, PositionError, ReplaceError, ResolvedPos, SchemaDefinitionError, Slice, TextNode, checkAttrs, computeAttrs, fragmentFromJSON, isModelError, make, makeUnsafe, markFromJSON, markSpec, nodeFromJSON, nodeSpec, replace, sliceFromJSON };

package/dist/placeholder.d.ts

@@ -0,0 +1,53 @@
+import { AnySchema } from "./model/schema.js";
+import { Node } from "./model/node.js";
+import "./model.js";
+import { EditorState } from "./state/state.js";
+import { Plugin } from "./state/plugin.js";
+import "./state.js";
+/**
+ * Where to show the placeholder:
+ *
+ * - `"doc"`: only when the whole document is empty (consists of a
+ *   single empty textblock), on that textblock.
+ * - `"block"`: on the empty textblock that holds the cursor (which
+ *   includes the case of an empty document).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PlaceholderStrategy = "doc" | "block";
+/**
+ * Options for `placeholder`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface PlaceholderOptions<Sc extends AnySchema = AnySchema> {
+  /**
+   * The placeholder text, or a function computing it from the state and
+   * the empty textblock (and its position).
+   */
+  readonly placeholder: string | ((state: EditorState<Sc, any, any>, node: Node<Sc>, pos: number) => string);
+  /** Where to show the placeholder. Defaults to `"doc"`. */
+  readonly strategy?: PlaceholderStrategy | undefined;
+  /** The class added to the empty textblock. Defaults to `"is-empty"`. */
+  readonly className?: string | undefined;
+}
+/**
+ * Create a placeholder plugin, which adds node decorations to empty
+ * textblocks: a `data-placeholder` attribute holding the placeholder
+ * text and a class (`is-empty` by default). Use CSS (for example
+ * `placeholderCSS`) to show the text.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const placeholder: <Sc extends AnySchema = AnySchema>(options: PlaceholderOptions<Sc>) => Plugin<undefined, Sc>;
+/**
+ * A default stylesheet that shows the placeholder text (in grey) for
+ * textblocks with the default `is-empty` class.
+ *
+ * @since 0.1.0
+ * @category styles
+ */
+export declare const placeholderCSS: string;

package/dist/placeholder.js

@@ -0,0 +1,79 @@
+import { Plugin } from "./state/plugin.js";
+import { Decoration, DecorationSet } from "./view/decoration.js";
+import * as Predicate from "effect/Predicate";
+// src/placeholder.ts
+/**
+* Placeholder text for empty documents or empty textblocks.
+*
+* The plugin only adds node decorations: the empty textblock gets a
+* `data-placeholder` attribute holding the text and a class (`is-empty`
+* by default). Showing the text is left to CSS; `placeholderCSS` is a
+* small default stylesheet.
+*
+* ```ts skip-type-checking
+* const plugins = [placeholder({ placeholder: "Write something…" })]
+* ```
+*
+* @since 0.1.0
+*/
+const isEmptyTextblock = (node) => node.isTextblock && node.content.size === 0;
+/**
+* Find the empty textblock (and its position) a placeholder should be
+* shown on with the given strategy, if any.
+*/
+const findEmptyBlock = (state, strategy) => {
+	const doc = state.doc;
+	if (strategy === "doc") {
+		if (doc.childCount !== 1) return null;
+		const first = doc.content.content[0];
+		return isEmptyTextblock(first) ? {
+			node: first,
+			pos: 0
+		} : null;
+	}
+	const { $from, empty } = state.selection;
+	if (!empty || $from.depth === 0) return null;
+	const parent = $from.parent;
+	return isEmptyTextblock(parent) ? {
+		node: parent,
+		pos: $from.beforeUnsafe()
+	} : null;
+};
+/**
+* Create a placeholder plugin, which adds node decorations to empty
+* textblocks: a `data-placeholder` attribute holding the placeholder
+* text and a class (`is-empty` by default). Use CSS (for example
+* `placeholderCSS`) to show the text.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const placeholder = (options) => {
+	const strategy = options.strategy ?? "doc";
+	const className = options.className ?? "is-empty";
+	return new Plugin({ props: { decorations(state) {
+		const found = findEmptyBlock(state, strategy);
+		if (!found) return null;
+		const text = Predicate.isFunction(options.placeholder) ? options.placeholder(state, found.node, found.pos) : options.placeholder;
+		return DecorationSet.create(state.doc, [Decoration.node(found.pos, found.pos + found.node.nodeSize, {
+			class: className,
+			"data-placeholder": text
+		})]);
+	} } });
+};
+/**
+* A default stylesheet that shows the placeholder text (in grey) for
+* textblocks with the default `is-empty` class.
+*
+* @since 0.1.0
+* @category styles
+*/
+const placeholderCSS = `.ProseMirror .is-empty[data-placeholder]::before {
+  content: attr(data-placeholder);
+  float: left;
+  height: 0;
+  color: #adb5bd;
+  pointer-events: none;
+}
+`;
+export { placeholder, placeholderCSS };

package/dist/reactive/observer.d.ts

@@ -0,0 +1,54 @@
+import { AnySchema } from "../model/schema.js";
+import "../model.js";
+import { EditorView } from "../view/view.js";
+import "../view.js";
+import { EditorStreams } from "./streams.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Scope from "effect/Scope";
+declare namespace observer_d_exports {
+  export { EditorObserver, EditorObserverTypeId, make };
+}
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+export declare const EditorObserverTypeId: unique symbol;
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+export type EditorObserverTypeId = typeof EditorObserverTypeId;
+/**
+ * Reactive streams following the state of an editor view (see
+ * `EditorStreams`), plus its focus.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface EditorObserver<Sc extends AnySchema = AnySchema, R = never, E = never> extends EditorStreams<Sc, R, E> {
+  readonly [EditorObserverTypeId]: EditorObserverTypeId;
+  /** The observed view. */
+  readonly view: EditorView<Sc, R, E>;
+  /** Whether the view has focus: the current value, then every change. */
+  readonly focus: Stream.Stream<boolean>;
+}
+/**
+ * Observe an editor view. The observer registers a listener with
+ * `view.subscribe` and focus listeners on `view.dom`, and removes them
+ * (ending all its streams) when the scope closes. It doesn't change the
+ * view's props or plugins.
+ *
+ * ```ts skip-type-checking
+ * const observer = yield* EditorObserver.make(view)
+ * yield* observer.isMarkActive("strong").pipe(
+ *   Stream.runForEach((active) => Effect.sync(() => button.classList.toggle("active", active))),
+ *   Effect.forkScoped
+ * )
+ * ```
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: <Sc extends AnySchema, R, E>(view: EditorView<Sc, R, E>) => Effect.Effect<EditorObserver<Sc, R, E>, never, Scope.Scope>;
+export { observer_d_exports };

package/dist/reactive/observer.js

@@ -0,0 +1,61 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { acquireRef, acquireSource, publishTransactions, setRefUnsafe, setState, streamsOf } from "./streams.js";
+import * as Effect from "effect/Effect";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+// src/reactive/observer.ts
+/**
+* `EditorObserver`: reactive streams for an `EditorView`.
+*
+* @since 0.1.0
+*/
+var observer_exports = /* @__PURE__ */ __exportAll({
+	EditorObserverTypeId: () => EditorObserverTypeId,
+	make: () => make
+});
+/**
+* @since 0.1.0
+* @category symbols
+*/
+const EditorObserverTypeId = Symbol.for("effect-richtext/reactive/EditorObserver");
+/**
+* Observe an editor view. The observer registers a listener with
+* `view.subscribe` and focus listeners on `view.dom`, and removes them
+* (ending all its streams) when the scope closes. It doesn't change the
+* view's props or plugins.
+*
+* ```ts skip-type-checking
+* const observer = yield* EditorObserver.make(view)
+* yield* observer.isMarkActive("strong").pipe(
+*   Stream.runForEach((active) => Effect.sync(() => button.classList.toggle("active", active))),
+*   Effect.forkScoped
+* )
+* ```
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (view) => Effect.gen(function* () {
+	const source = yield* acquireSource(view.state);
+	const focused = yield* acquireRef(view.hasFocus());
+	yield* Effect.acquireRelease(Effect.sync(() => view.subscribe((update) => {
+		setState(source, view.state);
+		publishTransactions(source, update.transactions, update.state, update.prevState);
+	})), (unsubscribe) => Effect.sync(unsubscribe));
+	const setFocus = (value) => setRefUnsafe(focused, value);
+	const onFocusIn = () => setFocus(true);
+	const onFocusOut = (event) => setFocus(!!event.relatedTarget && view.dom.contains(event.relatedTarget));
+	yield* Effect.acquireRelease(Effect.sync(() => {
+		view.dom.addEventListener("focusin", onFocusIn);
+		view.dom.addEventListener("focusout", onFocusOut);
+	}), () => Effect.sync(() => {
+		view.dom.removeEventListener("focusin", onFocusIn);
+		view.dom.removeEventListener("focusout", onFocusOut);
+	}));
+	return {
+		[EditorObserverTypeId]: EditorObserverTypeId,
+		...streamsOf(source, view),
+		view,
+		focus: SubscriptionRef.changes(focused)
+	};
+});
+export { EditorObserverTypeId, make, observer_exports };

package/dist/reactive/selectors.d.ts

@@ -0,0 +1,22 @@
+import { AnySchema, Attrs, MarkType, NodeType } from "../model/schema.js";
+import "../model.js";
+import { EditorState } from "../state/state.js";
+import "../state.js";
+/**
+ * Whether a mark of the given type is active: for an empty selection, it
+ * is in the stored marks (or the marks at the cursor); otherwise it is
+ * present somewhere in one of the selection's ranges.
+ *
+ * @since 0.1.0
+ * @category selectors
+ */
+export declare const isMarkActive: <Sc extends AnySchema>(state: EditorState<Sc, any, any>, type: MarkType<Sc, any> | string) => boolean;
+/**
+ * Whether a node of the given type (with the given attributes, when
+ * provided) is selected (as a node selection) or wraps the start of the
+ * selection.
+ *
+ * @since 0.1.0
+ * @category selectors
+ */
+export declare const isNodeActive: <Sc extends AnySchema>(state: EditorState<Sc, any, any>, type: NodeType<Sc, any> | string, attrs?: Attrs) => boolean;

package/dist/reactive/selectors.js

@@ -0,0 +1,61 @@
+import { AttributeError, ContentError } from "../model/errors.js";
+import { NodeSelection } from "../state/selection.js";
+import * as Predicate from "effect/Predicate";
+// src/reactive/selectors.ts
+/**
+* Pure state selectors used by the reactive streams.
+*
+* @since 0.1.0
+*/
+const markTypeOf = (state, type) => {
+	if (!Predicate.isString(type)) return type;
+	const markType = state.schema.marks[type];
+	if (!markType) throw new AttributeError({ message: "Unknown mark type " + type });
+	return markType;
+};
+const nodeTypeOf = (state, type) => {
+	if (!Predicate.isString(type)) return type;
+	const nodeType = state.schema.nodes[type];
+	if (!nodeType) throw new ContentError({ message: "Unknown node type " + type });
+	return nodeType;
+};
+const attrsMatch = (attrs, expected) => {
+	if (!expected) return true;
+	for (const name in expected) if (attrs[name] !== expected[name]) return false;
+	return true;
+};
+/**
+* Whether a mark of the given type is active: for an empty selection, it
+* is in the stored marks (or the marks at the cursor); otherwise it is
+* present somewhere in one of the selection's ranges.
+*
+* @since 0.1.0
+* @category selectors
+*/
+const isMarkActive = (state, type) => {
+	const markType = markTypeOf(state, type);
+	const { empty, $from, ranges } = state.selection;
+	if (empty) return markType.findInSet(state.storedMarksOrNull || $from.marks()) !== void 0;
+	for (const range of ranges) if (state.doc.rangeHasMark(range.$from.pos, range.$to.pos, markType)) return true;
+	return false;
+};
+/**
+* Whether a node of the given type (with the given attributes, when
+* provided) is selected (as a node selection) or wraps the start of the
+* selection.
+*
+* @since 0.1.0
+* @category selectors
+*/
+const isNodeActive = (state, type, attrs) => {
+	const nodeType = nodeTypeOf(state, type);
+	const { selection } = state;
+	if (selection instanceof NodeSelection && selection.node.type === nodeType) return attrsMatch(selection.node.attrs, attrs);
+	const { $from, to } = selection;
+	for (let d = $from.depth; d >= 0; d--) {
+		const node = $from.node(d);
+		if (node.type === nodeType && to <= $from.end(d) && attrsMatch(node.attrs, attrs)) return true;
+	}
+	return false;
+};
+export { isMarkActive, isNodeActive };

package/dist/reactive/stateref.d.ts

@@ -0,0 +1,72 @@
+import { AnySchema } from "../model/schema.js";
+import "../model.js";
+import { StateFailure } from "../state/errors.js";
+import { Command, Transaction } from "../state/transaction.js";
+import { EditorState } from "../state/state.js";
+import "../state.js";
+import { EditorStreams } from "./streams.js";
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+declare namespace stateref_d_exports {
+  export { StateRef, StateRefTypeId, make };
+}
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+export declare const StateRefTypeId: unique symbol;
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+export type StateRefTypeId = typeof StateRefTypeId;
+/**
+ * An editor state held in a `SubscriptionRef`, updated by dispatching
+ * transactions to it, without an editor view. Useful for headless or
+ * server-side editing, and for tests.
+ *
+ * Dispatches are serialized and run the state's plugins with the context
+ * captured by `StateRef.make`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface StateRef<Sc extends AnySchema = AnySchema, R = never, E = never> extends EditorStreams<Sc, R, E> {
+  readonly [StateRefTypeId]: StateRefTypeId;
+  /**
+   * Apply a transaction to the current state, publishing the new state
+   * and the applied transactions. Fails with the errors of the plugin
+   * hooks, or a `StateError` when the transaction doesn't start from the
+   * current document.
+   */
+  readonly dispatch: (tr: Transaction<Sc>) => Effect.Effect<void, E | StateFailure>;
+  /**
+   * Like `dispatch`, but runs synchronously and throws failures. Throws a
+   * defect when a plugin hook is asynchronous.
+   */
+  readonly dispatchUnsafe: (tr: Transaction<Sc>) => void;
+  /** Replace the state (e.g. with a reconfigured one), without a transaction. */
+  readonly set: (state: EditorState<Sc, R, E>) => Effect.Effect<void>;
+  /**
+   * Run a command against the current state, dispatching its
+   * transactions. Succeeds with the command's result; fails when the
+   * command or one of its dispatches fails.
+   */
+  readonly execute: <CE, CR>(command: Command<Sc, CE, CR>) => Effect.Effect<boolean, CE | E | StateFailure, CR>;
+}
+/**
+ * Create a `StateRef` holding `initial`. The current context (providing
+ * the plugins' requirements `R`) is captured to run plugin hooks when
+ * transactions are dispatched. Its streams end when the scope closes.
+ *
+ * ```ts skip-type-checking
+ * const ref = yield* StateRef.make(EditorState.createUnsafe({ schema }))
+ * yield* ref.dispatch(ref.state.getUnsafe().tr.insertTextUnsafe("hi"))
+ * yield* ref.execute(toggleMark(schema.marks.strong))
+ * ```
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: <Sc extends AnySchema, R = never, E = never>(initial: EditorState<Sc, R, E>) => Effect.Effect<StateRef<Sc, R, E>, never, Scope.Scope | R>;
+export { stateref_d_exports };