@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/history.d.ts

@@ -0,0 +1,178 @@
+import { AnySchema } from "./model/schema.js";
+import "./model.js";
+import { Mapping, StepMap } from "./transform/map.js";
+import { Step } from "./transform/step.js";
+import { Transform } from "./transform/transform.js";
+import "./state.js";
+import { Dispatch, Transaction } from "./state/transaction.js";
+import { SelectionBookmark } from "./state/selection.js";
+import { EditorState } from "./state/state.js";
+import { EditorViewLike, Plugin } from "./state/plugin.js";
+import "./transform.js";
+import * as Effect from "effect/Effect";
+import RopeSequence from "rope-sequence";
+interface PopResult {
+  readonly remaining: Branch;
+  readonly transform: Transaction<any>;
+  readonly selection: SelectionBookmark<any>;
+}
+/** @internal */
+export declare class Branch {
+  readonly items: RopeSequence<Item>;
+  readonly eventCount: number;
+  constructor(items: RopeSequence<Item>, eventCount: number);
+  popEvent(state: EditorState<any, any, any>, preserveItems: boolean): PopResult | null;
+  addTransform(transform: Transform<any>, selection: SelectionBookmark<any> | undefined, histOptions: HistoryConfig, preserveItems: boolean): Branch;
+  remapping(from: number, to: number): Mapping;
+  addMaps(array: ReadonlyArray<StepMap>): Branch;
+  rebased(rebasedTransform: Transform<any>, rebasedCount: number): Branch;
+  emptyItemCount(): number;
+  compress(upto?: number): Branch;
+  static empty: Branch;
+}
+/** @internal */
+export declare class Item {
+  readonly map: StepMap;
+  readonly step?: Step<any> | undefined;
+  readonly selection?: SelectionBookmark<any> | undefined;
+  readonly mirrorOffset?: number | undefined;
+  constructor(map: StepMap, step?: Step<any> | undefined, selection?: SelectionBookmark<any> | undefined, mirrorOffset?: number | undefined);
+  merge(other: Item): Item | undefined;
+}
+/**
+ * The value of the state field that tracks undo/redo history for that
+ * state. Will be stored in the plugin state when the history plugin is
+ * active. Its contents are opaque.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class HistoryState {
+  /** @internal */
+  readonly done: Branch;
+  /** @internal */
+  readonly undone: Branch;
+  /** @internal */
+  readonly prevRanges: ReadonlyArray<number> | null;
+  /** @internal */
+  readonly prevTime: number;
+  /** @internal */
+  readonly prevComposition: number;
+  /** @internal */
+  constructor(
+  /** @internal */
+  done: Branch,
+  /** @internal */
+  undone: Branch,
+  /** @internal */
+  prevRanges: ReadonlyArray<number> | null,
+  /** @internal */
+  prevTime: number,
+  /** @internal */
+  prevComposition: number);
+}
+/**
+ * Set a flag on the given transaction that will prevent further steps
+ * from being appended to an existing history event (so that they
+ * require a separate undo command to undo).
+ *
+ * @since 0.1.0
+ * @category transactions
+ */
+export declare const closeHistory: <Sc extends AnySchema>(tr: Transaction<Sc>) => Transaction<Sc>;
+interface HistoryConfig {
+  readonly depth: number;
+  readonly newGroupDelay: number;
+}
+/**
+ * Options for the history plugin.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface HistoryOptions {
+  /**
+   * The amount of history events that are collected before the oldest
+   * events are discarded. Defaults to 100.
+   */
+  readonly depth?: number | undefined;
+  /**
+   * The delay between changes after which a new group should be
+   * started. Defaults to 500 (milliseconds). Note that when changes
+   * aren't adjacent, a new group is always started.
+   */
+  readonly newGroupDelay?: number | undefined;
+}
+/**
+ * A command provided by this module. It works with any schema and
+ * needs no services.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type HistoryCommand = <Sc extends AnySchema>(state: EditorState<Sc, any, any>, dispatch?: Dispatch<Sc>, view?: EditorViewLike) => Effect.Effect<boolean>;
+/**
+ * Returns a plugin that enables the undo history for an editor. The
+ * plugin will track undo and redo stacks, which can be used with the
+ * `undo` and `redo` commands.
+ *
+ * You can set an `"addToHistory"` metadata property of `false` on a
+ * transaction to prevent it from being rolled back by undo.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const history: (config?: HistoryOptions) => Plugin<HistoryState>;
+/**
+ * A command that undoes the last change, if any.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare const undo: HistoryCommand;
+/**
+ * A command that redoes the last undone change, if any.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare const redo: HistoryCommand;
+/**
+ * A command that undoes the last change. Doesn't scroll the selection
+ * into view.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare const undoNoScroll: HistoryCommand;
+/**
+ * A command that redoes the last undone change. Doesn't scroll the
+ * selection into view.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare const redoNoScroll: HistoryCommand;
+/**
+ * The amount of undoable events available in a given state.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+export declare const undoDepth: (state: EditorState<any, any, any>) => number;
+/**
+ * The amount of redoable events available in a given editor state.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+export declare const redoDepth: (state: EditorState<any, any, any>) => number;
+/**
+ * Returns true if the given transaction was generated by the history
+ * plugin.
+ *
+ * @since 0.1.0
+ * @category guards
+ */
+export declare const isHistoryTransaction: (tr: Transaction<any>) => boolean;
+export {};

