@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/transform/map.js

@@ -0,0 +1,280 @@
+import * as Option from "effect/Option";
+import * as S from "effect/Schema";
+// src/transform/map.ts
+/**
+* Position maps: `StepMap`, `Mapping` and `MapResult`.
+*
+* @since 0.1.0
+*/
+const encodeRanges = S.encodeSync(S.fromJsonString(S.Array(S.Number)));
+const lower16 = 65535;
+const factor16 = Math.pow(2, 16);
+const makeRecover = (index, offset) => index + offset * factor16;
+const recoverIndex = (value) => value & lower16;
+const recoverOffset = (value) => (value - (value & lower16)) / factor16;
+const DEL_BEFORE = 1;
+const DEL_AFTER = 2;
+const DEL_ACROSS = 4;
+const DEL_SIDE = 8;
+/**
+* An object representing a mapped position with extra information.
+*
+* @since 0.1.0
+* @category models
+*/
+var MapResult = class {
+	/** @internal */
+	constructor(pos, delInfo, recover) {
+		this.pos = pos;
+		this.delInfo = delInfo;
+		this.recover = recover;
+	}
+	/**
+	* Tells you whether the position was deleted, that is, whether the
+	* step removed the token on the side queried (via the `assoc`)
+	* argument from the document.
+	*/
+	get deleted() {
+		return (this.delInfo & DEL_SIDE) > 0;
+	}
+	/** Tells you whether the token before the mapped position was deleted. */
+	get deletedBefore() {
+		return (this.delInfo & 5) > 0;
+	}
+	/** True when the token after the mapped position was deleted. */
+	get deletedAfter() {
+		return (this.delInfo & 6) > 0;
+	}
+	/**
+	* Tells whether any of the steps mapped through deletes across the
+	* position (including both the token before and after the position).
+	*/
+	get deletedAcross() {
+		return (this.delInfo & DEL_ACROSS) > 0;
+	}
+};
+/**
+* A map describing the deletions and insertions made by a step, which
+* can be used to find the correspondence between positions in the
+* pre-step version of a document and the same position in the
+* post-step version.
+*
+* @since 0.1.0
+* @category models
+*/
+var StepMap = class StepMap {
+	/**
+	* Create a position map. The modifications to the document are
+	* represented as an array of numbers, in which each group of three
+	* represents a modified chunk as `[start, oldSize, newSize]`.
+	*/
+	constructor(ranges, inverted = false) {
+		this.ranges = ranges;
+		this.inverted = inverted;
+		if (!ranges.length && StepMap.empty) return StepMap.empty;
+	}
+	/** @internal */
+	recover(value) {
+		let diff = 0;
+		const index = recoverIndex(value);
+		if (!this.inverted) for (let i = 0; i < index; i++) diff += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1];
+		return this.ranges[index * 3] + diff + recoverOffset(value);
+	}
+	mapResult(pos, assoc = 1) {
+		return this._map(pos, assoc, false);
+	}
+	map(pos, assoc = 1) {
+		return this._map(pos, assoc, true);
+	}
+	/** @internal */
+	_map(pos, assoc, simple) {
+		let diff = 0;
+		const oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+		for (let i = 0; i < this.ranges.length; i += 3) {
+			const start = this.ranges[i] - (this.inverted ? diff : 0);
+			if (start > pos) break;
+			const oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex], end = start + oldSize;
+			if (pos <= end) {
+				const side = !oldSize ? assoc : pos === start ? -1 : pos === end ? 1 : assoc;
+				const result = start + diff + (side < 0 ? 0 : newSize);
+				if (simple) return result;
+				const recover = pos === (assoc < 0 ? start : end) ? null : makeRecover(i / 3, pos - start);
+				let del = 0;
+				if (oldSize) {
+					del |= pos === start ? DEL_AFTER : pos === end ? DEL_BEFORE : DEL_ACROSS;
+					if (assoc < 0 ? pos !== start : pos !== end) del |= DEL_SIDE;
+				}
+				return new MapResult(result, del, recover);
+			}
+			diff += newSize - oldSize;
+		}
+		return simple ? pos + diff : new MapResult(pos + diff, 0, null);
+	}
+	/** @internal */
+	touches(pos, recover) {
+		let diff = 0;
+		const index = recoverIndex(recover);
+		const oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+		for (let i = 0; i < this.ranges.length; i += 3) {
+			const start = this.ranges[i] - (this.inverted ? diff : 0);
+			if (start > pos) break;
+			const oldSize = this.ranges[i + oldIndex];
+			if (pos <= start + oldSize && i === index * 3) return true;
+			diff += this.ranges[i + newIndex] - oldSize;
+		}
+		return false;
+	}
+	/** Calls the given function on each of the changed ranges included in this map. */
+	forEach(f) {
+		const oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+		for (let i = 0, diff = 0; i < this.ranges.length; i += 3) {
+			const start = this.ranges[i], oldStart = start - (this.inverted ? diff : 0), newStart = start + (this.inverted ? 0 : diff);
+			const oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex];
+			f(oldStart, oldStart + oldSize, newStart, newStart + newSize);
+			diff += newSize - oldSize;
+		}
+	}
+	/**
+	* Create an inverted version of this map. The result can be used to
+	* map positions in the post-step document to the pre-step document.
+	*/
+	invert() {
+		return new StepMap(this.ranges, !this.inverted);
+	}
+	/** @internal */
+	toString() {
+		return (this.inverted ? "-" : "") + encodeRanges(this.ranges);
+	}
+	/**
+	* Create a map that moves all positions by offset `n` (which may be
+	* negative). This can be useful when applying steps meant for a
+	* sub-document to a larger document, or vice-versa.
+	*/
+	static offset(n) {
+		return n === 0 ? StepMap.empty : new StepMap(n < 0 ? [
+			0,
+			-n,
+			0
+		] : [
+			0,
+			0,
+			n
+		]);
+	}
+	static {
+		this.empty = new StepMap([]);
+	}
+};
+/**
+* A mapping represents a pipeline of zero or more step maps. It has
+* special provisions for losslessly handling mapping positions through
+* a series of steps in which some steps are inverted versions of
+* earlier steps. (This comes up when ‘rebasing’ steps for collaboration
+* or history management.)
+*
+* Mappings are mutable: `appendMap` and friends modify the mapping in
+* place.
+*
+* @since 0.1.0
+* @category models
+*/
+var Mapping = class Mapping {
+	/** Create a new mapping with the given position maps. */
+	constructor(maps, mirror, from = 0, to = maps ? maps.length : 0) {
+		this.mirror = mirror;
+		this.from = from;
+		this.to = to;
+		this._maps = maps || [];
+		this.ownData = !(maps || mirror);
+	}
+	/** The step maps in this mapping. */
+	get maps() {
+		return this._maps;
+	}
+	/** Create a mapping that maps only through a part of this one. */
+	slice(from = 0, to = this.maps.length) {
+		return new Mapping(this._maps, this.mirror, from, to);
+	}
+	/**
+	* Add a step map to the end of this mapping. If `mirrors` is given,
+	* it should be the index of the step map that is the mirror image of
+	* this one.
+	*/
+	appendMap(map, mirrors) {
+		if (!this.ownData) {
+			this._maps = this._maps.slice();
+			this.mirror = this.mirror && this.mirror.slice();
+			this.ownData = true;
+		}
+		this.to = this._maps.push(map);
+		if (mirrors != null) this.setMirror(this._maps.length - 1, mirrors);
+	}
+	/** Add all the step maps in a given mapping to this one (preserving mirroring information). */
+	appendMapping(mapping) {
+		for (let i = 0, startSize = this._maps.length; i < mapping._maps.length; i++) {
+			const mirr = mapping.getMirrorOrUndefined(i);
+			this.appendMap(mapping._maps[i], mirr != null && mirr < i ? startSize + mirr : void 0);
+		}
+	}
+	/**
+	* Finds the offset of the step map that mirrors the map at the given
+	* offset, in this mapping (as per the second argument to
+	* `appendMap`).
+	*/
+	getMirror(n) {
+		return Option.fromUndefinedOr(this.getMirrorOrUndefined(n));
+	}
+	/** @internal */
+	getMirrorOrUndefined(n) {
+		if (this.mirror) {
+			for (let i = 0; i < this.mirror.length; i++) if (this.mirror[i] === n) return this.mirror[i + (i % 2 ? -1 : 1)];
+		}
+	}
+	/** Record that the maps at offsets `n` and `m` mirror each other. */
+	setMirror(n, m) {
+		if (!this.mirror) this.mirror = [];
+		this.mirror.push(n, m);
+	}
+	/** Append the inverse of the given mapping to this one. */
+	appendMappingInverted(mapping) {
+		for (let i = mapping.maps.length - 1, totalSize = this._maps.length + mapping._maps.length; i >= 0; i--) {
+			const mirr = mapping.getMirrorOrUndefined(i);
+			this.appendMap(mapping._maps[i].invert(), mirr != null && mirr > i ? totalSize - mirr - 1 : void 0);
+		}
+	}
+	/** Create an inverted version of this mapping. */
+	invert() {
+		const inverse = new Mapping();
+		inverse.appendMappingInverted(this);
+		return inverse;
+	}
+	/** Map a position through this mapping. */
+	map(pos, assoc = 1) {
+		if (this.mirror) return this._map(pos, assoc, true);
+		for (let i = this.from; i < this.to; i++) pos = this._maps[i].map(pos, assoc);
+		return pos;
+	}
+	/** Map a position through this mapping, returning a mapping result. */
+	mapResult(pos, assoc = 1) {
+		return this._map(pos, assoc, false);
+	}
+	/** @internal */
+	_map(pos, assoc, simple) {
+		let delInfo = 0;
+		for (let i = this.from; i < this.to; i++) {
+			const result = this._maps[i].mapResult(pos, assoc);
+			if (result.recover != null) {
+				const corr = this.getMirrorOrUndefined(i);
+				if (corr != null && corr > i && corr < this.to) {
+					i = corr;
+					pos = this._maps[corr].recover(result.recover);
+					continue;
+				}
+			}
+			delInfo |= result.delInfo;
+			pos = result.pos;
+		}
+		return simple ? pos : new MapResult(pos, delInfo, null);
+	}
+};
+export { MapResult, Mapping, StepMap };

