@monstermann/delta 0.0.0

package/dist/Delta/batch.d.mts

@@ -0,0 +1,57 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/batch.d.ts
+
+/**
+ * # batch
+ *
+ * ```ts
+ * function Delta.batch<T>(
+ *   ops: Delta<T>,
+ *   transform: (delta: Delta<T>) => Delta<T>,
+ * ): Delta<T>
+ * ```
+ *
+ * Batches multiple delta operations together for improved performance.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * Delta.batch([], (delta) => {
+ *     // First change copies:
+ *     delta = Delta.insert(delta, "Hello", { bold: true });
+ *     // Other changes mutate:
+ *     delta = Delta.insert(delta, " world");
+ *     return delta;
+ * });
+ * // [{ type: "insert", value: "Hello", attributes: { bold: true } },
+ * //  { type: "insert", value: " world" }]
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * pipe(
+ *     [],
+ *     Delta.batch((delta) => {
+ *         // First change copies:
+ *         delta = Delta.insert(delta, "Hello", { bold: true });
+ *         // Other changes mutate:
+ *         delta = Delta.insert(delta, " world");
+ *         return delta;
+ *     }),
+ * );
+ * // [{ type: "insert", value: "Hello", attributes: { bold: true } },
+ * //  { type: "insert", value: " world" }]
+ * ```
+ *
+ */
+declare const batch: {
+  <T extends OpAttributes>(transform: (delta: Delta<NoInfer<T>>) => Delta<NoInfer<T>>): (ops: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(ops: Delta<T>, transform: (delta: Delta<NoInfer<T>>) => Delta<NoInfer<T>>): Delta<T>;
+};
+//#endregion
+export { batch };

package/dist/Delta/batch.mjs

@@ -0,0 +1,61 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { endMutations, startMutations } from "@monstermann/remmi";
+
+//#region src/Delta/batch.ts
+/**
+* # batch
+*
+* ```ts
+* function Delta.batch<T>(
+*   ops: Delta<T>,
+*   transform: (delta: Delta<T>) => Delta<T>,
+* ): Delta<T>
+* ```
+*
+* Batches multiple delta operations together for improved performance.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* Delta.batch([], (delta) => {
+*     // First change copies:
+*     delta = Delta.insert(delta, "Hello", { bold: true });
+*     // Other changes mutate:
+*     delta = Delta.insert(delta, " world");
+*     return delta;
+* });
+* // [{ type: "insert", value: "Hello", attributes: { bold: true } },
+* //  { type: "insert", value: " world" }]
+* ```
+*
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* pipe(
+*     [],
+*     Delta.batch((delta) => {
+*         // First change copies:
+*         delta = Delta.insert(delta, "Hello", { bold: true });
+*         // Other changes mutate:
+*         delta = Delta.insert(delta, " world");
+*         return delta;
+*     }),
+* );
+* // [{ type: "insert", value: "Hello", attributes: { bold: true } },
+* //  { type: "insert", value: " world" }]
+* ```
+*
+*/
+const batch = dfdlT((ops, transform) => {
+	startMutations();
+	try {
+		return transform(ops);
+	} finally {
+		endMutations();
+	}
+}, 2);
+
+//#endregion
+export { batch };

package/dist/Delta/chop.d.mts

@@ -0,0 +1,56 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/chop.d.ts
+
+/**
+ * # chop
+ *
+ * ```ts
+ * function Delta.chop<T>(ops: Delta<T>): Delta<T>
+ * ```
+ *
+ * Removes a trailing retain operation if it has no attributes.
+ *
+ * ## Example
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * Delta.chop(pipe(
+ *     [],
+ *     Delta.insert("Hello"),
+ *     Delta.retain(5)
+ * ));
+ * // [{ type: "insert", value: "Hello" }]
+ *
+ * Delta.chop(pipe(
+ *     [],
+ *     Delta.insert("Hello"),
+ *     Delta.retain(5, { bold: true })
+ * ));
+ * // [{ type: "insert", value: "Hello" },
+ * //  { type: "retain", value: 5, attributes: { bold: true } }]
+ * ```
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * pipe(
+ *     [],
+ *     Delta.insert("Hello"),
+ *     Delta.retain(5),
+ *     Delta.chop()
+ * );
+ * // [{ type: "insert", value: "Hello" }]
+ * ```
+ *
+ */
+declare const chop: {
+  (): <T extends OpAttributes>(ops: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(ops: Delta<T>): Delta<T>;
+};
+//#endregion
+export { chop };

package/dist/Delta/chop.mjs

@@ -0,0 +1,60 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneArray } from "@monstermann/remmi";
+
+//#region src/Delta/chop.ts
+/**
+* # chop
+*
+* ```ts
+* function Delta.chop<T>(ops: Delta<T>): Delta<T>
+* ```
+*
+* Removes a trailing retain operation if it has no attributes.
+*
+* ## Example
+*
+* <!-- prettier-ignore -->
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* Delta.chop(pipe(
+*     [],
+*     Delta.insert("Hello"),
+*     Delta.retain(5)
+* ));
+* // [{ type: "insert", value: "Hello" }]
+*
+* Delta.chop(pipe(
+*     [],
+*     Delta.insert("Hello"),
+*     Delta.retain(5, { bold: true })
+* ));
+* // [{ type: "insert", value: "Hello" },
+* //  { type: "retain", value: 5, attributes: { bold: true } }]
+* ```
+*
+* <!-- prettier-ignore -->
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* pipe(
+*     [],
+*     Delta.insert("Hello"),
+*     Delta.retain(5),
+*     Delta.chop()
+* );
+* // [{ type: "insert", value: "Hello" }]
+* ```
+*
+*/
+const chop = dfdlT((ops) => {
+	const lastOp = ops[ops.length - 1];
+	if (lastOp?.type === "retain" && !lastOp.attributes) {
+		ops = cloneArray(ops);
+		ops.pop();
+	}
+	return ops;
+}, 1);
+
+//#endregion
+export { chop };

package/dist/Delta/clean.d.mts

@@ -0,0 +1,57 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/clean.d.ts
+
+/**
+ * # clean
+ *
+ * ```ts
+ * function Delta.clean<T>(ops: Delta<T>): Delta<T>
+ * ```
+ *
+ * Normalizes the delta by merging consecutive operations of the same type and attributes.
+ *
+ * ## Example
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * Delta.clean(pipe(
+ *     [],
+ *     Delta.insert("Hello"),
+ *     Delta.insert(" world")
+ * ));
+ * // [{ type: "insert", value: "Hello world" }]
+ *
+ * Delta.clean(
+ *     pipe(
+ *         [],
+ *         Delta.insert("Hello", { bold: true }),
+ *         Delta.insert(" world", { bold: true }),
+ *     ),
+ * );
+ * // [{ type: "insert", value: "Hello world", attributes: { bold: true } }]
+ * ```
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * pipe(
+ *     [],
+ *     Delta.insert("Hello"),
+ *     Delta.insert(" world"),
+ *     Delta.clean()
+ * );
+ * // [{ type: "insert", value: "Hello world" }]
+ * ```
+ *
+ */
+declare const clean: {
+  (): <T extends OpAttributes>(ops: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(ops: Delta<T>): Delta<T>;
+};
+//#endregion
+export { clean };

package/dist/Delta/clean.mjs

@@ -0,0 +1,61 @@
+import { push } from "./push.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+import { endMutations, markAsMutable, startMutations } from "@monstermann/remmi";
+
+//#region src/Delta/clean.ts
+/**
+* # clean
+*
+* ```ts
+* function Delta.clean<T>(ops: Delta<T>): Delta<T>
+* ```
+*
+* Normalizes the delta by merging consecutive operations of the same type and attributes.
+*
+* ## Example
+*
+* <!-- prettier-ignore -->
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* Delta.clean(pipe(
+*     [],
+*     Delta.insert("Hello"),
+*     Delta.insert(" world")
+* ));
+* // [{ type: "insert", value: "Hello world" }]
+*
+* Delta.clean(
+*     pipe(
+*         [],
+*         Delta.insert("Hello", { bold: true }),
+*         Delta.insert(" world", { bold: true }),
+*     ),
+* );
+* // [{ type: "insert", value: "Hello world", attributes: { bold: true } }]
+* ```
+*
+* <!-- prettier-ignore -->
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* pipe(
+*     [],
+*     Delta.insert("Hello"),
+*     Delta.insert(" world"),
+*     Delta.clean()
+* );
+* // [{ type: "insert", value: "Hello world" }]
+* ```
+*
+*/
+const clean = dfdlT((ops) => {
+	startMutations();
+	let newOps = markAsMutable([]);
+	for (const op of ops) newOps = push(newOps, op);
+	endMutations();
+	return newOps.length === ops.length ? ops : newOps;
+}, 1);
+
+//#endregion
+export { clean };

package/dist/Delta/compose.d.mts

@@ -0,0 +1,58 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/compose.d.ts
+
+/**
+ * # compose
+ *
+ * ```ts
+ * function Delta.compose<T>(a: Delta<T>, b: Delta<T>): Delta<T>
+ * ```
+ *
+ * Composes two deltas into a single delta that represents applying `a` then `b`.
+ *
+ * ## Example
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const a = Delta.insert([], "Hello");
+ * const b = pipe(
+ *     [],
+ *     Delta.retain(5),
+ *     Delta.insert(" world")
+ * );
+ *
+ * Delta.compose(a, b);
+ * // [{ type: "insert", value: "Hello world" }]
+ *
+ * const format = Delta.retain([], 5, { bold: true });
+ *
+ * Delta.compose(a, format);
+ * // [{ type: "insert", value: "Hello", attributes: { bold: true } }]
+ * ```
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const a = Delta.insert([], "Hello");
+ * const b = pipe(
+ *     [],
+ *     Delta.retain(5),
+ *     Delta.insert(" world")
+ * );
+ *
+ * pipe(a, Delta.compose(b));
+ * // [{ type: "insert", value: "Hello world" }]
+ * ```
+ *
+ */
+declare const compose: {
+  <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 { compose };

package/dist/Delta/compose.mjs

@@ -0,0 +1,100 @@
+import { chop } from "./chop.mjs";
+import { push } from "./push.mjs";
+import { compose as compose$1 } from "../OpAttributes/compose.mjs";
+import { create } from "../OpIterator/create.mjs";
+import { peek } from "../OpIterator/peek.mjs";
+import { peekType } from "../OpIterator/peekType.mjs";
+import { peekLength } from "../OpIterator/peekLength.mjs";
+import { next } from "../OpIterator/next.mjs";
+import { hasNext } from "../OpIterator/hasNext.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+import { endMutations, markAsMutable, startMutations } from "@monstermann/remmi";
+
+//#region src/Delta/compose.ts
+/**
+* # compose
+*
+* ```ts
+* function Delta.compose<T>(a: Delta<T>, b: Delta<T>): Delta<T>
+* ```
+*
+* Composes two deltas into a single delta that represents applying `a` then `b`.
+*
+* ## Example
+*
+* <!-- prettier-ignore -->
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "Hello");
+* const b = pipe(
+*     [],
+*     Delta.retain(5),
+*     Delta.insert(" world")
+* );
+*
+* Delta.compose(a, b);
+* // [{ type: "insert", value: "Hello world" }]
+*
+* const format = Delta.retain([], 5, { bold: true });
+*
+* Delta.compose(a, format);
+* // [{ type: "insert", value: "Hello", attributes: { bold: true } }]
+* ```
+*
+* <!-- prettier-ignore -->
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "Hello");
+* const b = pipe(
+*     [],
+*     Delta.retain(5),
+*     Delta.insert(" world")
+* );
+*
+* pipe(a, Delta.compose(b));
+* // [{ type: "insert", value: "Hello world" }]
+* ```
+*
+*/
+const compose = dfdlT((a, b) => {
+	const aIter = create(a);
+	const bIter = create(b);
+	const bHead = peek(bIter);
+	startMutations();
+	let ops = markAsMutable([]);
+	if (bHead?.type === "retain" && bHead.attributes == null) {
+		let bRetain = bHead.value;
+		while (peekType(aIter) === "insert" && peekLength(aIter) <= bRetain) {
+			bRetain -= peekLength(aIter);
+			ops.push(next(aIter));
+		}
+		if (bHead.value - bRetain > 0) next(bIter, bHead.value - bRetain);
+	}
+	while (hasNext(aIter) || hasNext(bIter)) if (peekType(bIter) === "insert") ops = push(ops, next(bIter));
+	else if (peekType(aIter) === "remove") ops = push(ops, next(aIter));
+	else {
+		const length = Math.min(peekLength(aIter), peekLength(bIter));
+		const aOp = next(aIter, length);
+		const bOp = next(bIter, length);
+		if (bOp.type === "retain") {
+			if (aOp.type === "retain") ops = push(ops, {
+				attributes: compose$1(aOp.attributes, bOp.attributes, true),
+				type: "retain",
+				value: length
+			});
+			else if (aOp.type === "insert") ops = push(ops, {
+				attributes: compose$1(aOp.attributes, bOp.attributes),
+				type: "insert",
+				value: aOp.value
+			});
+		} else if (bOp.type === "remove" && aOp.type === "retain") ops = push(ops, bOp);
+	}
+	ops = chop(ops);
+	endMutations();
+	return ops;
+}, 2);
+
+//#endregion
+export { compose };

package/dist/Delta/concat.d.mts

@@ -0,0 +1,50 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/concat.d.ts
+
+/**
+ * # concat
+ *
+ * ```ts
+ * function Delta.concat<T>(a: Delta<T>, b: Delta<T>): Delta<T>
+ * ```
+ *
+ * Concatenates two deltas together, merging adjacent operations if possible.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const a = Delta.insert([], "Hello");
+ * const b = Delta.insert([], " world");
+ *
+ * Delta.concat(a, b);
+ * // [{ type: "insert", value: "Hello world" }]
+ *
+ * const bold = Delta.insert([], "Hello", { bold: true });
+ * const italic = Delta.insert([], " world", { italic: true });
+ *
+ * Delta.concat(bold, italic);
+ * // [{ type: "insert", value: "Hello", attributes: { bold: true } },
+ * //  { type: "insert", value: " world", attributes: { italic: true } }]
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const a = Delta.insert([], "Hello");
+ * const b = Delta.insert([], " world");
+ *
+ * pipe(a, Delta.concat(b));
+ * // [{ type: "insert", value: "Hello world" }]
+ * ```
+ *
+ */
+declare const concat: {
+  <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 { concat };

package/dist/Delta/concat.mjs

@@ -0,0 +1,51 @@
+import { push } from "./push.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Delta/concat.ts
+/**
+* # concat
+*
+* ```ts
+* function Delta.concat<T>(a: Delta<T>, b: Delta<T>): Delta<T>
+* ```
+*
+* Concatenates two deltas together, merging adjacent operations if possible.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "Hello");
+* const b = Delta.insert([], " world");
+*
+* Delta.concat(a, b);
+* // [{ type: "insert", value: "Hello world" }]
+*
+* const bold = Delta.insert([], "Hello", { bold: true });
+* const italic = Delta.insert([], " world", { italic: true });
+*
+* Delta.concat(bold, italic);
+* // [{ type: "insert", value: "Hello", attributes: { bold: true } },
+* //  { type: "insert", value: " world", attributes: { italic: true } }]
+* ```
+*
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "Hello");
+* const b = Delta.insert([], " world");
+*
+* pipe(a, Delta.concat(b));
+* // [{ type: "insert", value: "Hello world" }]
+* ```
+*
+*/
+const concat = dfdlT((a, b) => {
+	if (!b.length) return a;
+	if (!a.length) return b;
+	return push(a, b[0]).concat(b.slice(1));
+}, 2);
+
+//#endregion
+export { concat };

package/dist/Delta/diff.d.mts

@@ -0,0 +1,73 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/diff.d.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 " }]
+ * ```
+ *
+ */
+declare const diff: {
+  <T extends OpAttributes>(b: Delta<NoInfer<T>>, cursor?: number): (a: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(a: Delta<T>, b: Delta<NoInfer<T>>, cursor?: number): Delta<T>;
+};
+//#endregion
+export { diff };