@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/state/state.js

@@ -0,0 +1,489 @@
+import { StateError } from "./errors.js";
+import { Selection } from "./selection.js";
+import { Transaction } from "./transaction.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+// src/state/state.ts
+/**
+* The editor state.
+*
+* @since 0.1.0
+*/
+const baseFields = [
+	{
+		name: "doc",
+		self: void 0,
+		init(config) {
+			if (config.doc) return config.doc;
+			const node = config.schema.topNodeType.createAndFillOrNull();
+			if (!node) throw new StateError({ message: "Can't create a default document for the schema" });
+			return node;
+		},
+		apply(tr) {
+			return tr.doc;
+		}
+	},
+	{
+		name: "selection",
+		self: void 0,
+		init(config, instance) {
+			return config.selection || Selection.atStart(instance.doc);
+		},
+		apply(tr) {
+			return tr.selection;
+		}
+	},
+	{
+		name: "storedMarks",
+		self: void 0,
+		init(config) {
+			return config.storedMarks || null;
+		},
+		apply(tr, _marks, _old, state) {
+			return state.selection.$cursorOrNull ? tr.storedMarksOrNull : null;
+		}
+	},
+	{
+		name: "scrollToSelection",
+		self: void 0,
+		init() {
+			return 0;
+		},
+		apply(tr, prev) {
+			return tr.scrolledIntoView ? prev + 1 : prev;
+		}
+	}
+];
+/**
+* Object wrapping the part of a state object that stays the same across
+* transactions. Stored in the state's `config` property.
+*
+* @internal
+*/
+var Configuration = class {
+	constructor(schema, plugins) {
+		this.schema = schema;
+		this.plugins = [];
+		this.pluginsByKey = Object.create(null);
+		this.fields = baseFields.slice();
+		if (plugins) plugins.forEach((plugin) => {
+			if (this.pluginsByKey[plugin.key]) throw new StateError({ message: "Adding different instances of a keyed plugin (" + plugin.key + ")" });
+			this.plugins.push(plugin);
+			this.pluginsByKey[plugin.key] = plugin;
+			const state = plugin.spec.state;
+			if (state) this.fields.push({
+				name: plugin.key,
+				self: plugin,
+				init: state.init,
+				apply: state.apply
+			});
+		});
+	}
+};
+const isStateError = (u) => u instanceof StateError;
+function startCreate(config) {
+	const schema = config.doc ? config.doc.type.schema : config.schema;
+	if (!schema) throw new StateError({ message: "Either `doc` or `schema` must be provided" });
+	const instance = new EditorState(new Configuration(schema, config.plugins));
+	return {
+		instance,
+		pending: instance.config.fields.findIndex((field) => Effect.isEffect(instance.slots[field.name] = field.init.call(field.self, config, instance)))
+	};
+}
+const finishCreate = (config, instance, pending) => Effect.gen(function* () {
+	for (const [i, field] of instance.config.fields.entries()) {
+		if (i < pending) continue;
+		const result = i === pending ? instance.slots[field.name] : yield* trySync(() => field.init.call(field.self, config, instance));
+		instance.slots[field.name] = Effect.isEffect(result) ? yield* result : result;
+	}
+	return instance;
+});
+/** Marker returned by the synchronous fast path when a hook returned an Effect. */
+const NeedsEffect = Symbol("effect-richtext/state/NeedsEffect");
+/** Lift a synchronous computation that may throw a `StateError` into an Effect. */
+const trySync = (f) => Effect.suspend(() => {
+	try {
+		return Effect.succeed(f());
+	} catch (e) {
+		return isStateError(e) ? Effect.fail(e) : Effect.die(e);
+	}
+});
+/**
+* Run an effect synchronously, throwing its (first) failure or defect.
+*
+* @internal
+*/
+const runSyncUnsafe = (effect) => {
+	const exit = Effect.runSyncExit(effect);
+	if (Exit.isSuccess(exit)) return exit.value;
+	throw Cause.squash(exit.cause);
+};
+/**
+* @since 0.1.0
+* @category symbols
+*/
+const EditorStateTypeId = Symbol.for("effect-richtext/state/EditorState");
+/**
+* The state of an editor is represented by an object of this type. A
+* state is a persistent data structure—it isn't updated, but rather a
+* new state value is computed from an old one using the `apply` method.
+*
+* A state holds a number of built-in fields, and plugins can define
+* additional fields.
+*
+* `R` and `E` are the unions of the requirements and errors of the
+* state's plugins: applying a transaction runs the plugins' hooks, so
+* `apply` returns an `Effect<EditorState<Sc, R, E>, E | StateError, R>`.
+* States whose plugins require no services (`R = never`) can also be
+* updated synchronously with `applyUnsafe`.
+*
+* @since 0.1.0
+* @category models
+*/
+var EditorState = class EditorState {
+	/** @internal */
+	constructor(config, slots = Object.create(null)) {
+		this.config = config;
+		this.slots = slots;
+	}
+	/** The current document. */
+	get doc() {
+		return this.slots.doc;
+	}
+	/** The selection. */
+	get selection() {
+		return this.slots.selection;
+	}
+	/** A set of marks to apply to the next input. `None` when no explicit marks have been set. */
+	get storedMarks() {
+		return Option.fromNullishOr(this.storedMarksOrNull);
+	}
+	/** @internal */
+	get storedMarksOrNull() {
+		return this.slots.storedMarks;
+	}
+	/** @internal */
+	get scrollToSelection() {
+		return this.slots.scrollToSelection;
+	}
+	/** The schema of the state's document. */
+	get schema() {
+		return this.config.schema;
+	}
+	/** The plugins that are active in this state. */
+	get plugins() {
+		return this.config.plugins;
+	}
+	/** Create a new transaction from this state. */
+	get tr() {
+		return new Transaction(this);
+	}
+	/** Apply the given transaction to produce a new state. */
+	apply(tr) {
+		return Effect.map(this.applyTransaction(tr), (r) => r.state);
+	}
+	/**
+	* Like `apply`, but runs synchronously, throwing failures. Only
+	* available for states whose plugins require no services; fails with
+	* a defect (thrown) when a plugin hook is asynchronous.
+	*/
+	applyUnsafe(tr) {
+		return this.applyTransactionUnsafe(tr).state;
+	}
+	/** @internal */
+	filterTransaction(tr, ignore = -1) {
+		const plugins = this.config.plugins;
+		const self = this;
+		return Effect.gen(function* () {
+			for (let i = 0; i < plugins.length; i++) {
+				if (i === ignore) continue;
+				const plugin = plugins[i], filter = plugin.spec.filterTransaction;
+				if (filter) {
+					const result = filter.call(plugin, tr, self);
+					if (!(Effect.isEffect(result) ? yield* result : result)) return false;
+				}
+			}
+			return true;
+		});
+	}
+	/**
+	* Verbose variant of `apply` that returns the precise transactions
+	* that were applied (which might be influenced by the transaction
+	* hooks of plugins) along with the new state.
+	*/
+	applyTransaction(rootTr) {
+		return Effect.suspend(() => {
+			let result;
+			try {
+				result = this.applyTransactionSync(rootTr);
+			} catch (e) {
+				return isStateError(e) ? Effect.fail(e) : Effect.die(e);
+			}
+			return result === NeedsEffect ? this.applyTransactionEffect(rootTr) : Effect.succeed(result);
+		});
+	}
+	/** @internal */
+	applyTransactionSync(rootTr) {
+		const filtered = this.filterTransactionSync(rootTr);
+		if (filtered === NeedsEffect) return NeedsEffect;
+		if (!filtered) return {
+			state: this,
+			transactions: []
+		};
+		const trs = [rootTr];
+		let newState = this.applyInnerSync(rootTr);
+		if (newState === NeedsEffect) return NeedsEffect;
+		let seen = null;
+		const plugins = this.config.plugins;
+		for (;;) {
+			let haveNew = false;
+			for (let i = 0; i < plugins.length; i++) {
+				const plugin = plugins[i], append = plugin.spec.appendTransaction;
+				if (append) {
+					const n = seen ? seen[i].n : 0, oldState = seen ? seen[i].state : this;
+					let tr = void 0;
+					if (n < trs.length) {
+						const result = append.call(plugin, n ? trs.slice(n) : trs, oldState, newState);
+						if (Effect.isEffect(result)) return NeedsEffect;
+						tr = result;
+					}
+					if (tr) {
+						const ok = newState.filterTransactionSync(tr, i);
+						if (ok === NeedsEffect) return NeedsEffect;
+						if (ok) {
+							tr.setMeta("appendedTransaction", rootTr);
+							if (!seen) {
+								seen = [];
+								for (let j = 0; j < plugins.length; j++) seen.push(j < i ? {
+									state: newState,
+									n: trs.length
+								} : {
+									state: this,
+									n: 0
+								});
+							}
+							trs.push(tr);
+							const next = newState.applyInnerSync(tr);
+							if (next === NeedsEffect) return NeedsEffect;
+							newState = next;
+							haveNew = true;
+						}
+					}
+					if (seen) seen[i] = {
+						state: newState,
+						n: trs.length
+					};
+				}
+			}
+			if (!haveNew) return {
+				state: newState,
+				transactions: trs
+			};
+		}
+	}
+	/** @internal */
+	filterTransactionSync(tr, ignore = -1) {
+		const plugins = this.config.plugins;
+		for (let i = 0; i < plugins.length; i++) {
+			if (i === ignore) continue;
+			const plugin = plugins[i], filter = plugin.spec.filterTransaction;
+			if (filter) {
+				const result = filter.call(plugin, tr, this);
+				if (Effect.isEffect(result)) return NeedsEffect;
+				if (!result) return false;
+			}
+		}
+		return true;
+	}
+	/** @internal */
+	applyInnerSync(tr) {
+		if (!tr.before.eq(this.doc)) throw new StateError({ message: "Applying a mismatched transaction" });
+		const newInstance = new EditorState(this.config), fields = this.config.fields;
+		for (let i = 0; i < fields.length; i++) {
+			const field = fields[i];
+			const result = field.apply.call(field.self, tr, this.slots[field.name], this, newInstance);
+			if (Effect.isEffect(result)) return NeedsEffect;
+			newInstance.slots[field.name] = result;
+		}
+		return newInstance;
+	}
+	/** @internal */
+	applyTransactionEffect(rootTr) {
+		const self = this;
+		return Effect.gen(function* () {
+			if (!(yield* self.filterTransaction(rootTr))) return {
+				state: self,
+				transactions: []
+			};
+			const trs = [rootTr];
+			let newState = yield* self.applyInner(rootTr);
+			let seen = null;
+			const plugins = self.config.plugins;
+			for (;;) {
+				let haveNew = false;
+				for (let i = 0; i < plugins.length; i++) {
+					const plugin = plugins[i], append = plugin.spec.appendTransaction;
+					if (append) {
+						const n = seen ? seen[i].n : 0, oldState = seen ? seen[i].state : self;
+						let tr = void 0;
+						if (n < trs.length) {
+							const result = append.call(plugin, n ? trs.slice(n) : trs, oldState, newState);
+							tr = Effect.isEffect(result) ? yield* result : result;
+						}
+						if (tr && (yield* newState.filterTransaction(tr, i))) {
+							tr.setMeta("appendedTransaction", rootTr);
+							if (!seen) {
+								seen = [];
+								for (let j = 0; j < plugins.length; j++) seen.push(j < i ? {
+									state: newState,
+									n: trs.length
+								} : {
+									state: self,
+									n: 0
+								});
+							}
+							trs.push(tr);
+							newState = yield* newState.applyInner(tr);
+							haveNew = true;
+						}
+						if (seen) seen[i] = {
+							state: newState,
+							n: trs.length
+						};
+					}
+				}
+				if (!haveNew) return {
+					state: newState,
+					transactions: trs
+				};
+			}
+		});
+	}
+	/** Like `applyTransaction`, but runs synchronously (see `applyUnsafe`). */
+	applyTransactionUnsafe(rootTr) {
+		const result = this.applyTransactionSync(rootTr);
+		return result === NeedsEffect ? runSyncUnsafe(this.applyTransactionEffect(rootTr)) : result;
+	}
+	/** @internal */
+	applyInner(tr) {
+		const self = this;
+		return Effect.gen(function* () {
+			if (!tr.before.eq(self.doc)) return yield* Effect.fail(new StateError({ message: "Applying a mismatched transaction" }));
+			const newInstance = new EditorState(self.config), fields = self.config.fields;
+			for (let i = 0; i < fields.length; i++) {
+				const field = fields[i];
+				const result = field.apply.call(field.self, tr, self.slots[field.name], self, newInstance);
+				newInstance.slots[field.name] = Effect.isEffect(result) ? yield* result : result;
+			}
+			return newInstance;
+		});
+	}
+	/**
+	* Create a new state based on this one, but with an adjusted set of
+	* active plugins. State fields that exist in both sets of plugins are
+	* kept unchanged. Those that no longer exist are dropped, and those
+	* that are new are initialized using their `init` method, passing in
+	* the new configuration object.
+	*/
+	reconfigure(config) {
+		const self = this;
+		return Effect.gen(function* () {
+			const $config = yield* trySync(() => new Configuration(self.schema, config.plugins));
+			const fields = $config.fields, instance = new EditorState($config);
+			for (let i = 0; i < fields.length; i++) {
+				const field = fields[i], name = field.name;
+				if (Object.prototype.hasOwnProperty.call(self.slots, name)) instance.slots[name] = self.slots[name];
+				else {
+					const result = field.init.call(field.self, config, instance);
+					instance.slots[name] = Effect.isEffect(result) ? yield* result : result;
+				}
+			}
+			return instance;
+		});
+	}
+	/** Like `reconfigure`, but runs synchronously (see `applyUnsafe`). */
+	reconfigureUnsafe(config) {
+		return runSyncUnsafe(this.reconfigure(config));
+	}
+	/**
+	* Serialize this state to JSON. If you want to serialize the state of
+	* plugins, pass an object mapping property names to use in the
+	* resulting JSON object to plugin objects. The argument may also be a
+	* string or number, in which case it is ignored, to support the way
+	* `JSON.stringify` calls `toJSON` methods. Throws a `StateError` when
+	* a plugin is mapped to the reserved `doc` or `selection` fields.
+	*/
+	toJSON(pluginFields) {
+		const result = {
+			doc: this.doc.toJSON(),
+			selection: this.selection.toJSON()
+		};
+		if (this.storedMarksOrNull) result.storedMarks = this.storedMarksOrNull.map((m) => m.toJSON());
+		if (pluginFields && typeof pluginFields === "object") for (const prop in pluginFields) {
+			if (prop === "doc" || prop === "selection") throw new StateError({ message: "The JSON fields `doc` and `selection` are reserved" });
+			const plugin = pluginFields[prop], state = plugin.spec.state;
+			if (state && state.toJSON) result[prop] = state.toJSON.call(plugin, this.slots[plugin.key]);
+		}
+		return result;
+	}
+	/** Create a new state. */
+	static create(config) {
+		return Effect.flatMap(trySync(() => startCreate(config)), ({ instance, pending }) => pending < 0 ? Effect.succeed(instance) : finishCreate(config, instance, pending));
+	}
+	/**
+	* Like `create`, but runs synchronously. Only available when the
+	* plugins require no services; throws on failure.
+	*/
+	static createUnsafe(config) {
+		const { instance, pending } = startCreate(config);
+		return pending < 0 ? instance : runSyncUnsafe(finishCreate(config, instance, pending));
+	}
+	/**
+	* Deserialize a JSON representation of a state. `config` should have
+	* at least a `schema` field, and should contain an array of plugins to
+	* initialize the state with. `pluginFields` can be used to deserialize
+	* the state of plugins, by associating plugin instances with the
+	* property names they use in the JSON object.
+	*/
+	static fromJSON(config, json, pluginFields) {
+		return Effect.gen(function* () {
+			const data = json;
+			if (!data || typeof data !== "object") return yield* Effect.fail(new StateError({ message: "Invalid input for EditorState.fromJSON" }));
+			if (!config.schema) return yield* Effect.fail(new StateError({ message: "Required config field 'schema' missing" }));
+			const $config = yield* trySync(() => new Configuration(config.schema, config.plugins));
+			const instance = new EditorState($config);
+			for (const field of $config.fields) if (field.name === "doc") instance.slots.doc = yield* config.schema.nodeFromJSON(data.doc);
+			else if (field.name === "selection") instance.slots.selection = yield* Selection.fromJSON(instance.doc, data.selection);
+			else if (field.name === "storedMarks") {
+				if (data.storedMarks) {
+					const marks = [];
+					for (const m of data.storedMarks) marks.push(yield* config.schema.markFromJSON(m));
+					instance.slots.storedMarks = marks;
+				} else instance.slots.storedMarks = null;
+			} else {
+				let done = false;
+				if (pluginFields) for (const prop in pluginFields) {
+					const plugin = pluginFields[prop], state = plugin.spec.state;
+					if (plugin.key === field.name && state && state.fromJSON && Object.prototype.hasOwnProperty.call(data, prop)) {
+						const result = state.fromJSON.call(plugin, config, data[prop], instance);
+						instance.slots[field.name] = Effect.isEffect(result) ? yield* result : result;
+						done = true;
+						break;
+					}
+				}
+				if (!done) {
+					const result = field.init.call(field.self, config, instance);
+					instance.slots[field.name] = Effect.isEffect(result) ? yield* result : result;
+				}
+			}
+			return instance;
+		});
+	}
+	/** Like `fromJSON`, but runs synchronously (see `createUnsafe`). */
+	static fromJSONUnsafe(config, json, pluginFields) {
+		return runSyncUnsafe(EditorState.fromJSON(config, json, pluginFields));
+	}
+};
+export { Configuration, EditorState, EditorStateTypeId, runSyncUnsafe };

