@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/test-builder.js

@@ -0,0 +1,239 @@
+import { seq, zeroOrMore } from "./model/content.js";
+import { DocSchema } from "./model/schema.js";
+import { Node } from "./model/node.js";
+import { marks, nodes } from "./schema-basic.js";
+import { addListNodes } from "./schema-list.js";
+// src/test-builder.ts
+/**
+* Helpers for concisely building documents in tests, ported from
+* `prosemirror-test-builder`.
+*
+* Builders are functions that take an optional attributes object and
+* any number of children (nodes, strings, or the output of mark
+* builders). Strings may contain `<name>` tags, which are removed from
+* the text and recorded (as document positions) in the resulting
+* node's `tag` object.
+*
+* ```ts skip-type-checking
+* const d = doc(p("hello <a>world"))
+* d.tag.a // => 7
+* ```
+*
+* @since 0.1.0
+*/
+const noTag = Object.create(null);
+const tags = /* @__PURE__ */ new WeakMap();
+/**
+* Get the tags recorded for a node built with a builder (empty when
+* none were recorded).
+*
+* @since 0.1.0
+* @category utils
+*/
+const tagsOf = (node) => tags.get(node) ?? noTag;
+const withTag = (node, tag) => {
+	if (tag !== noTag) tags.set(node, tag);
+	return node;
+};
+Object.defineProperty(Node.prototype, "tag", {
+	get() {
+		return tagsOf(this);
+	},
+	configurable: true
+});
+const isFlat = (u) => (typeof u === "object" || typeof u === "function") && u !== null && Array.isArray(u.flat);
+function flatten(schema, children, f) {
+	const result = [];
+	let pos = 0;
+	let tag = noTag;
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		if (typeof child === "string") {
+			const re = /<(\w+)>/g;
+			let m;
+			let at = 0, out = "";
+			while (m = re.exec(child)) {
+				out += child.slice(at, m.index);
+				pos += m.index - at;
+				at = m.index + m[0].length;
+				if (tag === noTag) tag = Object.create(null);
+				tag[m[1]] = pos;
+			}
+			out += child.slice(at);
+			pos += child.length - at;
+			if (out) result.push(f(schema.textUnsafe(out)));
+		} else if (isFlat(child)) {
+			const childTag = child.tag ?? noTag;
+			if (childTag !== noTag) {
+				if (tag === noTag) tag = Object.create(null);
+				for (const id in childTag) tag[id] = childTag[id] + pos;
+			}
+			for (let j = 0; j < child.flat.length; j++) {
+				const node = f(child.flat[j]);
+				pos += node.nodeSize;
+				result.push(node);
+			}
+		} else {
+			const node0 = child;
+			const childTag = tagsOf(node0);
+			if (childTag !== noTag) {
+				if (tag === noTag) tag = Object.create(null);
+				for (const id in childTag) tag[id] = childTag[id] + (node0.isText ? 0 : 1) + pos;
+			}
+			const node = f(node0);
+			pos += node.nodeSize;
+			result.push(node);
+		}
+	}
+	return {
+		nodes: result,
+		tag
+	};
+}
+function takeAttrs(attrs, args) {
+	const a0 = args[0];
+	if (!args.length || a0 && (typeof a0 === "string" || a0 instanceof Node || isFlat(a0))) return attrs;
+	args.shift();
+	if (!attrs) return a0;
+	if (!a0) return attrs;
+	return {
+		...attrs,
+		...a0
+	};
+}
+function block(type, attrs = null) {
+	const result = function(...args) {
+		const myAttrs = takeAttrs(attrs, args);
+		const { nodes, tag } = flatten(type.schema, args, (n) => n);
+		return withTag(type.createUnsafe(myAttrs, nodes), tag);
+	};
+	if (type.isLeaf) try {
+		result.flat = [type.createUnsafe(attrs)];
+	} catch {}
+	return result;
+}
+function mark(type, attrs) {
+	return function(...args) {
+		const m = type.createUnsafe(takeAttrs(attrs, args));
+		const { nodes, tag } = flatten(type.schema, args, (n) => {
+			const newMarks = m.addToSet(n.marks);
+			return newMarks.length > n.marks.length ? n.mark(newMarks) : n;
+		});
+		return {
+			flat: nodes,
+			tag
+		};
+	};
+}
+/**
+* Create builders for the given schema. `names` can be used to define
+* additional builders with preset attributes, using `nodeType` or
+* `markType` to specify the underlying type:
+*
+* ```ts skip-type-checking
+* builders(schema, { h1: { nodeType: "heading", level: 1 } })
+* ```
+*
+* @since 0.1.0
+* @category constructors
+*/
+function builders(schema, names) {
+	const result = { schema };
+	for (const name in schema.nodes) result[name] = block(schema.nodes[name], {});
+	for (const name in schema.marks) result[name] = mark(schema.marks[name], {});
+	if (names) for (const name in names) {
+		const value = { ...names[name] };
+		const typeName = value.nodeType || value.markType || name;
+		delete value.nodeType;
+		delete value.markType;
+		const nodeType = schema.nodes[typeName], markType = schema.marks[typeName];
+		if (nodeType) result[name] = block(nodeType, value);
+		else if (markType) result[name] = mark(markType, value);
+	}
+	return result;
+}
+/**
+* The test schema: the basic schema with list nodes added.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const schema = DocSchema.makeUnsafe({
+	nodes: addListNodes(nodes, seq("paragraph", zeroOrMore("block")), "block"),
+	marks
+});
+const b = builders(schema, {
+	p: { nodeType: "paragraph" },
+	pre: { nodeType: "code_block" },
+	h1: {
+		nodeType: "heading",
+		level: 1
+	},
+	h2: {
+		nodeType: "heading",
+		level: 2
+	},
+	h3: {
+		nodeType: "heading",
+		level: 3
+	},
+	li: { nodeType: "list_item" },
+	ul: { nodeType: "bullet_list" },
+	ol: { nodeType: "ordered_list" },
+	br: { nodeType: "hard_break" },
+	img: {
+		nodeType: "image",
+		src: "img.png"
+	},
+	hr: { nodeType: "horizontal_rule" },
+	a: {
+		markType: "link",
+		href: "foo"
+	}
+});
+/**
+* Structural equality helper.
+*
+* @since 0.1.0
+* @category utils
+*/
+function eq(a, b) {
+	return a.eq(b);
+}
+/** @since 0.1.0 */
+const doc = b.doc;
+/** @since 0.1.0 */
+const p = b.p;
+/** @since 0.1.0 */
+const code_block = b.code_block;
+/** @since 0.1.0 */
+const pre = b.pre;
+/** @since 0.1.0 */
+const h1 = b.h1;
+/** @since 0.1.0 */
+const h2 = b.h2;
+/** @since 0.1.0 */
+const h3 = b.h3;
+/** @since 0.1.0 */
+const li = b.li;
+/** @since 0.1.0 */
+const ul = b.ul;
+/** @since 0.1.0 */
+const ol = b.ol;
+/** @since 0.1.0 */
+const img = b.img;
+/** @since 0.1.0 */
+const hr = b.hr;
+/** @since 0.1.0 */
+const br = b.br;
+/** @since 0.1.0 */
+const blockquote = b.blockquote;
+/** @since 0.1.0 */
+const a = b.a;
+/** @since 0.1.0 */
+const em = b.em;
+/** @since 0.1.0 */
+const strong = b.strong;
+/** @since 0.1.0 */
+const code = b.code;
+export { a, blockquote, br, builders, code, code_block, doc, em, eq, h1, h2, h3, hr, img, li, ol, p, pre, schema, strong, tagsOf, ul };