package/dist/history.js

@@ -0,0 +1,412 @@
+import { Plugin, PluginKey } from "./state/plugin.js";
+import { Mapping } from "./transform/map.js";
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import RopeSequence from "rope-sequence";
+// src/history.ts
+/**
+* An undo/redo history for the editor, ported from
+* `prosemirror-history`.
+*
+* ```ts skip-type-checking
+* const state = EditorState.createUnsafe({ schema, plugins: [history()] })
+* // ...
+* yield* undo(state, dispatch)
+* ```
+*
+* @since 0.1.0
+*/
+const max_empty_items = 500;
+const DEPTH_OVERFLOW = 20;
+/** @internal */
+var Branch = class Branch {
+	constructor(items, eventCount) {
+		this.items = items;
+		this.eventCount = eventCount;
+	}
+	popEvent(state, preserveItems) {
+		if (this.eventCount === 0) return null;
+		let end = this.items.length;
+		for (;; end--) if (this.items.get(end - 1).selection) {
+			--end;
+			break;
+		}
+		let remap, mapFrom;
+		if (preserveItems) {
+			remap = this.remapping(end, this.items.length);
+			mapFrom = remap.maps.length;
+		}
+		const transform = state.tr;
+		let selection, remaining;
+		const addAfter = [], addBefore = [];
+		this.items.forEach((item, i) => {
+			if (!item.step) {
+				if (!remap) {
+					remap = this.remapping(end, i + 1);
+					mapFrom = remap.maps.length;
+				}
+				mapFrom--;
+				addBefore.push(item);
+				return;
+			}
+			if (remap) {
+				addBefore.push(new Item(item.map));
+				const step = Option.getOrNull(item.step.map(remap.slice(mapFrom)));
+				let map;
+				if (step && transform.maybeStep(step).docOrNull) {
+					map = transform.mapping.maps[transform.mapping.maps.length - 1];
+					addAfter.push(new Item(map, void 0, void 0, addAfter.length + addBefore.length));
+				}
+				mapFrom--;
+				if (map) remap.appendMap(map, mapFrom);
+			} else transform.maybeStep(item.step);
+			if (item.selection) {
+				selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;
+				remaining = new Branch(this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this.eventCount - 1);
+				return false;
+			}
+		}, this.items.length, 0);
+		return {
+			remaining,
+			transform,
+			selection
+		};
+	}
+	addTransform(transform, selection, histOptions, preserveItems) {
+		const newItems = [];
+		let eventCount = this.eventCount;
+		let oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;
+		for (let i = 0; i < transform.steps.length; i++) {
+			const step = transform.steps[i].invert(transform.docs[i]);
+			let item = new Item(transform.mapping.maps[i], step, selection);
+			const merged = lastItem && lastItem.merge(item);
+			if (merged) {
+				item = merged;
+				if (i) newItems.pop();
+				else oldItems = oldItems.slice(0, oldItems.length - 1);
+			}
+			newItems.push(item);
+			if (selection) {
+				eventCount++;
+				selection = void 0;
+			}
+			if (!preserveItems) lastItem = item;
+		}
+		const overflow = eventCount - histOptions.depth;
+		if (overflow > DEPTH_OVERFLOW) {
+			oldItems = cutOffEvents(oldItems, overflow);
+			eventCount -= overflow;
+		}
+		return new Branch(oldItems.append(newItems), eventCount);
+	}
+	remapping(from, to) {
+		const maps = new Mapping();
+		this.items.forEach((item, i) => {
+			const mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from ? maps.maps.length - item.mirrorOffset : void 0;
+			maps.appendMap(item.map, mirrorPos);
+		}, from, to);
+		return maps;
+	}
+	addMaps(array) {
+		if (this.eventCount === 0) return this;
+		return new Branch(this.items.append(array.map((map) => new Item(map))), this.eventCount);
+	}
+	rebased(rebasedTransform, rebasedCount) {
+		if (!this.eventCount) return this;
+		const count = Math.min(this.items.length, rebasedCount);
+		const rebasedItems = [], start = this.items.length - count;
+		const mapping = rebasedTransform.mapping;
+		let newUntil = rebasedTransform.steps.length;
+		let eventCount = this.eventCount;
+		this.items.forEach((item) => {
+			if (item.selection) eventCount--;
+		}, start);
+		let iRebased = count;
+		this.items.forEach((item) => {
+			const pos = mapping.getMirrorOrUndefined(--iRebased);
+			if (pos == null) return;
+			newUntil = Math.min(newUntil, pos);
+			const map = mapping.maps[pos];
+			if (item.step) {
+				const step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);
+				const selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));
+				if (selection) eventCount++;
+				rebasedItems.push(new Item(map, step, selection));
+			} else rebasedItems.push(new Item(map));
+		}, start);
+		const newMaps = [];
+		for (let i = count; i < newUntil; i++) newMaps.push(new Item(mapping.maps[i]));
+		const items = this.items.slice(0, start).append(newMaps).append(rebasedItems);
+		let branch = new Branch(items, eventCount);
+		if (branch.emptyItemCount() > max_empty_items) branch = branch.compress(this.items.length - rebasedItems.length);
+		return branch;
+	}
+	emptyItemCount() {
+		let count = 0;
+		this.items.forEach((item) => {
+			if (!item.step) count++;
+		});
+		return count;
+	}
+	compress(upto = this.items.length) {
+		const remap = this.remapping(0, upto);
+		let mapFrom = remap.maps.length;
+		const items = [];
+		let events = 0;
+		this.items.forEach((item, i) => {
+			if (i >= upto) {
+				items.push(item);
+				if (item.selection) events++;
+			} else if (item.step) {
+				const step = Option.getOrNull(item.step.map(remap.slice(mapFrom))), map = step && step.getMap();
+				mapFrom--;
+				if (map) remap.appendMap(map, mapFrom);
+				if (step) {
+					const selection = item.selection && item.selection.map(remap.slice(mapFrom));
+					if (selection) events++;
+					const newItem = new Item(map.invert(), step, selection), last = items.length - 1;
+					const merged = items.length ? items[last].merge(newItem) : void 0;
+					if (merged) items[last] = merged;
+					else items.push(newItem);
+				}
+			} else if (item.map) mapFrom--;
+		}, this.items.length, 0);
+		return new Branch(RopeSequence.from(items.reverse()), events);
+	}
+	static {
+		this.empty = new Branch(RopeSequence.empty, 0);
+	}
+};
+function cutOffEvents(items, n) {
+	let cutPoint;
+	items.forEach((item, i) => {
+		if (item.selection && n-- === 0) {
+			cutPoint = i;
+			return false;
+		}
+	});
+	return items.slice(cutPoint);
+}
+/** @internal */
+var Item = class Item {
+	constructor(map, step, selection, mirrorOffset) {
+		this.map = map;
+		this.step = step;
+		this.selection = selection;
+		this.mirrorOffset = mirrorOffset;
+	}
+	merge(other) {
+		if (this.step && other.step && !other.selection) {
+			const step = Option.getOrNull(other.step.merge(this.step));
+			if (step) return new Item(step.getMap().invert(), step, this.selection);
+		}
+	}
+};
+/**
+* The value of the state field that tracks undo/redo history for that
+* state. Will be stored in the plugin state when the history plugin is
+* active. Its contents are opaque.
+*
+* @since 0.1.0
+* @category models
+*/
+var HistoryState = class {
+	/** @internal */
+	constructor(done, undone, prevRanges, prevTime, prevComposition) {
+		this.done = done;
+		this.undone = undone;
+		this.prevRanges = prevRanges;
+		this.prevTime = prevTime;
+		this.prevComposition = prevComposition;
+	}
+};
+const meta = (tr, key) => Option.getOrUndefined(tr.getMeta(key));
+function applyTransaction(history, state, tr, options) {
+	const historyTr = meta(tr, historyKey);
+	if (historyTr) return historyTr.historyState;
+	if (meta(tr, closeHistoryKey)) history = new HistoryState(history.done, history.undone, null, 0, -1);
+	const appended = meta(tr, "appendedTransaction");
+	let rebased;
+	if (Arr.isReadonlyArrayEmpty(tr.steps)) return history;
+	else if (appended && meta(appended, historyKey)) {
+		if (meta(appended, historyKey).redo) return new HistoryState(history.done.addTransform(tr, void 0, options, mustPreserveItems(state)), history.undone, rangesFor(tr.mapping.maps), history.prevTime, history.prevComposition);
+		else return new HistoryState(history.done, history.undone.addTransform(tr, void 0, options, mustPreserveItems(state)), null, history.prevTime, history.prevComposition);
+	} else if (meta(tr, "addToHistory") !== false && !(appended && meta(appended, "addToHistory") === false)) {
+		const composition = meta(tr, "composition");
+		const newGroup = history.prevTime === 0 || !appended && history.prevComposition !== composition && (history.prevTime < (tr.time || 0) - options.newGroupDelay || !isAdjacentTo(tr, history.prevRanges));
+		const prevRanges = appended ? mapRanges(history.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps);
+		return new HistoryState(history.done.addTransform(tr, newGroup ? state.selection.getBookmark() : void 0, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr.time, composition == null ? history.prevComposition : composition);
+	} else if (rebased = meta(tr, "rebased")) return new HistoryState(history.done.rebased(tr, rebased), history.undone.rebased(tr, rebased), mapRanges(history.prevRanges, tr.mapping), history.prevTime, history.prevComposition);
+	else return new HistoryState(history.done.addMaps(tr.mapping.maps), history.undone.addMaps(tr.mapping.maps), mapRanges(history.prevRanges, tr.mapping), history.prevTime, history.prevComposition);
+}
+function isAdjacentTo(transform, prevRanges) {
+	if (!prevRanges) return false;
+	if (!transform.docChanged) return true;
+	let adjacent = false;
+	transform.mapping.maps[0].forEach((start, end) => {
+		for (let i = 0; i < prevRanges.length; i += 2) if (start <= prevRanges[i + 1] && end >= prevRanges[i]) adjacent = true;
+	});
+	return adjacent;
+}
+function rangesFor(maps) {
+	const result = [];
+	for (let i = maps.length - 1; i >= 0; i--) {
+		maps[i].forEach((_from, _to, from, to) => result.push(from, to));
+		if (Arr.isArrayNonEmpty(result)) break;
+	}
+	return result;
+}
+function mapRanges(ranges, mapping) {
+	if (!ranges) return null;
+	const result = [];
+	for (let i = 0; i < ranges.length; i += 2) {
+		const from = mapping.map(ranges[i], 1), to = mapping.map(ranges[i + 1], -1);
+		if (from <= to) result.push(from, to);
+	}
+	return result;
+}
+function histTransaction(history, state, redo) {
+	const preserveItems = mustPreserveItems(state);
+	const plugin = Option.getOrUndefined(historyKey.get(state));
+	if (!plugin) return null;
+	const histOptions = plugin.spec.config;
+	const pop = (redo ? history.undone : history.done).popEvent(state, preserveItems);
+	if (!pop) return null;
+	const selection = pop.selection.resolve(pop.transform.doc);
+	const added = (redo ? history.done : history.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);
+	const newHist = new HistoryState(redo ? added : pop.remaining, redo ? pop.remaining : added, null, 0, -1);
+	return pop.transform.setSelectionUnsafe(selection).setMeta(historyKey, {
+		redo,
+		historyState: newHist
+	});
+}
+let cachedPreserveItems = false;
+let cachedPreserveItemsPlugins = null;
+function mustPreserveItems(state) {
+	const plugins = state.plugins;
+	if (cachedPreserveItemsPlugins !== plugins) {
+		cachedPreserveItems = false;
+		cachedPreserveItemsPlugins = plugins;
+		for (let i = 0; i < plugins.length; i++) if (plugins[i].spec.historyPreserveItems) {
+			cachedPreserveItems = true;
+			break;
+		}
+	}
+	return cachedPreserveItems;
+}
+/**
+* Set a flag on the given transaction that will prevent further steps
+* from being appended to an existing history event (so that they
+* require a separate undo command to undo).
+*
+* @since 0.1.0
+* @category transactions
+*/
+const closeHistory = (tr) => tr.setMeta(closeHistoryKey, true);
+const historyKey = new PluginKey("history");
+const closeHistoryKey = new PluginKey("closeHistory");
+/**
+* Returns a plugin that enables the undo history for an editor. The
+* plugin will track undo and redo stacks, which can be used with the
+* `undo` and `redo` commands.
+*
+* You can set an `"addToHistory"` metadata property of `false` on a
+* transaction to prevent it from being rolled back by undo.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const history = (config = {}) => {
+	const options = {
+		depth: config.depth || 100,
+		newGroupDelay: config.newGroupDelay || 500
+	};
+	return new Plugin({
+		key: historyKey,
+		state: {
+			init() {
+				return new HistoryState(Branch.empty, Branch.empty, null, 0, -1);
+			},
+			apply(tr, hist, state) {
+				return applyTransaction(hist, state, tr, options);
+			}
+		},
+		config: options,
+		props: { handleDOMEvents: { beforeinput(view, e) {
+			const inputType = e.inputType;
+			const command = inputType === "historyUndo" ? undo : inputType === "historyRedo" ? redo : null;
+			if (!command || !view.editable) return false;
+			e.preventDefault();
+			return command(view.state, view.dispatch);
+		} } }
+	});
+};
+const buildCommand = (redo, scroll) => (state, dispatch) => Effect.suspend(() => {
+	const hist = Option.getOrUndefined(historyKey.getState(state));
+	if (!hist || (redo ? hist.undone : hist.done).eventCount === 0) return Effect.succeed(false);
+	if (dispatch) {
+		const tr = histTransaction(hist, state, redo);
+		if (tr) return Effect.as(dispatch(scroll ? tr.scrollIntoView() : tr), true);
+	}
+	return Effect.succeed(true);
+});
+/**
+* A command that undoes the last change, if any.
+*
+* @since 0.1.0
+* @category commands
+*/
+const undo = buildCommand(false, true);
+/**
+* A command that redoes the last undone change, if any.
+*
+* @since 0.1.0
+* @category commands
+*/
+const redo = buildCommand(true, true);
+/**
+* A command that undoes the last change. Doesn't scroll the selection
+* into view.
+*
+* @since 0.1.0
+* @category commands
+*/
+const undoNoScroll = buildCommand(false, false);
+/**
+* A command that redoes the last undone change. Doesn't scroll the
+* selection into view.
+*
+* @since 0.1.0
+* @category commands
+*/
+const redoNoScroll = buildCommand(true, false);
+/**
+* The amount of undoable events available in a given state.
+*
+* @since 0.1.0
+* @category getters
+*/
+const undoDepth = (state) => {
+	const hist = Option.getOrUndefined(historyKey.getState(state));
+	return hist ? hist.done.eventCount : 0;
+};
+/**
+* The amount of redoable events available in a given editor state.
+*
+* @since 0.1.0
+* @category getters
+*/
+const redoDepth = (state) => {
+	const hist = Option.getOrUndefined(historyKey.getState(state));
+	return hist ? hist.undone.eventCount : 0;
+};
+/**
+* Returns true if the given transaction was generated by the history
+* plugin.
+*
+* @since 0.1.0
+* @category guards
+*/
+const isHistoryTransaction = (tr) => Option.isSome(tr.getMeta(historyKey));
+export { Branch, HistoryState, Item, closeHistory, history, isHistoryTransaction, redo, redoDepth, redoNoScroll, undo, undoDepth, undoNoScroll };