@monstermann/delta 0.0.0

package/dist/Delta/push.mjs

@@ -0,0 +1,87 @@
+import { isEqual } from "../OpAttributes/isEqual.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneArray, endMutations, startMutations } from "@monstermann/remmi";
+
+//#region src/Delta/push.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" }]
+* ```
+*
+*/
+const push = dfdlT((ops, op) => {
+	if (!ops.length) return [op];
+	const length = ops.length;
+	const lastOp = ops[length - 1];
+	let copy = cloneArray(ops);
+	if (lastOp.type === "remove" && op.type === "remove") {
+		copy[length - 1] = {
+			attributes: void 0,
+			type: "remove",
+			value: lastOp.value + op.value
+		};
+		return copy;
+	}
+	if (lastOp.type === "remove" && op.type === "insert") {
+		startMutations();
+		copy.pop();
+		copy = push(copy, op);
+		copy.push(lastOp);
+		endMutations();
+		return copy;
+	}
+	if (lastOp.type === "insert" && op.type === "insert" && isEqual(lastOp.attributes, op.attributes)) {
+		copy[length - 1] = {
+			attributes: op.attributes,
+			type: "insert",
+			value: lastOp.value + op.value
+		};
+		return copy;
+	}
+	if (lastOp.type === "retain" && op.type === "retain" && isEqual(lastOp.attributes, op.attributes)) {
+		copy[length - 1] = {
+			attributes: op.attributes,
+			type: "retain",
+			value: lastOp.value + op.value
+		};
+		return copy;
+	}
+	copy.push(op);
+	return copy;
+}, 2);
+
+//#endregion
+export { push };

package/dist/Delta/remove.d.mts

@@ -0,0 +1,41 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/remove.d.ts
+
+/**
+ * # remove
+ *
+ * ```ts
+ * function Delta.remove<T>(ops: Delta<T>, length: number): Delta<T>
+ * ```
+ *
+ * Adds a remove operation to the delta.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * Delta.remove([], 5);
+ * // [{ type: "remove", value: 5 }]
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * pipe([], Delta.remove(5));
+ * // [{ type: "remove", value: 5 }]
+ *
+ * pipe([], Delta.retain(3), Delta.remove(5));
+ * // [{ type: "retain", value: 3 },
+ * //  { type: "remove", value: 5 }]
+ * ```
+ *
+ */
+declare const remove: {
+  <T extends OpAttributes>(length: number): (ops: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(ops: Delta<T>, length: number): Delta<T>;
+};
+//#endregion
+export { remove };

package/dist/Delta/remove.mjs

@@ -0,0 +1,46 @@
+import { push } from "./push.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Delta/remove.ts
+/**
+* # remove
+*
+* ```ts
+* function Delta.remove<T>(ops: Delta<T>, length: number): Delta<T>
+* ```
+*
+* Adds a remove operation to the delta.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* Delta.remove([], 5);
+* // [{ type: "remove", value: 5 }]
+* ```
+*
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* pipe([], Delta.remove(5));
+* // [{ type: "remove", value: 5 }]
+*
+* pipe([], Delta.retain(3), Delta.remove(5));
+* // [{ type: "retain", value: 3 },
+* //  { type: "remove", value: 5 }]
+* ```
+*
+*/
+const remove = dfdlT((ops, length) => {
+	if (!Number.isInteger(length)) return ops;
+	if (length <= 0) return ops;
+	return push(ops, {
+		attributes: void 0,
+		type: "remove",
+		value: length
+	});
+}, 2);
+
+//#endregion
+export { remove };

package/dist/Delta/retain.d.mts

@@ -0,0 +1,70 @@
+import { NullableOpAttributes, OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/retain.d.ts
+
+/**
+ * # retain
+ *
+ * ```ts
+ * function Delta.retain<T>(
+ *   ops: Delta<T>,
+ *   length: number,
+ *   attributes?: T | null,
+ * ): Delta<T>
+ * ```
+ *
+ * Adds a retain operation to the delta, optionally with attributes to apply formatting.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * Delta.retain([], 5);
+ * // [{ type: "retain", value: 5 }]
+ *
+ * Delta.retain([], 5, { bold: true });
+ * // [{ type: "retain", value: 5, attributes: { bold: true } }]
+ * ```
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * pipe([], Delta.retain(5));
+ * // [{ type: "retain", value: 5 }]
+ *
+ * pipe(
+ *     [],
+ *     Delta.retain(3),
+ *     Delta.retain(2, { italic: true })
+ * );
+ * // [{ type: "retain", value: 3 },
+ * //  { type: "retain", value: 2, attributes: { italic: true } }]
+ * ```
+ *
+ * ## Removing attributes
+ *
+ * Use `null` to remove an attribute when composing deltas:
+ *
+ * ```ts
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const doc = Delta.insert([], "Hello", { bold: true });
+ * // [{ type: "insert", value: "Hello", attributes: { bold: true } }]
+ *
+ * const removeBold = Delta.retain([], 5, { bold: null });
+ * // [{ type: "retain", value: 5, attributes: { bold: null } }]
+ *
+ * Delta.compose(doc, removeBold);
+ * // [{ type: "insert", value: "Hello" }]
+ * ```
+ *
+ */
+declare const retain: {
+  <T extends OpAttributes>(length: number, attributes?: NullableOpAttributes<NoInfer<T>> | null): (ops: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(ops: Delta<T>, length: number, attributes?: NullableOpAttributes<NoInfer<T>> | null): Delta<T>;
+};
+//#endregion
+export { retain };

package/dist/Delta/retain.mjs

@@ -0,0 +1,76 @@
+import { push } from "./push.mjs";
+import { hasKeys } from "../internals/hasKeys.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Delta/retain.ts
+/**
+* # retain
+*
+* ```ts
+* function Delta.retain<T>(
+*   ops: Delta<T>,
+*   length: number,
+*   attributes?: T | null,
+* ): Delta<T>
+* ```
+*
+* Adds a retain operation to the delta, optionally with attributes to apply formatting.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* Delta.retain([], 5);
+* // [{ type: "retain", value: 5 }]
+*
+* Delta.retain([], 5, { bold: true });
+* // [{ type: "retain", value: 5, attributes: { bold: true } }]
+* ```
+*
+* <!-- prettier-ignore -->
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* pipe([], Delta.retain(5));
+* // [{ type: "retain", value: 5 }]
+*
+* pipe(
+*     [],
+*     Delta.retain(3),
+*     Delta.retain(2, { italic: true })
+* );
+* // [{ type: "retain", value: 3 },
+* //  { type: "retain", value: 2, attributes: { italic: true } }]
+* ```
+*
+* ## Removing attributes
+*
+* Use `null` to remove an attribute when composing deltas:
+*
+* ```ts
+* import { Delta } from "@monstermann/delta";
+*
+* const doc = Delta.insert([], "Hello", { bold: true });
+* // [{ type: "insert", value: "Hello", attributes: { bold: true } }]
+*
+* const removeBold = Delta.retain([], 5, { bold: null });
+* // [{ type: "retain", value: 5, attributes: { bold: null } }]
+*
+* Delta.compose(doc, removeBold);
+* // [{ type: "insert", value: "Hello" }]
+* ```
+*
+*/
+const retain = dfdlT((ops, length, attributes) => {
+	if (!Number.isInteger(length)) return ops;
+	if (length <= 0) return ops;
+	return push(ops, {
+		attributes: attributes && hasKeys(attributes) ? attributes : void 0,
+		type: "retain",
+		value: length
+	});
+}, (args) => typeof args[0] !== "number");
+
+//#endregion
+export { retain };

package/dist/Delta/slice.d.mts

@@ -0,0 +1,64 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/slice.d.ts
+
+/**
+ * # slice
+ *
+ * ```ts
+ * function Delta.slice<T>(ops: Delta<T>, start: number, end?: number): Delta<T>
+ * ```
+ *
+ * Returns a portion of the delta from `start` to `end`.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const delta = Delta.insert([], "Hello world");
+ *
+ * Delta.slice(delta, 0, 5);
+ * // [{ type: "insert", value: "Hello" }]
+ *
+ * Delta.slice(delta, 6);
+ * // [{ type: "insert", value: "world" }]
+ *
+ * const formatted = pipe(
+ *     [],
+ *     Delta.insert("Hello", { bold: true }),
+ *     Delta.insert(" world", { italic: true }),
+ * );
+ *
+ * Delta.slice(formatted, 3, 8);
+ * // [{ type: "insert", value: "lo", attributes: { bold: true } },
+ * //  { type: "insert", value: " wo", attributes: { italic: true } }]
+ * ```
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * pipe(
+ *     [],
+ *     Delta.insert("Hello world"),
+ *     Delta.slice(0, 5)
+ * );
+ * // [{ type: "insert", value: "Hello" }]
+ *
+ * pipe(
+ *     [],
+ *     Delta.insert("Hello world"),
+ *     Delta.slice(6)
+ * );
+ * // [{ type: "insert", value: "world" }]
+ * ```
+ *
+ */
+declare const slice: {
+  (start: number, end?: number): <T extends OpAttributes>(ops: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(ops: Delta<T>, start: number, end?: number): Delta<T>;
+};
+//#endregion
+export { slice };

package/dist/Delta/slice.mjs

@@ -0,0 +1,77 @@
+import { create } from "../OpIterator/create.mjs";
+import { next } from "../OpIterator/next.mjs";
+import { hasNext } from "../OpIterator/hasNext.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Delta/slice.ts
+/**
+* # slice
+*
+* ```ts
+* function Delta.slice<T>(ops: Delta<T>, start: number, end?: number): Delta<T>
+* ```
+*
+* Returns a portion of the delta from `start` to `end`.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* const delta = Delta.insert([], "Hello world");
+*
+* Delta.slice(delta, 0, 5);
+* // [{ type: "insert", value: "Hello" }]
+*
+* Delta.slice(delta, 6);
+* // [{ type: "insert", value: "world" }]
+*
+* const formatted = pipe(
+*     [],
+*     Delta.insert("Hello", { bold: true }),
+*     Delta.insert(" world", { italic: true }),
+* );
+*
+* Delta.slice(formatted, 3, 8);
+* // [{ type: "insert", value: "lo", attributes: { bold: true } },
+* //  { type: "insert", value: " wo", attributes: { italic: true } }]
+* ```
+*
+* <!-- prettier-ignore -->
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* pipe(
+*     [],
+*     Delta.insert("Hello world"),
+*     Delta.slice(0, 5)
+* );
+* // [{ type: "insert", value: "Hello" }]
+*
+* pipe(
+*     [],
+*     Delta.insert("Hello world"),
+*     Delta.slice(6)
+* );
+* // [{ type: "insert", value: "world" }]
+* ```
+*
+*/
+const slice = dfdlT((ops, start, end = Infinity) => {
+	const newOps = [];
+	const iter = create(ops);
+	let index = 0;
+	while (index < end && hasNext(iter)) {
+		let nextOp;
+		if (index < start) nextOp = next(iter, start - index);
+		else {
+			nextOp = next(iter, end - index);
+			newOps.push(nextOp);
+		}
+		index += nextOp.type === "insert" ? nextOp.value.length : nextOp.value;
+	}
+	return newOps;
+}, (args) => typeof args[0] !== "number");
+
+//#endregion
+export { slice };

package/dist/Delta/transform.d.mts

@@ -0,0 +1,63 @@
+import { OpAttributes } from "../OpAttributes/index.mjs";
+import { Delta } from "./index.mjs";
+
+//#region src/Delta/transform.d.ts
+
+/**
+ * # transform
+ *
+ * ```ts
+ * function Delta.transform<T>(
+ *   a: Delta<T>,
+ *   b: Delta<T>,
+ *   priority?: boolean,
+ * ): Delta<T>
+ * ```
+ *
+ * Transforms delta `b` to account for delta `a` having been applied first. When both deltas insert at the same position, `priority` determines which insert comes first.
+ *
+ * ## Example
+ *
+ * <!-- prettier-ignore -->
+ * ```ts [data-first]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const a = Delta.insert([], "Hello");
+ * const b = Delta.insert([], "World");
+ *
+ * Delta.transform(a, b, true);
+ * // [{ type: "retain", value: 5 },
+ * //  { type: "insert", value: "World" }]
+ *
+ * Delta.transform(a, b, false);
+ * // [{ type: "insert", value: "World" }]
+ *
+ * const format = Delta.retain([], 5, { bold: true });
+ * const insert = pipe(
+ *     [],
+ *     Delta.retain(2),
+ *     Delta.insert("XXX")
+ * );
+ *
+ * Delta.transform(insert, format);
+ * // [{ type: "retain", value: 8, attributes: { bold: true } }]
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Delta } from "@monstermann/delta";
+ *
+ * const a = Delta.insert([], "Hello");
+ * const b = Delta.insert([], "World");
+ *
+ * pipe(a, Delta.transform(b, true));
+ * // [{ type: "retain", value: 5 },
+ * //  { type: "insert", value: "World" }]
+ * ```
+ *
+ */
+declare const transform: {
+  <T extends OpAttributes>(b: Delta<NoInfer<T>>, priority?: boolean): (a: Delta<T>) => Delta<T>;
+  <T extends OpAttributes>(a: Delta<T>, b: Delta<NoInfer<T>>, priority?: boolean): Delta<T>;
+};
+//#endregion
+export { transform };

package/dist/Delta/transform.mjs

@@ -0,0 +1,91 @@
+import { chop } from "./chop.mjs";
+import { push } from "./push.mjs";
+import { create } from "../OpIterator/create.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 { retain } from "./retain.mjs";
+import { transform as transform$1 } from "../OpAttributes/transform.mjs";
+import { dfdlT } from "@monstermann/dfdl";
+import { endMutations, markAsMutable, startMutations } from "@monstermann/remmi";
+
+//#region src/Delta/transform.ts
+/**
+* # transform
+*
+* ```ts
+* function Delta.transform<T>(
+*   a: Delta<T>,
+*   b: Delta<T>,
+*   priority?: boolean,
+* ): Delta<T>
+* ```
+*
+* Transforms delta `b` to account for delta `a` having been applied first. When both deltas insert at the same position, `priority` determines which insert comes first.
+*
+* ## Example
+*
+* <!-- prettier-ignore -->
+* ```ts [data-first]
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "Hello");
+* const b = Delta.insert([], "World");
+*
+* Delta.transform(a, b, true);
+* // [{ type: "retain", value: 5 },
+* //  { type: "insert", value: "World" }]
+*
+* Delta.transform(a, b, false);
+* // [{ type: "insert", value: "World" }]
+*
+* const format = Delta.retain([], 5, { bold: true });
+* const insert = pipe(
+*     [],
+*     Delta.retain(2),
+*     Delta.insert("XXX")
+* );
+*
+* Delta.transform(insert, format);
+* // [{ type: "retain", value: 8, attributes: { bold: true } }]
+* ```
+*
+* ```ts [data-last]
+* import { Delta } from "@monstermann/delta";
+*
+* const a = Delta.insert([], "Hello");
+* const b = Delta.insert([], "World");
+*
+* pipe(a, Delta.transform(b, true));
+* // [{ type: "retain", value: 5 },
+* //  { type: "insert", value: "World" }]
+* ```
+*
+*/
+const transform = dfdlT((a, b, priority = false) => {
+	const aIter = create(a);
+	const bIter = create(b);
+	startMutations();
+	let ops = markAsMutable([]);
+	while (hasNext(aIter) || hasNext(bIter)) if (peekType(aIter) === "insert" && (priority || peekType(bIter) !== "insert")) {
+		const aOp = next(aIter);
+		ops = retain(ops, aOp.value.length);
+	} else if (peekType(bIter) === "insert") ops = push(ops, next(bIter));
+	else {
+		const length = Math.min(peekLength(aIter), peekLength(bIter));
+		const aOp = next(aIter, length);
+		const bOp = next(bIter, length);
+		if (aOp.type === "remove") continue;
+		if (bOp.type === "remove") ops = push(ops, bOp);
+		else ops = retain(ops, length, transform$1(aOp.attributes, bOp.attributes, priority));
+	}
+	ops = chop(ops);
+	endMutations();
+	return ops;
+}, (args) => {
+	return Array.isArray(args[0]) && Array.isArray(args[1]);
+});
+
+//#endregion
+export { transform };

package/dist/Op/index.d.mts

@@ -0,0 +1,21 @@
+import { NullableOpAttributes, OpAttributes } from "../OpAttributes/index.mjs";
+
+//#region src/Op/index.d.ts
+type InsertOp<T extends OpAttributes> = {
+  attributes: NullableOpAttributes<T> | undefined;
+  type: "insert";
+  value: string;
+};
+type RetainOp<T extends OpAttributes> = {
+  attributes: NullableOpAttributes<T> | undefined;
+  type: "retain";
+  value: number;
+};
+type RemoveOp = {
+  attributes: undefined;
+  type: "remove";
+  value: number;
+};
+type Op<T extends OpAttributes = OpAttributes> = InsertOp<T> | RetainOp<T> | RemoveOp;
+//#endregion
+export { Op };

package/dist/OpAttributes/compose.d.mts

@@ -0,0 +1,6 @@
+import { NullableOpAttributes, OpAttributes } from "./index.mjs";
+
+//#region src/OpAttributes/compose.d.ts
+declare function compose<T extends OpAttributes>(a: NullableOpAttributes<T> | undefined, b: NullableOpAttributes<NoInfer<T>> | undefined, keepNull?: boolean): NullableOpAttributes<T> | undefined;
+//#endregion
+export { compose };

package/dist/OpAttributes/compose.mjs

@@ -0,0 +1,25 @@
+//#region src/OpAttributes/compose.ts
+function compose(a, b, keepNull = false) {
+	if (!b) return a;
+	if (!a) return keepNull ? b : stripNulls(b);
+	const result = {};
+	for (const key of unionKeys(a, b)) {
+		if (key in a && !(key in b)) {
+			result[key] = a[key];
+			continue;
+		}
+		if (b[key] !== null || keepNull) result[key] = b[key];
+	}
+	return Object.keys(result).length ? result : void 0;
+}
+function stripNulls(attrs) {
+	const result = {};
+	for (const key of Object.keys(attrs)) if (attrs[key] !== null) result[key] = attrs[key];
+	return Object.keys(result).length ? result : void 0;
+}
+function unionKeys(a, b) {
+	return new Set([...Object.keys(a), ...Object.keys(b)]);
+}
+
+//#endregion
+export { compose };

package/dist/OpAttributes/diff.d.mts

@@ -0,0 +1,6 @@
+import { NullableOpAttributes, OpAttributes } from "./index.mjs";
+
+//#region src/OpAttributes/diff.d.ts
+declare function diff<T extends OpAttributes>(a: NullableOpAttributes<T> | undefined, b?: NullableOpAttributes<NoInfer<T>> | undefined): NullableOpAttributes<T> | undefined;
+//#endregion
+export { diff };

package/dist/OpAttributes/diff.mjs

@@ -0,0 +1,14 @@
+//#region src/OpAttributes/diff.ts
+function diff(a, b = {}) {
+	if (!a) return b;
+	const result = {};
+	const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+	for (const key of keys) {
+		if (a[key] === b[key]) continue;
+		result[key] = key in b ? b[key] : null;
+	}
+	return Object.keys(result).length ? result : void 0;
+}
+
+//#endregion
+export { diff };