@monstermann/delta 0.0.0

package/dist/Delta/diff.mjs

@@ -0,0 +1,124 @@
+import { chop } from "./chop.mjs";
+import { push } from "./push.mjs";
+import { create } from "../OpIterator/create.mjs";
+import { peekLength } from "../OpIterator/peekLength.mjs";
+import { next } from "../OpIterator/next.mjs";
+import { remove } from "./remove.mjs";
+import { retain } from "./retain.mjs";
+import { diff as diff$1 } from "../OpAttributes/diff.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+import { endMutations, markAsMutable, startMutations } from "@monstermann/remmi";
+import fastDiff from "fast-diff";
+
+//#region src/Delta/diff.ts
+/**
+* # diff
+*
+* ```ts
+* function Delta.diff<T>(a: Delta<T>, b: Delta<T>, cursor?: number): Delta<T>
+* ```
+*
+* Computes the difference between two document deltas, returning a delta that transforms `a` into `b`.
+*
+* The optional `cursor` parameter provides a hint about where the user's cursor is positioned. This helps produce more intuitive diffs when there are multiple valid ways to represent the same change.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "Hello");
+* const b = Delta.insert([], "Hello world");
+*
+* Delta.diff(a, b);
+* // [{ type: "retain", value: 5 },
+* //  { type: "insert", value: " world" }]
+*
+* const plain = Delta.insert([], "Hello");
+* const bold = Delta.insert([], "Hello", { bold: true });
+*
+* Delta.diff(plain, bold);
+* // [{ type: "retain", value: 5, attributes: { bold: true } }]
+* ```
+*
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "Hello");
+* const b = Delta.insert([], "Hello world");
+*
+* pipe(a, Delta.diff(b));
+* // [{ type: "retain", value: 5 },
+* //  { type: "insert", value: " world" }]
+* ```
+*
+* ## Cursor hint
+*
+* When text changes are ambiguous, the cursor position determines where the change is placed:
+*
+* ```ts
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "foo");
+* const b = Delta.insert([], "foo bar foo");
+*
+* // cursor=3: user typed " bar foo" at the end
+* Delta.diff(a, b, 3);
+* // [{ type: "retain", value: 3 },
+* //  { type: "insert", value: " bar foo" }]
+*
+* // cursor=0: user typed "foo bar " at the beginning
+* Delta.diff(a, b, 0);
+* // [{ type: "insert", value: "foo bar " }]
+* ```
+*
+*/
+const diff = dfdlT((a, b, cursor) => {
+	if (a === b) return [];
+	const aString = toText(a, "Delta.diff(a, b): a is not a document");
+	const bString = toText(b, "Delta.diff(a, b): b is not a document");
+	startMutations();
+	let ops = markAsMutable([]);
+	const diffResult = fastDiff(aString, bString, cursor, true);
+	const aIter = create(a);
+	const bIter = create(b);
+	for (const component of diffResult) {
+		const [type, text] = component;
+		let length = text.length;
+		while (length > 0) {
+			let opLength = 0;
+			if (type === fastDiff.INSERT) {
+				opLength = Math.min(peekLength(bIter), length);
+				ops = push(ops, next(bIter, opLength));
+			} else if (type === fastDiff.DELETE) {
+				opLength = Math.min(length, peekLength(aIter));
+				next(aIter, opLength);
+				ops = remove(ops, opLength);
+			} else if (type === fastDiff.EQUAL) {
+				opLength = Math.min(peekLength(aIter), peekLength(bIter), length);
+				const aOp = next(aIter, opLength);
+				const bOp = next(bIter, opLength);
+				if (aOp.type === "insert" && bOp.type === "insert" && aOp.value === bOp.value) ops = retain(ops, opLength, diff$1(aOp.attributes, bOp.attributes));
+				else {
+					ops = push(ops, bOp);
+					ops = remove(ops, opLength);
+				}
+			}
+			length -= opLength;
+		}
+	}
+	ops = chop(ops);
+	endMutations();
+	return ops;
+}, (args) => {
+	return Array.isArray(args[0]) && Array.isArray(args[1]);
+});
+function toText(ops, errMsg) {
+	return ops.map((op) => {
+		if (op.type === "insert") return op.value;
+		throw new Error(errMsg);
+	}).join("");
+}
+
+//#endregion
+export { diff };