package/dist/transform/mark.js

@@ -0,0 +1,98 @@
+import { Fragment } from "../model/fragment.js";
+import { MarkType } from "../model/schema.js";
+import { Slice } from "../model/replace.js";
+import { pushMarkStep } from "./mark_set_step.js";
+import { AddMarkStep, RemoveMarkStep } from "./mark_step.js";
+import { ReplaceStep } from "./replace_step.js";
+import * as Option from "effect/Option";
+// src/transform/mark.ts
+/**
+* Mark-related transform implementations.
+*
+* @internal
+*/
+/** @internal */
+function addMark(tr, from, to, mark) {
+	const added = [];
+	tr.doc.nodesBetween(from, to, (node, pos, parent) => {
+		if (!node.isInline) return;
+		const marks = node.marks;
+		if (!mark.isInSet(marks) && Option.isSome(parent) && parent.value.type.allowsMarkType(mark.type)) {
+			const start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
+			pushMarkStep(AddMarkStep, start, end, mark, added);
+		}
+	});
+	added.forEach((s) => tr.stepUnsafe(s));
+}
+/** @internal */
+function removeMark(tr, from, to, mark) {
+	const matched = [];
+	let step = 0;
+	tr.doc.nodesBetween(from, to, (node, pos) => {
+		if (!node.isInline || !node.isAtom) return;
+		step++;
+		let toRemove = null;
+		if (mark instanceof MarkType) {
+			let set = node.marks, found;
+			const list = [];
+			while (found = mark.findInSet(set)) {
+				list.push(found);
+				set = found.removeFromSet(set);
+			}
+			if (list.length) toRemove = list;
+		} else if (mark) {
+			if (mark.isInSet(node.marks)) toRemove = [mark];
+		} else toRemove = node.marks;
+		if (toRemove && toRemove.length) {
+			const end = Math.min(pos + node.nodeSize, to);
+			for (let i = 0; i < toRemove.length; i++) {
+				const style = toRemove[i];
+				let found;
+				for (let j = 0; j < matched.length; j++) {
+					const m = matched[j];
+					if (m.step === step - 1 && style.eq(m.style)) found = m;
+				}
+				if (found) {
+					found.to = end;
+					found.step = step;
+				} else matched.push({
+					style,
+					from: Math.max(pos, from),
+					to: end,
+					step
+				});
+			}
+		}
+	});
+	matched.forEach((m) => tr.stepUnsafe(new RemoveMarkStep(m.from, m.to, m.style)));
+}
+/** @internal */
+function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch, clearNewlines = true) {
+	const node = tr.doc.nodeAtOrNull(pos);
+	const replSteps = [];
+	let cur = pos + 1;
+	for (let i = 0; i < node.childCount; i++) {
+		const child = node.content.content[i], end = cur + child.nodeSize;
+		const allowed = match.matchTypeOrNull(child.type);
+		if (!allowed) replSteps.push(new ReplaceStep(cur, end, Slice.empty));
+		else {
+			match = allowed;
+			for (let j = 0; j < child.marks.length; j++) if (!parentType.allowsMarkType(child.marks[j].type)) tr.stepUnsafe(new RemoveMarkStep(cur, end, child.marks[j]));
+			if (clearNewlines && child.isText && parentType.whitespace !== "pre") {
+				let m, slice;
+				const newline = /\r?\n|\r/g;
+				while (m = newline.exec(child.text)) {
+					if (!slice) slice = new Slice(Fragment.from(parentType.schema.textUnsafe(" ", parentType.allowedMarks(child.marks))), 0, 0);
+					replSteps.push(new ReplaceStep(cur + m.index, cur + m.index + m[0].length, slice));
+				}
+			}
+		}
+		cur = end;
+	}
+	if (!match.validEnd) {
+		const fill = match.fillBeforeOrNull(Fragment.empty, true);
+		tr.replaceUnsafe(cur, cur, new Slice(fill, 0, 0));
+	}
+	for (let i = replSteps.length - 1; i >= 0; i--) tr.stepUnsafe(replSteps[i]);
+}
+export { addMark, clearIncompatible, removeMark };

