import { generateSHA1Hash } from '../../shared/utils/sha1' import { debugging, debugConsole } from '@/utils/debugging' import getMeta from '@/utils/meta' var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /* eslint-disable camelcase, max-len, no-class-assign, no-return-assign, no-undef, no-unused-vars, no-use-before-define, standard/object-curly-even-spacing, */ // 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 * DS102: Remove unnecessary code created because of implicit returns * DS205: Consider reworking code to avoid use of IIFEs * DS207: Consider shorter variations of null checks * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md */ export const { Doc } = (() => { var append = void 0, bootstrapTransform = void 0, exports = void 0, transformComponent = void 0; var WEB = true; window.sharejs = exports = {}; var types = exports.types = {}; // These methods let you build a transform function from a transformComponent function // for OT types like text and JSON in which operations are lists of components // and transforming them requires N^2 work. // Add transform and transformX functions for an OT type which has transformComponent defined. // transformComponent(destination array, component, other component, side) exports['_bt'] = bootstrapTransform = function bootstrapTransform(type, transformComponent, checkValidOp, append) { var _transformX = void 0; var transformComponentX = function transformComponentX(left, right, destLeft, destRight) { transformComponent(destLeft, left, right, 'left'); return transformComponent(destRight, right, left, 'right'); }; // Transforms rightOp by leftOp. Returns ['rightOp', clientOp'] type.transformX = type['transformX'] = _transformX = function transformX(leftOp, rightOp) { checkValidOp(leftOp); checkValidOp(rightOp); var newRightOp = []; var _iteratorNormalCompletion = true; var _didIteratorError = false; var _iteratorError = undefined; try { for (var _iterator = Array.from(rightOp)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { var rightComponent = _step.value; // Generate newLeftOp by composing leftOp by rightComponent var newLeftOp = []; var k = 0; while (k < leftOp.length) { var l; var nextC = []; transformComponentX(leftOp[k], rightComponent, newLeftOp, nextC); k++; if (nextC.length === 1) { rightComponent = nextC[0]; } else if (nextC.length === 0) { var _iteratorNormalCompletion2 = true; var _didIteratorError2 = false; var _iteratorError2 = undefined; try { for (var _iterator2 = Array.from(leftOp.slice(k))[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { l = _step2.value; append(newLeftOp, l); } } catch (err) { _didIteratorError2 = true; _iteratorError2 = err; } finally { try { if (!_iteratorNormalCompletion2 && _iterator2.return) { _iterator2.return(); } } finally { if (_didIteratorError2) { throw _iteratorError2; } } } rightComponent = null; break; } else { // Recurse. var _Array$from = Array.from(_transformX(leftOp.slice(k), nextC)), _Array$from2 = _slicedToArray(_Array$from, 2), l_ = _Array$from2[0], r_ = _Array$from2[1]; var _iteratorNormalCompletion3 = true; var _didIteratorError3 = false; var _iteratorError3 = undefined; try { for (var _iterator3 = Array.from(l_)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { l = _step3.value; append(newLeftOp, l); } } catch (err) { _didIteratorError3 = true; _iteratorError3 = err; } finally { try { if (!_iteratorNormalCompletion3 && _iterator3.return) { _iterator3.return(); } } finally { if (_didIteratorError3) { throw _iteratorError3; } } } var _iteratorNormalCompletion4 = true; var _didIteratorError4 = false; var _iteratorError4 = undefined; try { for (var _iterator4 = Array.from(r_)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { var r = _step4.value; append(newRightOp, r); } } catch (err) { _didIteratorError4 = true; _iteratorError4 = err; } finally { try { if (!_iteratorNormalCompletion4 && _iterator4.return) { _iterator4.return(); } } finally { if (_didIteratorError4) { throw _iteratorError4; } } } rightComponent = null; break; } } if (rightComponent != null) { append(newRightOp, rightComponent); } leftOp = newLeftOp; } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { if (!_iteratorNormalCompletion && _iterator.return) { _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } } return [leftOp, newRightOp]; }; // Transforms op with specified type ('left' or 'right') by otherOp. return type.transform = type['transform'] = function (op, otherOp, type) { var _ = void 0; if (type !== 'left' && type !== 'right') { throw new Error("type must be 'left' or 'right'"); } if (otherOp.length === 0) { return op; } // TODO: Benchmark with and without this line. I _think_ it'll make a big difference...? if (op.length === 1 && otherOp.length === 1) { return transformComponent([], op[0], otherOp[0], type); } if (type === 'left') { var left = void 0; var _Array$from3 = Array.from(_transformX(op, otherOp)); var _Array$from4 = _slicedToArray(_Array$from3, 2); left = _Array$from4[0]; _ = _Array$from4[1]; return left; } else { var right = void 0; var _Array$from5 = Array.from(_transformX(otherOp, op)); var _Array$from6 = _slicedToArray(_Array$from5, 2); _ = _Array$from6[0]; right = _Array$from6[1]; return right; } }; }; // A simple text implementation // // Operations are lists of components. // Each component either inserts or deletes at a specified position in the document. // // Components are either: // {i:'str', p:100}: Insert 'str' at position 100 in the document // {d:'str', p:100}: Delete 'str' at position 100 in the document // // Components in an operation are executed sequentially, so the position of components // assumes previous components have already executed. // // Eg: This op: // [{i:'abc', p:0}] // is equivalent to this op: // [{i:'a', p:0}, {i:'b', p:1}, {i:'c', p:2}] // NOTE: The global scope here is shared with other sharejs files when built with closure. // Be careful what ends up in your namespace. var text = {}; text.name = 'text'; text.create = function () { return ''; }; var strInject = function strInject(s1, pos, s2) { return s1.slice(0, pos) + s2 + s1.slice(pos); }; var checkValidComponent = function checkValidComponent(c) { if (typeof c.p !== 'number') { throw new Error('component missing position field'); } var i_type = _typeof(c.i); var d_type = _typeof(c.d); var c_type = _typeof(c.c); if (!(i_type === 'string' ^ d_type === 'string' ^ c_type === 'string')) { throw new Error('component needs an i, d or c field'); } if (!(c.p >= 0)) { throw new Error('position cannot be negative'); } }; var checkValidOp = function checkValidOp(op) { var _iteratorNormalCompletion5 = true; var _didIteratorError5 = false; var _iteratorError5 = undefined; try { for (var _iterator5 = Array.from(op)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) { var c = _step5.value; checkValidComponent(c); } } catch (err) { _didIteratorError5 = true; _iteratorError5 = err; } finally { try { if (!_iteratorNormalCompletion5 && _iterator5.return) { _iterator5.return(); } } finally { if (_didIteratorError5) { throw _iteratorError5; } } } return true; }; text.apply = function (snapshot, op) { checkValidOp(op); var _iteratorNormalCompletion6 = true; var _didIteratorError6 = false; var _iteratorError6 = undefined; try { for (var _iterator6 = Array.from(op)[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) { var component = _step6.value; if (component.i != null) { snapshot = strInject(snapshot, component.p, component.i); } else if (component.d != null) { var deleted = snapshot.slice(component.p, component.p + component.d.length); if (component.d !== deleted) { throw new Error('Delete component \'' + component.d + '\' does not match deleted text \'' + deleted + '\''); } snapshot = snapshot.slice(0, component.p) + snapshot.slice(component.p + component.d.length); } else if (component.c != null) { var comment = snapshot.slice(component.p, component.p + component.c.length); if (component.c !== comment) { throw new Error('Comment component \'' + component.c + '\' does not match commented text \'' + comment + '\''); } } else { throw new Error('Unknown op type'); } } } catch (err) { _didIteratorError6 = true; _iteratorError6 = err; } finally { try { if (!_iteratorNormalCompletion6 && _iterator6.return) { _iterator6.return(); } } finally { if (_didIteratorError6) { throw _iteratorError6; } } } return snapshot; }; var cloneAndModify = function cloneAndModify(op, modifications) { var v = void 0; var newOp = {}; for (var k in op) { v = op[k]; newOp[k] = v; } for (k in modifications) { v = modifications[k]; newOp[k] = v; } return newOp; }; // Exported for use by the random op generator. // // For simplicity, this version of append does not compress adjacent inserts and deletes of // the same text. It would be nice to change that at some stage. text._append = append = function append(newOp, c) { if (c.i === '' || c.d === '') { return; } if (newOp.length === 0) { return newOp.push(c); } else { var last = newOp[newOp.length - 1]; // Compose the insert into the previous insert if possible if (last.i != null && c.i != null && last.p <= c.p && c.p <= last.p + last.i.length && last.u === c.u) { return newOp[newOp.length - 1] = cloneAndModify(last, { i: strInject(last.i, c.p - last.p, c.i) }); } else if (last.d != null && c.d != null && c.p <= last.p && last.p <= c.p + c.d.length && last.u === c.u) { return newOp[newOp.length - 1] = cloneAndModify(last, { d: strInject(c.d, last.p - c.p, last.d), p: c.p }); } else { return newOp.push(c); } } }; text.compose = function (op1, op2) { checkValidOp(op1); checkValidOp(op2); var newOp = op1.slice(); var _iteratorNormalCompletion7 = true; var _didIteratorError7 = false; var _iteratorError7 = undefined; try { for (var _iterator7 = Array.from(op2)[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) { var c = _step7.value; append(newOp, c); } } catch (err) { _didIteratorError7 = true; _iteratorError7 = err; } finally { try { if (!_iteratorNormalCompletion7 && _iterator7.return) { _iterator7.return(); } } finally { if (_didIteratorError7) { throw _iteratorError7; } } } return newOp; }; // Attempt to compress the op components together 'as much as possible'. // This implementation preserves order and preserves create/delete pairs. text.compress = function (op) { return text.compose([], op); }; text.normalize = function (op) { var newOp = []; // Normalize should allow ops which are a single (unwrapped) component: // {i:'asdf', p:23}. // There's no good way to test if something is an array: // http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/ // so this is probably the least bad solution. if (op.i != null || op.p != null) { op = [op]; } var _iteratorNormalCompletion8 = true; var _didIteratorError8 = false; var _iteratorError8 = undefined; try { for (var _iterator8 = Array.from(op)[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) { var c = _step8.value; if (c.p == null) { c.p = 0; } append(newOp, c); } } catch (err) { _didIteratorError8 = true; _iteratorError8 = err; } finally { try { if (!_iteratorNormalCompletion8 && _iterator8.return) { _iterator8.return(); } } finally { if (_didIteratorError8) { throw _iteratorError8; } } } return newOp; }; // This helper method transforms a position by an op component. // // If c is an insert, insertAfter specifies whether the transform // is pushed after the insert (true) or before it (false). // // insertAfter is optional for deletes. var transformPosition = function transformPosition(pos, c, insertAfter) { if (c.i != null) { if (c.p < pos || c.p === pos && insertAfter) { return pos + c.i.length; } else { return pos; } } else if (c.d != null) { // I think this could also be written as: Math.min(c.p, Math.min(c.p - otherC.p, otherC.d.length)) // but I think its harder to read that way, and it compiles using ternary operators anyway // so its no slower written like this. if (pos <= c.p) { return pos; } else if (pos <= c.p + c.d.length) { return c.p; } else { return pos - c.d.length; } } else if (c.c != null) { return pos; } else { throw new Error('unknown op type'); } }; // Helper method to transform a cursor position as a result of an op. // // Like transformPosition above, if c is an insert, insertAfter specifies whether the cursor position // is pushed after an insert (true) or before it (false). text.transformCursor = function (position, op, side) { var insertAfter = side === 'right'; var _iteratorNormalCompletion9 = true; var _didIteratorError9 = false; var _iteratorError9 = undefined; try { for (var _iterator9 = Array.from(op)[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) { var c = _step9.value; position = transformPosition(position, c, insertAfter); } } catch (err) { _didIteratorError9 = true; _iteratorError9 = err; } finally { try { if (!_iteratorNormalCompletion9 && _iterator9.return) { _iterator9.return(); } } finally { if (_didIteratorError9) { throw _iteratorError9; } } } return position; }; // Transform an op component by another op component. Asymmetric. // The result will be appended to destination. // // exported for use in JSON type text._tc = transformComponent = function transformComponent(dest, c, otherC, side) { var cIntersect = void 0, intersectEnd = void 0, intersectStart = void 0, newC = void 0, otherIntersect = void 0; checkValidOp([c]); checkValidOp([otherC]); if (c.i != null) { append(dest, cloneAndModify(c, { p: transformPosition(c.p, otherC, side === 'right') })); } else if (c.d != null) { // Delete if (otherC.i != null) { // delete vs insert var s = c.d; if (c.p < otherC.p) { append(dest, cloneAndModify(c, { d: s.slice(0, otherC.p - c.p) })); s = s.slice(otherC.p - c.p); } if (s !== '') { append(dest, cloneAndModify(c, { d: s, p: c.p + otherC.i.length })); } } else if (otherC.d != null) { // Delete vs delete if (c.p >= otherC.p + otherC.d.length) { append(dest, cloneAndModify(c, { p: c.p - otherC.d.length })); } else if (c.p + c.d.length <= otherC.p) { append(dest, c); } else { // They overlap somewhere. newC = cloneAndModify(c, { d: '' }); if (c.p < otherC.p) { newC.d = c.d.slice(0, otherC.p - c.p); } if (c.p + c.d.length > otherC.p + otherC.d.length) { newC.d += c.d.slice(otherC.p + otherC.d.length - c.p); } // This is entirely optional - just for a check that the deleted // text in the two ops matches intersectStart = Math.max(c.p, otherC.p); intersectEnd = Math.min(c.p + c.d.length, otherC.p + otherC.d.length); cIntersect = c.d.slice(intersectStart - c.p, intersectEnd - c.p); otherIntersect = otherC.d.slice(intersectStart - otherC.p, intersectEnd - otherC.p); if (cIntersect !== otherIntersect) { throw new Error('Delete ops delete different text in the same region of the document'); } if (newC.d !== '') { // This could be rewritten similarly to insert v delete, above. newC.p = transformPosition(newC.p, otherC); append(dest, newC); } } } else if (otherC.c != null) { append(dest, c); } else { throw new Error('unknown op type'); } } else if (c.c != null) { // Comment if (otherC.i != null) { if (c.p < otherC.p && otherC.p < c.p + c.c.length) { var offset = otherC.p - c.p; var new_c = c.c.slice(0, +(offset - 1) + 1 || undefined) + otherC.i + c.c.slice(offset); append(dest, cloneAndModify(c, { c: new_c })); } else { append(dest, cloneAndModify(c, { p: transformPosition(c.p, otherC, true) })); } } else if (otherC.d != null) { if (c.p >= otherC.p + otherC.d.length) { append(dest, cloneAndModify(c, { p: c.p - otherC.d.length })); } else if (c.p + c.c.length <= otherC.p) { append(dest, c); } else { // Delete overlaps comment // They overlap somewhere. newC = cloneAndModify(c, { c: '' }); if (c.p < otherC.p) { newC.c = c.c.slice(0, otherC.p - c.p); } if (c.p + c.c.length > otherC.p + otherC.d.length) { newC.c += c.c.slice(otherC.p + otherC.d.length - c.p); } // This is entirely optional - just for a check that the deleted // text in the two ops matches intersectStart = Math.max(c.p, otherC.p); intersectEnd = Math.min(c.p + c.c.length, otherC.p + otherC.d.length); cIntersect = c.c.slice(intersectStart - c.p, intersectEnd - c.p); otherIntersect = otherC.d.slice(intersectStart - otherC.p, intersectEnd - otherC.p); if (cIntersect !== otherIntersect) { throw new Error('Delete ops delete different text in the same region of the document'); } newC.p = transformPosition(newC.p, otherC); append(dest, newC); } } else if (otherC.c != null) { append(dest, c); } else { throw new Error('unknown op type'); } } return dest; }; var invertComponent = function invertComponent(c) { if (c.i != null) { return { d: c.i, p: c.p }; } else { return { i: c.d, p: c.p }; } }; // No need to use append for invert, because the components won't be able to // cancel with one another. text.invert = function (op) { return Array.from(op.slice().reverse()).map(function (c) { return invertComponent(c); }); }; if (WEB != null) { if (!exports.types) { exports.types = {}; } // This is kind of awful - come up with a better way to hook this helper code up. bootstrapTransform(text, transformComponent, checkValidOp, append); // [] is used to prevent closure from renaming types.text exports.types.text = text; } // Text document API for text text.api = { provides: { text: true }, // The number of characters in the string getLength: function getLength() { return this.snapshot.length; }, // Get the text contents of a document getText: function getText() { return this.snapshot; }, insert: function insert(pos, text, fromUndo, callback) { var op = { p: pos, i: text }; if (fromUndo) { op.u = true; } op = [op]; this.submitOp(op, callback); return op; }, del: function del(pos, length, fromUndo, callback) { var op = { p: pos, d: this.snapshot.slice(pos, pos + length) }; if (fromUndo) { op.u = true; } op = [op]; this.submitOp(op, callback); return op; }, _register: function _register() { return this.on('remoteop', function (op) { var _this = this; return function () { var result = []; var _iteratorNormalCompletion10 = true; var _didIteratorError10 = false; var _iteratorError10 = undefined; try { for (var _iterator10 = Array.from(op)[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) { var component = _step10.value; if (component.i !== undefined) { result.push(_this.emit('insert', component.p, component.i)); } else if (component.d !== undefined) { result.push(_this.emit('delete', component.p, component.d)); } else { result.push(undefined); } } } catch (err) { _didIteratorError10 = true; _iteratorError10 = err; } finally { try { if (!_iteratorNormalCompletion10 && _iterator10.return) { _iterator10.return(); } } finally { if (_didIteratorError10) { throw _iteratorError10; } } } return result; }(); }); } }; // This is a simple port of microevent.js to Coffeescript. I've changed the // function names to be consistent with node.js EventEmitter. // // microevent.js is copyright Jerome Etienne, and licensed under the MIT license: // https://github.com/jeromeetienne/microevent.js var nextTick = WEB != null ? function (fn) { return setTimeout(fn, 0); } : process['nextTick']; var MicroEvent = function () { function MicroEvent() { _classCallCheck(this, MicroEvent); } _createClass(MicroEvent, [{ key: 'on', value: function on(event, fct) { if (!this._events) { this._events = {}; } if (!this._events[event]) { this._events[event] = []; } this._events[event].push(fct); return this; } }, { key: 'removeListener', value: function removeListener(event, fct) { var _this2 = this; if (!this._events) { this._events = {}; } var listeners = this._events[event] || (this._events[event] = []); // Sadly, there's no IE8- support for indexOf. var i = 0; while (i < listeners.length) { if (listeners[i] === fct) { listeners[i] = undefined; } i++; } nextTick(function () { return _this2._events[event] = Array.from(_this2._events[event]).filter(function (x) { return x; }); }); return this; } }, { key: 'emit', value: function emit(event) { if (!(this._events != null ? this._events[event] : undefined)) { return this; } for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { args[_key - 1] = arguments[_key]; } var _iteratorNormalCompletion11 = true; var _didIteratorError11 = false; var _iteratorError11 = undefined; try { for (var _iterator11 = Array.from(this._events[event])[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) { var fn = _step11.value; if (fn) { fn.apply(this, args); } } } catch (err) { _didIteratorError11 = true; _iteratorError11 = err; } finally { try { if (!_iteratorNormalCompletion11 && _iterator11.return) { _iterator11.return(); } } finally { if (_didIteratorError11) { throw _iteratorError11; } } } return this; } }]); return MicroEvent; }(); // mixin will delegate all MicroEvent.js function in the destination object MicroEvent.mixin = function (obj) { var proto = obj.prototype || obj; // Damn closure compiler :/ proto.on = MicroEvent.prototype.on; proto.removeListener = MicroEvent.prototype.removeListener; proto.emit = MicroEvent.prototype.emit; return obj; }; if (WEB == null) { module.exports = MicroEvent; } if (WEB != null) { exports.extendDoc = function (name, fn) { return Doc.prototype[name] = fn; }; } // A Doc is a client's view on a sharejs document. // // Documents are created by calling Connection.open(). // // Documents are event emitters - use doc.on(eventname, fn) to subscribe. // // Documents get mixed in with their type's API methods. So, you can .insert('foo', 0) into // a text document and stuff like that. // // Events: // - remoteop (op) // - changed (op) // - acknowledge (op) // - error // - open, closing, closed. 'closing' is not guaranteed to fire before closed. var Doc = function () { // connection is a Connection object. // name is the documents' docName. // data can optionally contain known document data, and initial open() call arguments: // {v[erson], snapshot={...}, type, create=true/false/undefined} // callback will be called once the document is first opened. function Doc(connection, name, openData) { _classCallCheck(this, Doc); // Any of these can be null / undefined at this stage. this.flush = this.flush.bind(this); this.setFlushDelay = this.setFlushDelay.bind(this); this.shout = this.shout.bind(this); this.connection = connection; this.name = name; if (!openData) { openData = {}; } this.version = openData.v; this.snapshot = openData.snaphot; if (openData.type) { this._setType(openData.type); } this.state = 'closed'; this.autoOpen = false; // Has the document already been created? this._create = openData.create; // The op that is currently roundtripping to the server, or null. // // When the connection reconnects, the inflight op is resubmitted. this.inflightOp = null; this.inflightCallbacks = []; // The auth ids which the client has previously used to attempt to send inflightOp. This is // usually empty. this.inflightSubmittedIds = []; // All ops that are waiting for the server to acknowledge @inflightOp this.pendingOp = null; this.pendingCallbacks = []; } // Transform a server op by a client op, and vice versa. _createClass(Doc, [{ key: '_xf', value: function _xf(client, server) { if (this.type.transformX) { return this.type.transformX(client, server); } else { var client_ = this.type.transform(client, server, 'left'); var server_ = this.type.transform(server, client, 'right'); return [client_, server_]; } } }, { key: '_otApply', value: function _otApply(docOp, isRemote, msg) { var oldSnapshot = this.snapshot; this.snapshot = this.type.apply(this.snapshot, docOp); // Its important that these event handlers are called with oldSnapshot. // The reason is that the OT type APIs might need to access the snapshots to // determine information about the received op. this.emit('change', docOp, oldSnapshot, msg); if (isRemote) { return this.emit('remoteop', docOp, oldSnapshot, msg); } } }, { key: '_connectionStateChanged', value: function _connectionStateChanged(state, data) { switch (state) { case 'disconnected': this.state = 'closed'; // This is used by the server to make sure that when an op is resubmitted it // doesn't end up getting applied twice. if (this.inflightOp) { this.inflightSubmittedIds.push(this.connection.id); } this.emit('closed'); break; case 'ok': // Might be able to do this when we're connecting... that would save a roundtrip. if (this.autoOpen) { this.open(); } break; case 'stopped': if (typeof this._openCallback === 'function') { this._openCallback(data); } break; } return this.emit(state, data); } }, { key: '_setType', value: function _setType(type) { if (typeof type === 'string') { type = types[type]; } if (!type || !type.compose) { throw new Error('Support for types without compose() is not implemented'); } this.type = type; if (type.api) { for (var k in type.api) { var v = type.api[k];this[k] = v; } return typeof this._register === 'function' ? this._register() : undefined; } else { return this.provides = {}; } } }, { key: '_onMessage', value: function _onMessage(msg) { // debugConsole.warn('s->c', msg) if (msg.open === true) { // The document has been successfully opened. this.state = 'open'; this._create = false; // Don't try and create the document again next time open() is called. if (this.created == null) { this.created = !!msg.create; } if (msg.type) { this._setType(msg.type); } if (msg.create) { this.created = true; this.snapshot = this.type.create(); } else { if (this.created !== true) { this.created = false; } if (msg.snapshot !== undefined) { this.snapshot = msg.snapshot; } } if (msg.v != null) { this.version = msg.v; } // Resend any previously queued operation. if (this.inflightOp) { var response = { doc: this.name, op: this.inflightOp, v: this.version }; if (this.inflightSubmittedIds.length) { response.dupIfSource = this.inflightSubmittedIds; } this.connection.send(response); } else { this.flush(); } this.emit('open'); return typeof this._openCallback === 'function' ? this._openCallback(null) : undefined; } else if (msg.open === false) { // The document has either been closed, or an open request has failed. if (msg.error) { // An error occurred opening the document. debugConsole.error('Could not open document: ' + msg.error); this.emit('error', msg.error); if (typeof this._openCallback === 'function') { this._openCallback(msg.error); } } this.state = 'closed'; this.emit('closed'); if (typeof this._closeCallback === 'function') { this._closeCallback(); } return this._closeCallback = null; } else if (msg.op === null && error === 'Op already submitted') { // We've tried to resend an op to the server, which has already been received successfully. Do nothing. // The op will be confirmed normally when we get the op itself was echoed back from the server // (handled below). } else if (msg.op === undefined && msg.v !== undefined || msg.op && Array.from(this.inflightSubmittedIds).includes(msg.meta.source)) { // Our inflight op has been acknowledged. var callback = void 0; var oldInflightOp = this.inflightOp; this.inflightOp = null; this.inflightSubmittedIds.length = 0; if (this.pendingOp === null) { // All ops are acked this.emit('saved'); } var error = msg.error; if (error) { // The server has rejected an op from the client for some reason. // We'll send the error message to the user and roll back the change. // // If the server isn't going to allow edits anyway, we should probably // figure out some way to flag that (readonly:true in the open request?) if (this.type.invert) { var undo = this.type.invert(oldInflightOp); // Now we have to transform the undo operation by any server ops & pending ops if (this.pendingOp) { var _Array$from7 = Array.from(this._xf(this.pendingOp, undo)); var _Array$from8 = _slicedToArray(_Array$from7, 2); this.pendingOp = _Array$from8[0]; undo = _Array$from8[1]; } // ... and apply it locally, reverting the changes. // // This call will also call @emit 'remoteop'. I'm still not 100% sure about this // functionality, because its really a local op. Basically, the problem is that // if the client's op is rejected by the server, the editor window should update // to reflect the undo. this._otApply(undo, true, msg); } else { this.emit('error', 'Op apply failed (' + error + ') and the op could not be reverted'); } var _iteratorNormalCompletion12 = true; var _didIteratorError12 = false; var _iteratorError12 = undefined; try { for (var _iterator12 = Array.from(this.inflightCallbacks)[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) { callback = _step12.value; callback(error); } } catch (err) { _didIteratorError12 = true; _iteratorError12 = err; } finally { try { if (!_iteratorNormalCompletion12 && _iterator12.return) { _iterator12.return(); } } finally { if (_didIteratorError12) { throw _iteratorError12; } } } } else { // The op applied successfully. // We may get multiple acks of the same message if we retried it, // so its ok if we receive an ack for a version that we've already gone past. // If so, just ignore it if (msg.v < this.version) { return; } if (msg.v !== this.version) { throw new Error('Invalid version from server'); } this.version++; this.emit('acknowledge', oldInflightOp); var _iteratorNormalCompletion13 = true; var _didIteratorError13 = false; var _iteratorError13 = undefined; try { for (var _iterator13 = Array.from(this.inflightCallbacks)[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) { callback = _step13.value; callback(null, oldInflightOp); } } catch (err) { _didIteratorError13 = true; _iteratorError13 = err; } finally { try { if (!_iteratorNormalCompletion13 && _iterator13.return) { _iterator13.return(); } } finally { if (_didIteratorError13) { throw _iteratorError13; } } } } // Send the next op. return this.delayedFlush(); } else if (msg.op) { // We got a new op from the server. // msg is {doc:, op:, v:} // There is a bug in socket.io (produced on firefox 3.6) which causes messages // to be duplicated sometimes. // We'll just silently drop subsequent messages. if (msg.v < this.version) { return; } if (msg.doc !== this.name) { return this.emit('error', 'Expected docName \'' + this.name + '\' but got ' + msg.doc); } if (msg.v !== this.version) { return this.emit('error', 'Expected version ' + this.version + ' but got ' + msg.v); } // p "if: #{i @inflightOp} pending: #{i @pendingOp} doc '#{@snapshot}' op: #{i msg.op}" var docOp = msg.op; if (this.inflightOp !== null) { var _Array$from9 = Array.from(this._xf(this.inflightOp, docOp)); var _Array$from10 = _slicedToArray(_Array$from9, 2); this.inflightOp = _Array$from10[0]; docOp = _Array$from10[1]; } if (this.pendingOp !== null) { var _Array$from11 = Array.from(this._xf(this.pendingOp, docOp)); var _Array$from12 = _slicedToArray(_Array$from11, 2); this.pendingOp = _Array$from12[0]; docOp = _Array$from12[1]; } this.version++; // Finally, apply the op to @snapshot and trigger any event listeners return this._otApply(docOp, true, msg); } else if (msg.meta) { var _msg$meta = msg.meta, path = _msg$meta.path, value = _msg$meta.value; switch (path != null ? path[0] : undefined) { case 'shout': return this.emit('shout', value); default: return debugConsole.warn('Unhandled meta op:', msg); } } else { return debugConsole.warn('Unhandled document message:', msg); } } // Send ops to the server, if appropriate. // // Only one op can be in-flight at a time, so if an op is already on its way then // this method does nothing. }, { key: 'flush', value: function flush() { this.flushTimeout = null; // console.log "CALLED FLUSH" if (this.connection.state !== 'ok' || this.inflightOp !== null || this.pendingOp === null) { return; } // Rotate null -> pending -> inflight this.inflightOp = this.pendingOp; this.inflightCallbacks = this.pendingCallbacks; this.pendingOp = null; this.pendingCallbacks = []; this.emit('flipped_pending_to_inflight'); if (getMeta('ol-useShareJsHash') || debugging) { var now = Date.now() var age = this.__lastSubmitTimestamp && (now - this.__lastSubmitTimestamp) var RECOMPUTE_HASH_INTERVAL = 5000 // check the document hash regularly (but not if we have checked in the last 5 seconds) var needToRecomputeHash = !this.__lastSubmitTimestamp || (age > RECOMPUTE_HASH_INTERVAL) || (age < 0) if (needToRecomputeHash || debugging) { // send git hash of current snapshot var sha1 = generateSHA1Hash("blob " + this.snapshot.length + "\x00" + this.snapshot) this.__lastSubmitTimestamp = now; } } // console.log "SENDING OP TO SERVER", @inflightOp, @version var lastVersion = this.__lastVersion; this.__lastVersion = this.version; return this.connection.send({ doc: this.name, op: this.inflightOp, v: this.version, lastV: lastVersion, hash: sha1}); } // Submit an op to the server. The op maybe held for a little while before being sent, as only one // op can be inflight at any time. }, { key: 'submitOp', value: function submitOp(op, callback) { if (this.type.normalize != null) { op = this.type.normalize(op); } var oldSnapshot = this.snapshot; // If this throws an exception, no changes should have been made to the doc this.snapshot = this.type.apply(this.snapshot, op); if (this.pendingOp !== null) { this.pendingOp = this.type.compose(this.pendingOp, op); } else { this.pendingOp = op; } if (callback) { this.pendingCallbacks.push(callback); } this.emit('change', op, oldSnapshot); return this.delayedFlush(); } }, { key: 'delayedFlush', value: function delayedFlush() { if (this.flushTimeout == null) { return this.flushTimeout = setTimeout(this.flush, this._flushDelay || 0); } } }, { key: 'setFlushDelay', value: function setFlushDelay(delay) { return this._flushDelay = delay; } }, { key: 'shout', value: function shout(msg) { // Meta ops don't have to queue, they can go direct. Good/bad idea? return this.connection.send({ doc: this.name, meta: { path: ['shout'], value: msg } }); } // Open a document. The document starts closed. }, { key: 'open', value: function open(callback) { var _this3 = this; this.autoOpen = true; if (this.state !== 'closed') { return; } var message = { doc: this.name, open: true }; if (this.snapshot === undefined) { message.snapshot = null; } if (this.type) { message.type = this.type.name; } if (this.version != null) { message.v = this.version; } if (this._create) { message.create = true; } this.connection.send(message); this.state = 'opening'; return this._openCallback = function (error) { _this3._openCallback = null; return typeof callback === 'function' ? callback(error) : undefined; }; } // Close a document. }, { key: 'close', value: function close(callback) { this.autoOpen = false; if (this.state === 'closed') { return typeof callback === 'function' ? callback() : undefined; } this.connection.send({ doc: this.name, open: false }); // Should this happen immediately or when we get open:false back from the server? this.state = 'closed'; this.emit('closing'); return this._closeCallback = callback; } }]); return Doc; }(); // Make documents event emitters MicroEvent.mixin(Doc); exports.Doc = Doc; return exports; })() export default window.sharejs