Overleaf/services/track-changes/app/js/UpdateCompressor.js

/* eslint-disable
    camelcase,
    handle-callback-err,
    new-cap,
    no-throw-literal,
    no-unused-vars,
*/
// TODO: This file was created by bulk-decaffeinate.
// Fix any style issues and re-enable lint.
/*
 * decaffeinate suggestions:
 * DS101: Remove unnecessary use of Array.from
 * DS103: Rewrite code to no longer use __guard__
 * DS207: Consider shorter variations of null checks
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
let oneMinute, twoMegabytes, UpdateCompressor;
const strInject = (s1, pos, s2) => s1.slice(0, pos) + s2 + s1.slice(pos);
const strRemove = (s1, pos, length) => s1.slice(0, pos) + s1.slice((pos + length));

const { diff_match_patch } = require("../lib/diff_match_patch");
const dmp = new diff_match_patch();

module.exports = (UpdateCompressor = {
	NOOP: "noop",

	// Updates come from the doc updater in format
	// {
	// 	op:   [ { ... op1 ... }, { ... op2 ... } ]
	// 	meta: { ts: ..., user_id: ... }
	// }
	// but it's easier to work with on op per update, so convert these updates to
	// our compressed format
	// [{
	// 	op: op1
	// 	meta: { start_ts: ... , end_ts: ..., user_id: ... }
	// }, {
	// 	op: op2
	// 	meta: { start_ts: ... , end_ts: ..., user_id: ... }
	// }]
	convertToSingleOpUpdates(updates) {
		const splitUpdates = [];
		for (const update of Array.from(updates)) {
			// Reject any non-insert or delete ops, i.e. comments
			const ops = update.op.filter(o => (o.i != null) || (o.d != null));
			if (ops.length === 0) {
				splitUpdates.push({
					op: UpdateCompressor.NOOP,
					meta: {
						start_ts: update.meta.start_ts || update.meta.ts,
						end_ts:   update.meta.end_ts   || update.meta.ts,
						user_id:  update.meta.user_id
					},
					v: update.v
				});
			} else {
				for (const op of Array.from(ops)) {
					splitUpdates.push({
						op,
						meta: {
							start_ts: update.meta.start_ts || update.meta.ts,
							end_ts:   update.meta.end_ts   || update.meta.ts,
							user_id:  update.meta.user_id
						},
						v: update.v
					});
				}
			}
		}
		return splitUpdates;
	},

	concatUpdatesWithSameVersion(updates) {
		const concattedUpdates = [];
		for (const update of Array.from(updates)) {
			const lastUpdate = concattedUpdates[concattedUpdates.length - 1];
			if ((lastUpdate != null) && (lastUpdate.v === update.v)) {
				if (update.op !== UpdateCompressor.NOOP) { lastUpdate.op.push(update.op); }
			} else {
				const nextUpdate = {
					op:   [],
					meta: update.meta,
					v:    update.v
				};
				if (update.op !== UpdateCompressor.NOOP) { nextUpdate.op.push(update.op); }
				concattedUpdates.push(nextUpdate);
			}
		}
		return concattedUpdates;
	},

	compressRawUpdates(lastPreviousUpdate, rawUpdates) {
		if (__guard__(lastPreviousUpdate != null ? lastPreviousUpdate.op : undefined, x => x.length) > 1) {
			// if the last previous update was an array op, don't compress onto it.
			// The avoids cases where array length changes but version number doesn't
			return [lastPreviousUpdate].concat(UpdateCompressor.compressRawUpdates(null,rawUpdates));
		}
		if (lastPreviousUpdate != null) {
			rawUpdates = [lastPreviousUpdate].concat(rawUpdates);
		}
		let updates = UpdateCompressor.convertToSingleOpUpdates(rawUpdates);
		updates = UpdateCompressor.compressUpdates(updates);
		return UpdateCompressor.concatUpdatesWithSameVersion(updates);
	},

	compressUpdates(updates) {
		if (updates.length === 0) { return []; }

		let compressedUpdates = [updates.shift()];
		for (const update of Array.from(updates)) {
			const lastCompressedUpdate = compressedUpdates.pop();
			if (lastCompressedUpdate != null) {
				compressedUpdates = compressedUpdates.concat(UpdateCompressor._concatTwoUpdates(lastCompressedUpdate, update));
			} else {
				compressedUpdates.push(update);
			}
		}

		return compressedUpdates;
	},

	MAX_TIME_BETWEEN_UPDATES: (oneMinute = 60 * 1000),
	MAX_UPDATE_SIZE: (twoMegabytes = 2* 1024 * 1024),

	_concatTwoUpdates(firstUpdate, secondUpdate) {
		let offset;
		firstUpdate = {
			op: firstUpdate.op,
			meta: {
				user_id:  firstUpdate.meta.user_id || null,
				start_ts: firstUpdate.meta.start_ts || firstUpdate.meta.ts,
				end_ts:   firstUpdate.meta.end_ts   || firstUpdate.meta.ts
			},
			v: firstUpdate.v
		};
		secondUpdate = {
			op: secondUpdate.op,
			meta: {
				user_id:  secondUpdate.meta.user_id || null,
				start_ts: secondUpdate.meta.start_ts || secondUpdate.meta.ts,
				end_ts:   secondUpdate.meta.end_ts   || secondUpdate.meta.ts
			},
			v: secondUpdate.v
		};

		if (firstUpdate.meta.user_id !== secondUpdate.meta.user_id) {
			return [firstUpdate, secondUpdate];
		}

		if ((secondUpdate.meta.start_ts - firstUpdate.meta.end_ts) > UpdateCompressor.MAX_TIME_BETWEEN_UPDATES) {
			return [firstUpdate, secondUpdate];
		}

		const firstOp = firstUpdate.op;
		const secondOp = secondUpdate.op;

		const firstSize = (firstOp.i != null ? firstOp.i.length : undefined) || (firstOp.d != null ? firstOp.d.length : undefined);
		const secondSize = (secondOp.i != null ? secondOp.i.length : undefined) || (secondOp.d != null ? secondOp.d.length : undefined);

		// Two inserts
		if ((firstOp.i != null) && (secondOp.i != null) && (firstOp.p <= secondOp.p && secondOp.p <= (firstOp.p + firstOp.i.length)) && ((firstSize + secondSize) < UpdateCompressor.MAX_UPDATE_SIZE)) {
			return [{
				meta: {
					start_ts: firstUpdate.meta.start_ts,
					end_ts:   secondUpdate.meta.end_ts,
					user_id:  firstUpdate.meta.user_id
				},
				op: {
					p: firstOp.p,
					i: strInject(firstOp.i, secondOp.p - firstOp.p, secondOp.i)
				},
				v: secondUpdate.v
			}
			];
		// Two deletes
		} else if ((firstOp.d != null) && (secondOp.d != null) && (secondOp.p <= firstOp.p && firstOp.p <= (secondOp.p + secondOp.d.length)) && ((firstSize + secondSize) < UpdateCompressor.MAX_UPDATE_SIZE)) {
			return [{
				meta: {
					start_ts: firstUpdate.meta.start_ts,
					end_ts:   secondUpdate.meta.end_ts,
					user_id:  firstUpdate.meta.user_id
				},
				op: {
					p: secondOp.p,
					d: strInject(secondOp.d, firstOp.p - secondOp.p, firstOp.d)
				},
				v: secondUpdate.v
			}
			];
		// An insert and then a delete
		} else if ((firstOp.i != null) && (secondOp.d != null) && (firstOp.p <= secondOp.p && secondOp.p <= (firstOp.p + firstOp.i.length))) {
			offset = secondOp.p - firstOp.p;
			const insertedText = firstOp.i.slice(offset, offset + secondOp.d.length);
			// Only trim the insert when the delete is fully contained within in it
			if (insertedText === secondOp.d) {
				const insert = strRemove(firstOp.i, offset, secondOp.d.length);
				return [{
					meta: {
						start_ts: firstUpdate.meta.start_ts,
						end_ts:   secondUpdate.meta.end_ts,
						user_id:  firstUpdate.meta.user_id
					},
					op: {
						p: firstOp.p,
						i: insert
					},
					v: secondUpdate.v
				}
				];
			} else {
				// This will only happen if the delete extends outside the insert
				return [firstUpdate, secondUpdate];
			}

		// A delete then an insert at the same place, likely a copy-paste of a chunk of content
		} else if ((firstOp.d != null) && (secondOp.i != null) && (firstOp.p === secondOp.p)) {
			offset = firstOp.p;
			const diff_ops = this.diffAsShareJsOps(firstOp.d, secondOp.i);
			if (diff_ops.length === 0) {
				return [{ // Noop
					meta: {
						start_ts: firstUpdate.meta.start_ts,
						end_ts:   secondUpdate.meta.end_ts,
						user_id:  firstUpdate.meta.user_id
					},
					op: {
						p: firstOp.p,
						i: ""
					},
					v: secondUpdate.v
				}];
			} else {
				return diff_ops.map(function(op) {
					op.p += offset;
					return {
						meta: {
							start_ts: firstUpdate.meta.start_ts,
							end_ts:   secondUpdate.meta.end_ts,
							user_id:  firstUpdate.meta.user_id
						},
						op,
						v: secondUpdate.v
					};});
			}

		} else {
			return [firstUpdate, secondUpdate];
		}
	},

	ADDED: 1,
	REMOVED: -1,
	UNCHANGED: 0,
	diffAsShareJsOps(before, after, callback) {
		if (callback == null) { callback = function(error, ops) {}; }
		const diffs = dmp.diff_main(before, after);
		dmp.diff_cleanupSemantic(diffs);

		const ops = [];
		let position = 0;
		for (const diff of Array.from(diffs)) {
			const type = diff[0];
			const content = diff[1];
			if (type === this.ADDED) {
				ops.push({
					i: content,
					p: position
				});
				position += content.length;
			} else if (type === this.REMOVED) {
				ops.push({
					d: content,
					p: position
				});
			} else if (type === this.UNCHANGED) {
				position += content.length;
			} else {
				throw "Unknown type";
			}
		}
		return ops;
	}
});

function __guard__(value, transform) {
  return (typeof value !== 'undefined' && value !== null) ? transform(value) : undefined;
}