package/dist/Delta/equals.d.mts

@@ -0,0 +1,43 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/equals.d.ts
+
+/**
+ * # equals
+ *
+ * ```ts
+ * function Delta.equals<T>(a: Delta<T>, b: Delta<T>): boolean
+ * ```
+ *
+ * Checks if two deltas are equal by comparing their operations and attributes.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const a = Delta.insert([], "Hello", { bold: true });
+ * const b = Delta.insert([], "Hello", { bold: true });
+ * const c = Delta.insert([], "Hello", { italic: true });
+ *
+ * Delta.equals(a, b); // true
+ * Delta.equals(a, c); // false
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const a = Delta.insert([], "Hello", { bold: true });
+ * const b = Delta.insert([], "Hello", { bold: true });
+ *
+ * pipe(a, Delta.equals(b)); // true
+ * ```
+ *
+ */
+declare const equals: {
+  <T extends OpAttributes>(b: Delta<NoInfer<T>>): (a: Delta<T>) => boolean;
+  <T extends OpAttributes>(a: Delta<T>, b: Delta<NoInfer<T>>): boolean;
+};
+//#endregion
+export { equals };

package/dist/Delta/equals.mjs

@@ -0,0 +1,50 @@
+import { isEqual } from "../OpAttributes/isEqual.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Delta/equals.ts
+/**
+* # equals
+*
+* ```ts
+* function Delta.equals<T>(a: Delta<T>, b: Delta<T>): boolean
+* ```
+*
+* Checks if two deltas are equal by comparing their operations and attributes.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "Hello", { bold: true });
+* const b = Delta.insert([], "Hello", { bold: true });
+* const c = Delta.insert([], "Hello", { italic: true });
+*
+* Delta.equals(a, b); // true
+* Delta.equals(a, c); // false
+* ```
+*
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "Hello", { bold: true });
+* const b = Delta.insert([], "Hello", { bold: true });
+*
+* pipe(a, Delta.equals(b)); // true
+* ```
+*
+*/
+const equals = dfdlT((a, b) => {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		const aOp = a[i];
+		const bOp = b[i];
+		if (aOp.type !== bOp.type) return false;
+		if (aOp.value !== bOp.value) return false;
+		if (!isEqual(aOp.attributes, bOp.attributes)) return false;
+	}
+	return true;
+}, 2);
+
+//#endregion
+export { equals };

package/dist/Delta/index.d.mts

@@ -0,0 +1,26 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { batch } from "./batch.mjs";
+import { chop } from "./chop.mjs";
+import { clean } from "./clean.mjs";
+import { compose } from "./compose.mjs";
+import { concat } from "./concat.mjs";
+import { diff } from "./diff.mjs";
+import { equals } from "./equals.mjs";
+import { insert } from "./insert.mjs";
+import { invert } from "./invert.mjs";
+import { length } from "./length.mjs";
+import { Op } from "../Op/index.mjs";
+import { push } from "./push.mjs";
+import { remove } from "./remove.mjs";
+import { retain } from "./retain.mjs";
+import { slice } from "./slice.mjs";
+import { transform } from "./transform.mjs";
+
+//#region src/Delta/index.d.ts
+
+type Delta<T extends OpAttributes = OpAttributes> = Op<T>[];
+declare namespace Delta {
+  export { batch, chop, clean, compose, concat, diff, equals, insert, invert, length, push, remove, retain, slice, transform };
+}
+//#endregion
+export { Delta };

package/dist/Delta/index.mjs

