@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/state/transaction.js

@@ -0,0 +1,195 @@
+import { attempt } from "../internal/attempt.js";
+import { Mark } from "../model/mark.js";
+import { isTransformOrModelError } from "../transform/errors.js";
+import { Transform } from "../transform/transform.js";
+import { SelectionError } from "./errors.js";
+import { Selection } from "./selection.js";
+import * as Option from "effect/Option";
+// src/state/transaction.ts
+const UPDATED_SEL = 1;
+const UPDATED_MARKS = 2;
+const UPDATED_SCROLL = 4;
+/**
+* An editor state transaction, which can be applied to a state to
+* create an updated state. Use `EditorState.tr` to create an instance.
+*
+* Transactions track changes to the document (they are a subclass of
+* `Transform`), but also other state changes, like selection updates and
+* adjustments of the set of stored marks. In addition, you can store
+* metadata properties in a transaction, which are extra pieces of
+* information that client code or plugins can use to describe what a
+* transaction represents, so that they can update their own state
+* accordingly.
+*
+* Like transforms, transactions are mutable builders.
+*
+* @since 0.1.0
+* @category models
+*/
+var Transaction = class extends Transform {
+	/** @internal */
+	constructor(state) {
+		super(state.doc);
+		this.curSelectionFor = 0;
+		this.updated = 0;
+		this.meta = Object.create(null);
+		this.time = Date.now();
+		this.curSelection = state.selection;
+		this.storedMarksOrNull = state.storedMarksOrNull;
+	}
+	/** The stored marks set by this transaction, if any. */
+	get storedMarks() {
+		return Option.fromNullishOr(this.storedMarksOrNull);
+	}
+	/**
+	* The transaction's current selection. This defaults to the editor
+	* selection mapped through the steps in the transaction, but can be
+	* overwritten with `setSelection`.
+	*/
+	get selection() {
+		if (this.curSelectionFor < this.steps.length) {
+			this.curSelection = this.curSelection.map(this.doc, this.mapping.slice(this.curSelectionFor));
+			this.curSelectionFor = this.steps.length;
+		}
+		return this.curSelection;
+	}
+	/**
+	* Update the transaction's current selection. Will determine the
+	* selection that the editor gets when the transaction is applied.
+	* Fails with a `SelectionError` when the selection doesn't point into
+	* the transaction's current document.
+	*/
+	setSelection(selection) {
+		return attempt(() => this.setSelectionUnsafe(selection), (u) => u instanceof SelectionError);
+	}
+	/** Like `setSelection`, but throws a `SelectionError` on failure. */
+	setSelectionUnsafe(selection) {
+		if (selection.$from.doc !== this.doc) throw new SelectionError({ message: "Selection passed to setSelection must point at the current document" });
+		this.curSelection = selection;
+		this.curSelectionFor = this.steps.length;
+		this.updated = (this.updated | UPDATED_SEL) & -3;
+		this.storedMarksOrNull = null;
+		return this;
+	}
+	/** Whether the selection was explicitly updated by this transaction. */
+	get selectionSet() {
+		return (this.updated & UPDATED_SEL) > 0;
+	}
+	/** Set the current stored marks. */
+	setStoredMarks(marks) {
+		this.storedMarksOrNull = marks;
+		this.updated |= UPDATED_MARKS;
+		return this;
+	}
+	/**
+	* Make sure the current stored marks or, if that is null, the marks at
+	* the selection, match the given set of marks. Does nothing if this is
+	* already the case.
+	*/
+	ensureMarks(marks) {
+		if (!Mark.sameSet(this.storedMarksOrNull || this.selection.$from.marks(), marks)) this.setStoredMarks(marks);
+		return this;
+	}
+	/** Add a mark to the set of stored marks. */
+	addStoredMark(mark) {
+		return this.ensureMarks(mark.addToSet(this.storedMarksOrNull || this.selection.$head.marks()));
+	}
+	/** Remove a mark or mark type from the set of stored marks. */
+	removeStoredMark(mark) {
+		const set = this.storedMarksOrNull || this.selection.$head.marks();
+		return this.ensureMarks(mark instanceof Mark ? mark.removeFromSet(set) : mark.removeFromSet(set));
+	}
+	/** Whether the stored marks were explicitly set for this transaction. */
+	get storedMarksSet() {
+		return (this.updated & UPDATED_MARKS) > 0;
+	}
+	/** @internal */
+	addStep(step, doc) {
+		super.addStep(step, doc);
+		this.updated = this.updated & -3;
+		this.storedMarksOrNull = null;
+	}
+	/** Update the timestamp for the transaction. */
+	setTime(time) {
+		this.time = time;
+		return this;
+	}
+	/** Replace the current selection with the given slice. */
+	replaceSelection(slice) {
+		this.selection.replace(this, slice);
+		return this;
+	}
+	/**
+	* Replace the selection with the given node. When `inheritMarks` is
+	* true and the content is inline, it inherits the marks from the place
+	* where it is inserted.
+	*/
+	replaceSelectionWith(node, inheritMarks = true) {
+		const selection = this.selection;
+		if (inheritMarks) node = node.mark(this.storedMarksOrNull || (selection.empty ? selection.$from.marks() : selection.$from.marksAcrossOrNull(selection.$to) || Mark.none));
+		selection.replaceWith(this, node);
+		return this;
+	}
+	/** Delete the selection. */
+	deleteSelection() {
+		this.selection.replace(this);
+		return this;
+	}
+	/**
+	* Replace the given range, or the selection if no range is given,
+	* with a text node containing the given string.
+	*/
+	insertText(text, from, to) {
+		return attempt(() => this.insertTextUnsafe(text, from, to), isTransformOrModelError);
+	}
+	/** Like `insertText`, but throws on failure (for example for positions outside of the document). */
+	insertTextUnsafe(text, from, to) {
+		const schema = this.doc.type.schema;
+		if (from == null) {
+			if (!text) return this.deleteSelection();
+			return this.replaceSelectionWith(schema.textUnsafe(text), true);
+		} else {
+			if (to == null) to = from;
+			if (!text) return this.deleteRangeUnsafe(from, to);
+			let marks = this.storedMarksOrNull;
+			if (!marks) {
+				const $from = this.doc.resolveUnsafe(from);
+				marks = to === from ? $from.marks() : $from.marksAcrossOrNull(this.doc.resolveUnsafe(to));
+			}
+			this.replaceRangeWithUnsafe(from, to, schema.textUnsafe(text, marks));
+			if (!this.selection.empty && this.selection.to === from + text.length) this.setSelectionUnsafe(Selection.near(this.selection.$to));
+			return this;
+		}
+	}
+	/** Store a metadata property in this transaction, keyed either by name or by plugin. */
+	setMeta(key, value) {
+		this.meta[typeof key === "string" ? key : key.key] = value;
+		return this;
+	}
+	/** Retrieve a metadata property for a given name or plugin, if it was set. */
+	getMeta(key) {
+		const name = typeof key === "string" ? key : key.key;
+		return name in this.meta ? Option.some(this.meta[name]) : Option.none();
+	}
+	/**
+	* Returns true if this transaction doesn't contain any metadata, and
+	* can thus safely be extended.
+	*/
+	get isGeneric() {
+		for (const _ in this.meta) return false;
+		return true;
+	}
+	/**
+	* Indicate that the editor should scroll the selection into view when
+	* updated to the state produced by this transaction.
+	*/
+	scrollIntoView() {
+		this.updated |= UPDATED_SCROLL;
+		return this;
+	}
+	/** True when this transaction has had `scrollIntoView` called on it. */
+	get scrolledIntoView() {
+		return (this.updated & UPDATED_SCROLL) > 0;
+	}
+};
+export { Transaction };