package/dist/transform/attr_step.d.ts

@@ -0,0 +1,60 @@
+import { AnySchema } from "../model/schema.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import { Mappable, StepMap } from "./map.js";
+import { Step, StepJSON, StepResult } from "./step.js";
+import * as Option from "effect/Option";
+/**
+ * Update an attribute in a specific node.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+export declare class AttrStep<Sc extends AnySchema = AnySchema> extends Step<Sc> {
+  /** The position of the target node. */
+  readonly pos: number;
+  /** The attribute to set. */
+  readonly attr: string;
+  /** The attribute's new value. */
+  readonly value: unknown;
+  /** Construct an attribute step. */
+  constructor(
+  /** The position of the target node. */
+  pos: number,
+  /** The attribute to set. */
+  attr: string,
+  /** The attribute's new value. */
+  value: unknown);
+  apply(doc: Node<Sc>): StepResult<Sc>;
+  getMap(): StepMap;
+  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): AttrStep<Sc>;
+}
+/**
+ * Update an attribute in the doc node.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+export declare class DocAttrStep<Sc extends AnySchema = AnySchema> extends Step<Sc> {
+  /** The attribute to set. */
+  readonly attr: string;
+  /** The attribute's new value. */
+  readonly value: unknown;
+  /** Construct an attribute step. */
+  constructor(
+  /** The attribute to set. */
+  attr: string,
+  /** The attribute's new value. */
+  value: unknown);
+  apply(doc: Node<Sc>): StepResult<Sc>;
+  getMap(): StepMap;
+  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): DocAttrStep<Sc>;
+}