package/dist/state/transaction.d.ts

@@ -0,0 +1,145 @@
+import { Slice } from "../model/replace.js";
+import { AnySchema, MarkType } from "../model/schema.js";
+import { Mark } from "../model/mark.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import "../transform.js";
+import { Step } from "../transform/step.js";
+import { ReplaceFailure, Transform } from "../transform/transform.js";
+import { SelectionError } from "./errors.js";
+import { EditorViewLike, Plugin, PluginKey } from "./plugin.js";
+import { Selection } from "./selection.js";
+import { EditorState } from "./state.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+/**
+ * A function that applies a transaction, as passed to commands.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Dispatch<Sc extends AnySchema = AnySchema> = (tr: Transaction<Sc>) => Effect.Effect<void>;
+/**
+ * Commands are functions that take a state and an optional transaction
+ * dispatch function and...
+ *
+ *  - determine whether they apply to this state
+ *  - if not, succeed with `false`
+ *  - if `dispatch` was passed, perform their effect, possibly by passing
+ *    a transaction to `dispatch`
+ *  - succeed with `true`
+ *
+ * In some cases, the editor view is passed as a third argument.
+ * Commands carry the errors (`E`) and requirements (`R`) of the effects
+ * they run.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Command<Sc extends AnySchema = AnySchema, E = never, R = never> = (state: EditorState<Sc, any, any>, dispatch?: Dispatch<Sc>, view?: EditorViewLike) => Effect.Effect<boolean, E, R>;
+/**
+ * Keys under which transaction metadata can be stored.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type MetaKey = string | Plugin<any, any, any, any> | PluginKey<any>;
+/**
+ * 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
+ */
+export declare class Transaction<Sc extends AnySchema = AnySchema> extends Transform<Sc> {
+  /** The timestamp associated with this transaction, in the same format as `Date.now()`. */
+  time: number;
+  private curSelection;
+  private curSelectionFor;
+  private updated;
+  private readonly meta;
+  /** @internal */
+  storedMarksOrNull: ReadonlyArray<Mark<Sc>> | null;
+  /** @internal */
+  constructor(state: EditorState<Sc, any, any>);
+  /** The stored marks set by this transaction, if any. */
+  get storedMarks(): Option.Option<ReadonlyArray<Mark<Sc>>>;
+  /**
+   * 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(): Selection<Sc>;
+  /**
+   * 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: Selection<Sc>): Effect.Effect<this, SelectionError>;
+  /** Like `setSelection`, but throws a `SelectionError` on failure. */
+  setSelectionUnsafe(selection: Selection<Sc>): this;
+  /** Whether the selection was explicitly updated by this transaction. */
+  get selectionSet(): boolean;
+  /** Set the current stored marks. */
+  setStoredMarks(marks: ReadonlyArray<Mark<Sc>> | null): 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: ReadonlyArray<Mark<Sc>>): this;
+  /** Add a mark to the set of stored marks. */
+  addStoredMark(mark: Mark<Sc>): this;
+  /** Remove a mark or mark type from the set of stored marks. */
+  removeStoredMark(mark: Mark<Sc> | MarkType<Sc>): this;
+  /** Whether the stored marks were explicitly set for this transaction. */
+  get storedMarksSet(): boolean;
+  /** @internal */
+  addStep(step: Step<Sc>, doc: Node<Sc>): void;
+  /** Update the timestamp for the transaction. */
+  setTime(time: number): this;
+  /** Replace the current selection with the given slice. */
+  replaceSelection(slice: Slice<Sc>): 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: Node<Sc>, inheritMarks?: boolean): this;
+  /** Delete the selection. */
+  deleteSelection(): this;
+  /**
+   * Replace the given range, or the selection if no range is given,
+   * with a text node containing the given string.
+   */
+  insertText(text: string, from?: number, to?: number): Effect.Effect<this, ReplaceFailure>;
+  /** Like `insertText`, but throws on failure (for example for positions outside of the document). */
+  insertTextUnsafe(text: string, from?: number, to?: number): this;
+  /** Store a metadata property in this transaction, keyed either by name or by plugin. */
+  setMeta(key: MetaKey, value: unknown): this;
+  /** Retrieve a metadata property for a given name or plugin, if it was set. */
+  getMeta<A = unknown>(key: MetaKey): Option.Option<A>;
+  /**
+   * Returns true if this transaction doesn't contain any metadata, and
+   * can thus safely be extended.
+   */
+  get isGeneric(): boolean;
+  /**
+   * Indicate that the editor should scroll the selection into view when
+   * updated to the state produced by this transaction.
+   */
+  scrollIntoView(): this;
+  /** True when this transaction has had `scrollIntoView` called on it. */
+  get scrolledIntoView(): boolean;
+}