package/dist/state.d.ts

@@ -0,0 +1,6 @@
+import { SelectionError, StateError, StateFailure, isStateFailure } from "./state/errors.js";
+import { AnyPlugin, EditorViewLike, MaybeEffect, Plugin, PluginErrors, PluginKey, PluginProps, PluginRequirements, PluginSpec, PluginTypeId, PluginView, StateField, getField } from "./state/plugin.js";
+import { AllSelection, NodeSelection, Selection, SelectionBookmark, SelectionDeserializer, SelectionFromJSON, SelectionJSON, SelectionRange, TextSelection } from "./state/selection.js";
+import { ApplyResult, Configuration, EditorState, EditorStateConfig, EditorStateJSON, EditorStateTypeId, runSyncUnsafe } from "./state/state.js";
+import { Command, Dispatch, MetaKey, Transaction } from "./state/transaction.js";
+export { AllSelection, AnyPlugin, ApplyResult, Command, Configuration, Dispatch, EditorState, EditorStateConfig, EditorStateJSON, EditorStateTypeId, EditorViewLike, MaybeEffect, MetaKey, NodeSelection, Plugin, PluginErrors, PluginKey, PluginProps, PluginRequirements, PluginSpec, PluginTypeId, PluginView, Selection, SelectionBookmark, SelectionDeserializer, SelectionError, SelectionFromJSON, SelectionJSON, SelectionRange, StateError, StateFailure, StateField, TextSelection, Transaction, getField, isStateFailure, runSyncUnsafe };

package/dist/state.js

@@ -0,0 +1,6 @@
+import { SelectionError, StateError, isStateFailure } from "./state/errors.js";
+import { Plugin, PluginKey, PluginTypeId, getField } from "./state/plugin.js";
+import { AllSelection, NodeSelection, Selection, SelectionFromJSON, SelectionRange, TextSelection } from "./state/selection.js";
+import { Configuration, EditorState, EditorStateTypeId, runSyncUnsafe } from "./state/state.js";
+import { Transaction } from "./state/transaction.js";
+export { AllSelection, Configuration, EditorState, EditorStateTypeId, NodeSelection, Plugin, PluginKey, PluginTypeId, Selection, SelectionError, SelectionFromJSON, SelectionRange, StateError, TextSelection, Transaction, getField, isStateFailure, runSyncUnsafe };