package/dist/transform/attr_step.js

@@ -0,0 +1,105 @@
+import { Fragment } from "../model/fragment.js";
+import { JSONError } from "../model/errors.js";
+import { Slice } from "../model/replace.js";
+import { StepMap } from "./map.js";
+import { Step, StepResult } from "./step.js";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+// src/transform/attr_step.ts
+/**
+* Attribute steps.
+*
+* @since 0.1.0
+*/
+/**
+* Update an attribute in a specific node.
+*
+* @since 0.1.0
+* @category steps
+*/
+var AttrStep = class AttrStep extends Step {
+	/** Construct an attribute step. */
+	constructor(pos, attr, value) {
+		super();
+		this.pos = pos;
+		this.attr = attr;
+		this.value = value;
+	}
+	apply(doc) {
+		const node = doc.nodeAtOrNull(this.pos);
+		if (!node) return StepResult.fail("No node at attribute step's position");
+		const attrs = Object.create(null);
+		for (const name in node.attrs) attrs[name] = node.attrs[name];
+		attrs[this.attr] = this.value;
+		const updated = node.type.createUnsafe(attrs, null, node.marks);
+		return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+	}
+	getMap() {
+		return StepMap.empty;
+	}
+	invert(doc) {
+		return new AttrStep(this.pos, this.attr, doc.nodeAtOrNull(this.pos).attrs[this.attr]);
+	}
+	map(mapping) {
+		const pos = mapping.mapResult(this.pos, 1);
+		return pos.deletedAfter ? Option.none() : Option.some(new AttrStep(pos.pos, this.attr, this.value));
+	}
+	toJSON() {
+		return {
+			stepType: "attr",
+			pos: this.pos,
+			attr: this.attr,
+			value: this.value
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(_schema, json) {
+		if (!Predicate.isNumber(json.pos) || !Predicate.isString(json.attr)) throw new JSONError({ message: "Invalid input for AttrStep.fromJSON" });
+		return new AttrStep(json.pos, json.attr, json.value);
+	}
+};
+Step.jsonID("attr", AttrStep);
+/**
+* Update an attribute in the doc node.
+*
+* @since 0.1.0
+* @category steps
+*/
+var DocAttrStep = class DocAttrStep extends Step {
+	/** Construct an attribute step. */
+	constructor(attr, value) {
+		super();
+		this.attr = attr;
+		this.value = value;
+	}
+	apply(doc) {
+		const attrs = Object.create(null);
+		for (const name in doc.attrs) attrs[name] = doc.attrs[name];
+		attrs[this.attr] = this.value;
+		const updated = doc.type.createUnsafe(attrs, doc.content, doc.marks);
+		return StepResult.ok(updated);
+	}
+	getMap() {
+		return StepMap.empty;
+	}
+	invert(doc) {
+		return new DocAttrStep(this.attr, doc.attrs[this.attr]);
+	}
+	map(_mapping) {
+		return Option.some(this);
+	}
+	toJSON() {
+		return {
+			stepType: "docAttr",
+			attr: this.attr,
+			value: this.value
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(_schema, json) {
+		if (!Predicate.isString(json.attr)) throw new JSONError({ message: "Invalid input for DocAttrStep.fromJSON" });
+		return new DocAttrStep(json.attr, json.value);
+	}
+};
+Step.jsonID("docAttr", DocAttrStep);
+export { AttrStep, DocAttrStep };

package/dist/transform/errors.d.ts

@@ -0,0 +1,50 @@
+import { ModelError } from "../model/errors.js";
+import * as Schema from "effect/Schema";
+declare const TransformError_base: Schema.Class<TransformError, Schema.TaggedStruct<"TransformError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An invalid transform operation, such as wrapping content in node
+ * types that can not contain it, splitting where splitting is not
+ * allowed, or addressing a position that holds no node. Corresponds to
+ * the `TransformError`/`RangeError`s thrown by ProseMirror's transform
+ * methods.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class TransformError extends TransformError_base {}
+declare const StepError_base: Schema.Class<StepError, Schema.TaggedStruct<"StepError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A step could not be applied to a document. The `message` is the
+ * step's failure message (see `StepResult.failed`).
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class StepError extends StepError_base {}
+/**
+ * Union of the errors defined by the transform layer.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export type TransformFailure = TransformError | StepError;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+export declare const isTransformFailure: (u: unknown) => u is TransformFailure;
+/**
+ * Errors that can be produced by transform operations: the transform
+ * layer's own errors plus model errors.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export type TransformOrModelError = TransformFailure | ModelError;
+/** @internal */
+export declare const isTransformOrModelError: (u: unknown) => u is TransformOrModelError;
+export {};

package/dist/transform/errors.js

@@ -0,0 +1,35 @@
+import { isModelError } from "../model/errors.js";
+import * as Schema from "effect/Schema";
+// src/transform/errors.ts
+/**
+* Tagged errors raised by the transform layer.
+*
+* @since 0.1.0
+*/
+/**
+* An invalid transform operation, such as wrapping content in node
+* types that can not contain it, splitting where splitting is not
+* allowed, or addressing a position that holds no node. Corresponds to
+* the `TransformError`/`RangeError`s thrown by ProseMirror's transform
+* methods.
+*
+* @since 0.1.0
+* @category errors
+*/
+var TransformError = class extends Schema.TaggedError()("TransformError", { message: Schema.String }) {};
+/**
+* A step could not be applied to a document. The `message` is the
+* step's failure message (see `StepResult.failed`).
+*
+* @since 0.1.0
+* @category errors
+*/
+var StepError = class extends Schema.TaggedError()("StepError", { message: Schema.String }) {};
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isTransformFailure = (u) => u instanceof TransformError || u instanceof StepError;
+/** @internal */
+const isTransformOrModelError = (u) => isTransformFailure(u) || isModelError(u);
+export { StepError, TransformError, isTransformFailure, isTransformOrModelError };

package/dist/transform/map.d.ts

@@ -0,0 +1,182 @@
+import * as Option from "effect/Option";
+/**
+ * There are several things that positions can be mapped through.
+ * Such objects conform to this interface.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Mappable {
+  /**
+   * Map a position through this object. When given, `assoc` (should be
+   * -1 or 1, defaults to 1) determines with which side the position is
+   * associated, which determines in which direction to move when a
+   * chunk of content is inserted at the mapped position.
+   */
+  readonly map: (pos: number, assoc?: number) => number;
+  /**
+   * Map a position, and return an object containing additional
+   * information about the mapping. The result's `deleted` field tells
+   * you whether the position was deleted (completely enclosed in a
+   * replaced range) during the mapping. When content on only one side
+   * is deleted, the position itself is only considered deleted when
+   * `assoc` points in the direction of the deleted content.
+   */
+  readonly mapResult: (pos: number, assoc?: number) => MapResult;
+}
+/**
+ * An object representing a mapped position with extra information.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class MapResult {
+  /** The mapped version of the position. */
+  readonly pos: number;
+  /** @internal */
+  readonly delInfo: number;
+  /** @internal */
+  readonly recover: number | null;
+  /** @internal */
+  constructor(
+  /** The mapped version of the position. */
+  pos: number,
+  /** @internal */
+  delInfo: number,
+  /** @internal */
+  recover: number | null);
+  /**
+   * 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(): boolean;
+  /** Tells you whether the token before the mapped position was deleted. */
+  get deletedBefore(): boolean;
+  /** True when the token after the mapped position was deleted. */
+  get deletedAfter(): boolean;
+  /**
+   * Tells whether any of the steps mapped through deletes across the
+   * position (including both the token before and after the position).
+   */
+  get deletedAcross(): boolean;
+}
+/**
+ * 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
+ */
+export declare class StepMap implements Mappable {
+  /** @internal */
+  readonly ranges: ReadonlyArray<number>;
+  /** @internal */
+  readonly inverted: boolean;
+  /**
+   * 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(
+  /** @internal */
+  ranges: ReadonlyArray<number>,
+  /** @internal */
+  inverted?: boolean);
+  /** @internal */
+  recover(value: number): number;
+  mapResult(pos: number, assoc?: number): MapResult;
+  map(pos: number, assoc?: number): number;
+  /** @internal */
+  _map(pos: number, assoc: number, simple: boolean): number | MapResult;
+  /** @internal */
+  touches(pos: number, recover: number): boolean;
+  /** Calls the given function on each of the changed ranges included in this map. */
+  forEach(f: (oldStart: number, oldEnd: number, newStart: number, newEnd: number) => void): void;
+  /**
+   * 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(): StepMap;
+  /** @internal */
+  toString(): string;
+  /**
+   * 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: number): StepMap;
+  /** A StepMap that contains no changed ranges. */
+  static readonly empty: 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
+ */
+export declare class Mapping implements Mappable {
+  /** @internal */
+  mirror?: Array<number> | undefined;
+  /**
+   * The starting position in the `maps` array, used when `map` or
+   * `mapResult` is called.
+   */
+  from: number;
+  /** The end position in the `maps` array. */
+  to: number;
+  private _maps;
+  private ownData;
+  /** Create a new mapping with the given position maps. */
+  constructor(maps?: ReadonlyArray<StepMap>,
+  /** @internal */
+  mirror?: Array<number> | undefined,
+  /**
+   * The starting position in the `maps` array, used when `map` or
+   * `mapResult` is called.
+   */
+  from?: number,
+  /** The end position in the `maps` array. */
+  to?: number);
+  /** The step maps in this mapping. */
+  get maps(): ReadonlyArray<StepMap>;
+  /** Create a mapping that maps only through a part of this one. */
+  slice(from?: number, to?: number): Mapping;
+  /**
+   * 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: StepMap, mirrors?: number): void;
+  /** Add all the step maps in a given mapping to this one (preserving mirroring information). */
+  appendMapping(mapping: Mapping): void;
+  /**
+   * 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: number): Option.Option<number>;
+  /** @internal */
+  getMirrorOrUndefined(n: number): number | undefined;
+  /** Record that the maps at offsets `n` and `m` mirror each other. */
+  setMirror(n: number, m: number): void;
+  /** Append the inverse of the given mapping to this one. */
+  appendMappingInverted(mapping: Mapping): void;
+  /** Create an inverted version of this mapping. */
+  invert(): Mapping;
+  /** Map a position through this mapping. */
+  map(pos: number, assoc?: number): number;
+  /** Map a position through this mapping, returning a mapping result. */
+  mapResult(pos: number, assoc?: number): MapResult;
+  /** @internal */
+  _map(pos: number, assoc: number, simple: boolean): number | MapResult;
+}