@@ -0,0 +1,37 @@
+import { batch } from "./batch.mjs";
+import { chop } from "./chop.mjs";
+import { push } from "./push.mjs";
+import { clean } from "./clean.mjs";
+import { compose } from "./compose.mjs";
+import { concat } from "./concat.mjs";
+import { remove } from "./remove.mjs";
+import { retain } from "./retain.mjs";
+import { diff } from "./diff.mjs";
+import { equals } from "./equals.mjs";
+import { insert } from "./insert.mjs";
+import { slice } from "./slice.mjs";
+import { invert } from "./invert.mjs";
+import { length } from "./length.mjs";
+import { transform } from "./transform.mjs";
+
+//#region src/Delta/index.js
+const Delta = {
+	batch,
+	chop,
+	clean,
+	compose,
+	concat,
+	diff,
+	equals,
+	insert,
+	invert,
+	length,
+	push,
+	remove,
+	retain,
+	slice,
+	transform
+};
+
+//#endregion
+export { Delta };

package/dist/Delta/insert.d.mts

@@ -0,0 +1,52 @@
+import { NullableOpAttributes, OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/insert.d.ts
+
+/**
+ * # insert
+ *
+ * ```ts
+ * function Delta.insert<T>(
+ *   ops: Delta<T>,
+ *   content: string,
+ *   attributes?: T | null,
+ * ): Delta<T>
+ * ```
+ *
+ * Adds an insert operation to the delta.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * Delta.insert([], "Hello");
+ * // [{ type: "insert", value: "Hello" }]
+ *
+ * Delta.insert([], "Hello", { bold: true });
+ * // [{ type: "insert", value: "Hello", attributes: { bold: true } }]
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * pipe([], Delta.insert("Hello"));
+ * // [{ type: "insert", value: "Hello" }]
+ *
+ * pipe(
+ *     [],
+ *     Delta.insert("Hello", { bold: true }),
+ *     Delta.insert(" world", { italic: true }),
+ * );
+ * // [{ type: "insert", value: "Hello", attributes: { bold: true } },
+ * //  { type: "insert", value: " world", attributes: { italic: true } }]
+ * ```
+ *
+ */
+declare const insert: {
+  <T extends OpAttributes>(content: string, attributes?: NullableOpAttributes<NoInfer<T>> | null): (ops: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(ops: Delta<T>, content: string, attributes?: NullableOpAttributes<NoInfer<T>> | null): Delta<T>;
+};
+//#endregion
+export { insert };

package/dist/Delta/insert.mjs

@@ -0,0 +1,57 @@
+import { push } from "./push.mjs";
+import { hasKeys } from "../internals/hasKeys.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Delta/insert.ts
+/**
+* # insert
+*
+* ```ts
+* function Delta.insert<T>(
+*   ops: Delta<T>,
+*   content: string,
+*   attributes?: T | null,
+* ): Delta<T>
+* ```
+*
+* Adds an insert operation to the delta.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* Delta.insert([], "Hello");
+* // [{ type: "insert", value: "Hello" }]
+*
+* Delta.insert([], "Hello", { bold: true });
+* // [{ type: "insert", value: "Hello", attributes: { bold: true } }]
+* ```
+*
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* pipe([], Delta.insert("Hello"));
+* // [{ type: "insert", value: "Hello" }]
+*
+* pipe(
+*     [],
+*     Delta.insert("Hello", { bold: true }),
+*     Delta.insert(" world", { italic: true }),
+* );
+* // [{ type: "insert", value: "Hello", attributes: { bold: true } },
+* //  { type: "insert", value: " world", attributes: { italic: true } }]
+* ```
+*
+*/
+const insert = dfdlT((ops, content, attributes) => {
+	if (!content.length) return ops;
+	return push(ops, {
+		attributes: attributes && hasKeys(attributes) ? attributes : void 0,
+		type: "insert",
+		value: content
+	});
+}, (args) => typeof args[0] !== "string");
+
+//#endregion
+export { insert };

package/dist/Delta/invert.d.mts

@@ -0,0 +1,54 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/invert.d.ts
+
+/**
+ * # invert
+ *
+ * ```ts
+ * function Delta.invert<T>(a: Delta<T>, b: Delta<T>): Delta<T>
+ * ```
+ *
+ * Returns the inverse of a delta against a base document. Applying the inverted delta undoes the original change.
+ *
+ * ## Example
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const base = Delta.insert([], "Hello");
+ * const change = Delta.retain([], 5, { bold: true });
+ *
+ * Delta.invert(change, base);
+ * // [{ type: "retain", value: 5, attributes: { bold: null } }]
+ *
+ * const insert = pipe(
+ *     [],
+ *     Delta.retain(5),
+ *     Delta.insert(" world")
+ * );
+ *
+ * Delta.invert(insert, base);
+ * // [{ type: "retain", value: 5 },
+ * //  { type: "remove", value: 6 }]
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const base = Delta.insert([], "Hello");
+ * const change = Delta.retain([], 5, { bold: true });
+ *
+ * pipe(change, Delta.invert(base));
+ * // [{ type: "retain", value: 5, attributes: { bold: null } }]
+ * ```
+ *
+ */
+declare const invert: {
+  <T extends OpAttributes>(b: Delta<NoInfer<T>>): (a: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(a: Delta<T>, b: Delta<NoInfer<T>>): Delta<T>;
+};
+//#endregion
+export { invert };

package/dist/Delta/invert.mjs

@@ -0,0 +1,77 @@
+import { chop } from "./chop.mjs";
+import { push } from "./push.mjs";
+import { remove } from "./remove.mjs";
+import { retain } from "./retain.mjs";
+import { slice } from "./slice.mjs";
+import { invert as invert$1 } from "../OpAttributes/invert.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+import { endMutations, markAsMutable, startMutations } from "@monstermann/remmi";
+
+//#region src/Delta/invert.ts
+/**
+* # invert
+*
+* ```ts
+* function Delta.invert<T>(a: Delta<T>, b: Delta<T>): Delta<T>
+* ```
+*
+* Returns the inverse of a delta against a base document. Applying the inverted delta undoes the original change.
+*
+* ## Example
+*
+* <!-- prettier-ignore -->
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* const base = Delta.insert([], "Hello");
+* const change = Delta.retain([], 5, { bold: true });
+*
+* Delta.invert(change, base);
+* // [{ type: "retain", value: 5, attributes: { bold: null } }]
+*
+* const insert = pipe(
+*     [],
+*     Delta.retain(5),
+*     Delta.insert(" world")
+* );
+*
+* Delta.invert(insert, base);
+* // [{ type: "retain", value: 5 },
+* //  { type: "remove", value: 6 }]
+* ```
+*
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* const base = Delta.insert([], "Hello");
+* const change = Delta.retain([], 5, { bold: true });
+*
+* pipe(change, Delta.invert(base));
+* // [{ type: "retain", value: 5, attributes: { bold: null } }]
+* ```
+*
+*/
+const invert = dfdlT((a, b) => {
+	startMutations();
+	let newOps = markAsMutable([]);
+	let baseIndex = 0;
+	for (const aOp of a) if (aOp.type === "insert") newOps = remove(newOps, aOp.value.length);
+	else if (aOp.type === "retain" && aOp.attributes == null) {
+		newOps = retain(newOps, aOp.value);
+		baseIndex += aOp.value;
+	} else {
+		const length = aOp.value;
+		for (const bOp of slice(b, baseIndex, baseIndex + length)) if (aOp.type === "remove") newOps = push(newOps, bOp);
+		else if (aOp.attributes) {
+			const bOpLength = bOp.type === "insert" ? bOp.value.length : bOp.value;
+			newOps = retain(newOps, bOpLength, invert$1(aOp.attributes, bOp.attributes));
+		}
+		baseIndex += length;
+	}
+	newOps = chop(newOps);
+	endMutations();
+	return newOps;
+}, 2);
+
+//#endregion
+export { invert };

package/dist/Delta/length.d.mts

@@ -0,0 +1,51 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/length.d.ts
+
+/**
+ * # length
+ *
+ * ```ts
+ * function Delta.length<T>(ops: Delta<T>): number
+ * ```
+ *
+ * Returns the total length of the delta (sum of all operation lengths).
+ *
+ * ## Example
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * Delta.length(Delta.insert([], "Hello")); // 5
+ *
+ * Delta.length(pipe(
+ *     [],
+ *     Delta.insert("Hello"),
+ *     Delta.retain(3),
+ *     Delta.remove(2)
+ * )); // 10
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * pipe([], Delta.insert("Hello"), Delta.length()); // 5
+ *
+ * pipe(
+ *     [],
+ *     Delta.insert("Hello"),
+ *     Delta.retain(3),
+ *     Delta.remove(2),
+ *     Delta.length(),
+ * ); // 10
+ * ```
+ *
+ */
+declare const length: {
+  (): <T extends OpAttributes>(ops: Delta<T>) => number;
+  <T extends OpAttributes>(ops: Delta<T>): number;
+};
+//#endregion
+export { length };

package/dist/Delta/length.mjs

@@ -0,0 +1,51 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Delta/length.ts
+/**
+* # length
+*
+* ```ts
+* function Delta.length<T>(ops: Delta<T>): number
+* ```
+*
+* Returns the total length of the delta (sum of all operation lengths).
+*
+* ## Example
+*
+* <!-- prettier-ignore -->
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* Delta.length(Delta.insert([], "Hello")); // 5
+*
+* Delta.length(pipe(
+*     [],
+*     Delta.insert("Hello"),
+*     Delta.retain(3),
+*     Delta.remove(2)
+* )); // 10
+* ```
+*
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* pipe([], Delta.insert("Hello"), Delta.length()); // 5
+*
+* pipe(
+*     [],
+*     Delta.insert("Hello"),
+*     Delta.retain(3),
+*     Delta.remove(2),
+*     Delta.length(),
+* ); // 10
+* ```
+*
+*/
+const length = dfdlT((ops) => {
+	return ops.reduce((acc, op) => {
+		return acc + (op.type === "insert" ? op.value.length : op.value);
+	}, 0);
+}, 1);
+
+//#endregion
+export { length };

package/dist/Delta/push.d.mts

@@ -0,0 +1,51 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Op } from "../Op/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/push.d.ts
+
+/**
+ * # push
+ *
+ * ```ts
+ * function Delta.push<T>(ops: Delta<T>, op: Op<T>): Delta<T>
+ * ```
+ *
+ * Pushes an operation onto the delta, merging with the previous operation if possible.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * Delta.push([], { type: "insert", value: "Hello" });
+ * // [{ type: "insert", value: "Hello" }]
+ *
+ * Delta.push(Delta.push([], { type: "insert", value: "Hello" }), {
+ *     type: "insert",
+ *     value: " world",
+ * });
+ * // [{ type: "insert", value: "Hello world" }]
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * pipe([], Delta.push({ type: "insert", value: "Hello" }));
+ * // [{ type: "insert", value: "Hello" }]
+ *
+ * pipe(
+ *     [],
+ *     Delta.push({ type: "insert", value: "Hello" }),
+ *     Delta.push({ type: "insert", value: " world" }),
+ * );
+ * // [{ type: "insert", value: "Hello world" }]
+ * ```
+ *
+ */
+declare const push: {
+  <T extends OpAttributes>(op: Op<NoInfer<T>>): (ops: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(ops: Delta<T>, op: Op<NoInfer<T>>): Delta<T>;
+};
+//#endregion
+export { push };