package/dist/transform/mark_set_step.js

@@ -0,0 +1,69 @@
+import { JSONError } from "../model/errors.js";
+import { Step, StepResult } from "./step.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+// src/transform/mark_set_step.ts
+/**
+* Internal helpers for mark steps: `pushMarkStep` and the `MarkSetStep`
+* that inverting a mark step can produce. Not part of the public API
+* (prosemirror-transform keeps both private too).
+*
+* Ported from prosemirror-transform 1.12.3 / 1.12.4 (MIT, Marijn Haverbeke and others).
+*
+* @internal
+*/
+/**
+* Append a mark step to `target`, extending the last step instead when
+* it is of the same class, carries an equal mark, and ends at `from`.
+*
+* @internal
+*/
+function pushMarkStep(cls, from, to, mark, target) {
+	const last = target.at(-1);
+	if (last && last instanceof cls && last.to === from && last.mark.eq(mark)) target[target.length - 1] = new cls(last.from, to, mark);
+	else target.push(new cls(from, to, mark));
+}
+/**
+* A group of mark steps applied as one, produced when inverting a mark
+* step needs more than one step. Serialized as `"markSet"`.
+*
+* @internal
+*/
+var MarkSetStep = class MarkSetStep extends Step {
+	constructor(steps) {
+		super();
+		this.steps = steps;
+	}
+	apply(doc) {
+		return this.steps.reduce((result, step) => result.docOrNull === null ? result : step.apply(result.docOrNull), StepResult.ok(doc));
+	}
+	invert(doc) {
+		return new MarkSetStep(this.steps.map((s) => s.invert(doc)));
+	}
+	map(mapping) {
+		const result = Arr.getSomes(this.steps.map((step) => step.map(mapping)));
+		return result.length ? Option.some(new MarkSetStep(result)) : Option.none();
+	}
+	toJSON() {
+		return {
+			stepType: "markSet",
+			steps: this.steps.map((s) => s.toJSON())
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(schema, json) {
+		if (!Array.isArray(json.steps) || !json.steps.every((s) => s && (s.stepType === "addMark" || s.stepType === "removeMark"))) throw new JSONError({ message: "Invalid JSON for MarkSetStep" });
+		return new MarkSetStep(json.steps.map((s) => Step.fromJSONUnsafe(schema, s)));
+	}
+};
+Step.jsonID("markSet", MarkSetStep);
+/**
+* The single step in `steps`, or a `MarkSetStep` grouping them.
+*
+* @internal
+*/
+const markStepGroup = (steps) => {
+	const [only] = steps;
+	return steps.length === 1 && only ? only : new MarkSetStep(steps);
+};
+export { MarkSetStep, markStepGroup, pushMarkStep };

package/dist/transform/mark_step.d.ts

@@ -0,0 +1,113 @@
+import { AnySchema } from "../model/schema.js";
+import { Mark } from "../model/mark.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import { Mappable } from "./map.js";
+import { Step, StepJSON, StepResult } from "./step.js";
+import * as Option from "effect/Option";
+/**
+ * Add a mark to all inline content between two positions.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+export declare class AddMarkStep<Sc extends AnySchema = AnySchema> extends Step<Sc> {
+  /** The start of the marked range. */
+  readonly from: number;
+  /** The end of the marked range. */
+  readonly to: number;
+  /** The mark to add. */
+  readonly mark: Mark<Sc>;
+  /** Create a mark step. */
+  constructor(
+  /** The start of the marked range. */
+  from: number,
+  /** The end of the marked range. */
+  to: number,
+  /** The mark to add. */
+  mark: Mark<Sc>);
+  apply(doc: Node<Sc>): StepResult<Sc>;
+  invert(doc: Node<Sc>): Step<Sc>;
+  map(mapping: Mappable): Option.Option<Step<Sc>>;
+  merge(other: Step<Sc>): Option.Option<Step<Sc>>;
+  toJSON(): StepJSON;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(schema: Sc, json: any): AddMarkStep<Sc>;
+}
+/**
+ * Remove a mark from all inline content between two positions.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+export declare class RemoveMarkStep<Sc extends AnySchema = AnySchema> extends Step<Sc> {
+  /** The start of the unmarked range. */
+  readonly from: number;
+  /** The end of the unmarked range. */
+  readonly to: number;
+  /** The mark to remove. */
+  readonly mark: Mark<Sc>;
+  /** Create a mark-removing step. */
+  constructor(
+  /** The start of the unmarked range. */
+  from: number,
+  /** The end of the unmarked range. */
+  to: number,
+  /** The mark to remove. */
+  mark: Mark<Sc>);
+  apply(doc: Node<Sc>): StepResult<Sc>;
+  invert(doc: Node<Sc>): Step<Sc>;
+  map(mapping: Mappable): Option.Option<Step<Sc>>;
+  merge(other: Step<Sc>): Option.Option<Step<Sc>>;
+  toJSON(): StepJSON;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(schema: Sc, json: any): RemoveMarkStep<Sc>;
+}
+/**
+ * Add a mark to a specific node.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+export declare class AddNodeMarkStep<Sc extends AnySchema = AnySchema> extends Step<Sc> {
+  /** The position of the target node. */
+  readonly pos: number;
+  /** The mark to add. */
+  readonly mark: Mark<Sc>;
+  /** Create a node mark step. */
+  constructor(
+  /** The position of the target node. */
+  pos: number,
+  /** The mark to add. */
+  mark: Mark<Sc>);
+  apply(doc: Node<Sc>): StepResult<Sc>;
+  invert(doc: Node<Sc>): Step<Sc>;
+  map(mapping: Mappable): Option.Option<Step<Sc>>;
+  toJSON(): StepJSON;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(schema: Sc, json: any): AddNodeMarkStep<Sc>;
+}
+/**
+ * Remove a mark from a specific node.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+export declare class RemoveNodeMarkStep<Sc extends AnySchema = AnySchema> extends Step<Sc> {
+  /** The position of the target node. */
+  readonly pos: number;
+  /** The mark to remove. */
+  readonly mark: Mark<Sc>;
+  /** Create a mark-removing step. */
+  constructor(
+  /** The position of the target node. */
+  pos: number,
+  /** The mark to remove. */
+  mark: Mark<Sc>);
+  apply(doc: Node<Sc>): StepResult<Sc>;
+  invert(doc: Node<Sc>): Step<Sc>;
+  map(mapping: Mappable): Option.Option<Step<Sc>>;
+  toJSON(): StepJSON;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(schema: Sc, json: any): RemoveNodeMarkStep<Sc>;
+}