@difizen/libro-shared-model 0.0.2-alpha.0

package/es/ymodels.js

@@ -0,0 +1,1778 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { deepCopy, deepEqual } from '@difizen/libro-common';
+import { Emitter } from '@difizen/mana-common';
+import { v4 } from 'uuid';
+import { Awareness } from 'y-protocols/awareness';
+import * as Y from 'yjs';
+
+/**
+ * Abstract interface to define Shared Models that can be bound to a text editor using any existing
+ * Yjs-based editor binding.
+ */
+
+/**
+ * Generic shareable document.
+ */
+export var YDocument = /*#__PURE__*/function () {
+  function YDocument() {
+    var _this = this;
+    _classCallCheck(this, YDocument);
+    /**
+     * YJS document
+     */
+    this.ydoc = new Y.Doc();
+    /**
+     * Shared state
+     */
+    this.ystate = this.ydoc.getMap('state');
+    /**
+     * YJS document undo manager
+     */
+    this.undoManager = new Y.UndoManager([], {
+      trackedOrigins: new Set([this]),
+      doc: this.ydoc
+    });
+    /**
+     * Shared awareness
+     */
+    this.awareness = new Awareness(this.ydoc);
+    /**
+     * Handle a change to the ystate.
+     */
+    this.onStateChanged = function (event) {
+      var stateChange = new Array();
+      event.keysChanged.forEach(function (key) {
+        var change = event.changes.keys.get(key);
+        if (change) {
+          stateChange.push({
+            name: key,
+            oldValue: change.oldValue,
+            newValue: _this.ystate.get(key)
+          });
+        }
+      });
+      _this._changedEmitter.fire({
+        stateChange: stateChange
+      });
+    };
+    this._changedEmitter = new Emitter();
+    this._changed = this._changedEmitter.event;
+    this._isDisposed = false;
+    this.ystate.observe(this.onStateChanged);
+  }
+  _createClass(YDocument, [{
+    key: "changed",
+    get:
+    /**
+     * The changed signal.
+     */
+    function get() {
+      return this._changed;
+    }
+
+    /**
+     * Whether the document is disposed or not.
+     */
+  }, {
+    key: "isDisposed",
+    get: function get() {
+      return this._isDisposed;
+    }
+
+    /**
+     * Whether the object can undo changes.
+     */
+  }, {
+    key: "canUndo",
+    value: function canUndo() {
+      return this.undoManager.undoStack.length > 0;
+    }
+
+    /**
+     * Whether the object can redo changes.
+     */
+  }, {
+    key: "canRedo",
+    value: function canRedo() {
+      return this.undoManager.redoStack.length > 0;
+    }
+
+    /**
+     * Dispose of the resources.
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this._isDisposed) {
+        return;
+      }
+      this._isDisposed = true;
+      this.ystate.unobserve(this.onStateChanged);
+      this.awareness.destroy();
+      this.undoManager.destroy();
+      this.ydoc.destroy();
+    }
+
+    /**
+     * Undo an operation.
+     */
+  }, {
+    key: "undo",
+    value: function undo() {
+      this.undoManager.undo();
+    }
+
+    /**
+     * Redo an operation.
+     */
+  }, {
+    key: "redo",
+    value: function redo() {
+      this.undoManager.redo();
+    }
+
+    /**
+     * Clear the change stack.
+     */
+  }, {
+    key: "clearUndoHistory",
+    value: function clearUndoHistory() {
+      this.undoManager.clear();
+    }
+
+    /**
+     * Perform a transaction. While the function f is called, all changes to the shared
+     * document are bundled into a single event.
+     */
+  }, {
+    key: "transact",
+    value: function transact(f) {
+      var undoable = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      this.ydoc.transact(f, undoable ? this : null);
+    }
+  }]);
+  return YDocument;
+}();
+
+/**
+ * Shareable text file.
+ */
+export var YFile = /*#__PURE__*/function (_ref) {
+  _inherits(YFile, _ref);
+  var _super = _createSuper(YFile);
+  function YFile() {
+    var _this2;
+    _classCallCheck(this, YFile);
+    _this2 = _super.call(this);
+    /**
+     * YJS file text.
+     */
+    _this2.ysource = _this2.ydoc.getText('source');
+    /**
+     * Handle a change to the ymodel.
+     */
+    _this2._modelObserver = function (event) {
+      _this2._changedEmitter.fire({
+        sourceChange: event.changes.delta
+      });
+    };
+    _this2.undoManager.addToScope(_this2.ysource);
+    _this2.ysource.observe(_this2._modelObserver);
+    return _this2;
+  }
+  _createClass(YFile, [{
+    key: "source",
+    get:
+    /**
+     * File text
+     */
+    function get() {
+      return this.getSource();
+    },
+    set: function set(v) {
+      this.setSource(v);
+    }
+
+    /**
+     * Dispose of the resources.
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this.isDisposed) {
+        return;
+      }
+      this.ysource.unobserve(this._modelObserver);
+      _get(_getPrototypeOf(YFile.prototype), "dispose", this).call(this);
+    }
+
+    /**
+     * Get the file text.
+     *
+     * @returns File text.
+     */
+  }, {
+    key: "getSource",
+    value: function getSource() {
+      return this.ysource.toString();
+    }
+
+    /**
+     * Set the file text.
+     *
+     * @param value New text
+     */
+  }, {
+    key: "setSource",
+    value: function setSource(value) {
+      var _this3 = this;
+      this.transact(function () {
+        var ytext = _this3.ysource;
+        ytext.delete(0, ytext.length);
+        ytext.insert(0, value);
+      });
+    }
+
+    /**
+     * Replace content from `start' to `end` with `value`.
+     *
+     * @param start: The start index of the range to replace (inclusive).
+     * @param end: The end index of the range to replace (exclusive).
+     * @param value: New source (optional).
+     */
+  }, {
+    key: "updateSource",
+    value: function updateSource(start, end) {
+      var _this4 = this;
+      var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+      this.transact(function () {
+        var ysource = _this4.ysource;
+        // insert and then delete.
+        // This ensures that the cursor position is adjusted after the replaced content.
+        ysource.insert(start, value);
+        ysource.delete(start + value.length, end - start);
+      });
+    }
+  }], [{
+    key: "create",
+    value:
+    /**
+     * Instantiate a new shareable file.
+     *
+     * @param source The initial file content
+     *
+     * @returns The file model
+     */
+    function create(source) {
+      var model = new YFile();
+      if (source) {
+        model.source = source;
+      }
+      return model;
+    }
+  }]);
+  return YFile;
+}(YDocument);
+export var defaultCellTypeAdaptor = function defaultCellTypeAdaptor(cell_Type) {
+  return cell_Type;
+};
+
+/**
+ * Create a new shared cell model given the YJS shared type.
+ */
+var createCellModelFromSharedType = function createCellModelFromSharedType(type) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var cellTypeAdaptor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultCellTypeAdaptor;
+  switch (cellTypeAdaptor(type.get('cell_type'))) {
+    case 'code':
+      return new YCodeCell(type, type.get('source'), type.get('outputs'), options);
+    case 'markdown':
+      return new YMarkdownCell(type, type.get('source'), options);
+    case 'raw':
+      return new YRawCell(type, type.get('source'), options);
+    default:
+      throw new Error('Found unknown cell type');
+  }
+};
+
+/**
+ * Create a new cell that can be inserted in an existing shared model.
+ *
+ * If no notebook is specified the cell will be standalone.
+ *
+ * @param cell Cell JSON representation
+ * @param notebook Notebook to which the cell will be added
+ */
+var createCell = function createCell(cell, notebook) {
+  var _cell$id;
+  var cellTypeAdaptor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultCellTypeAdaptor;
+  var ymodel = new Y.Map();
+  var ysource = new Y.Text();
+  ymodel.set('source', ysource);
+  ymodel.set('metadata', {});
+  ymodel.set('cell_type', cell.cell_type);
+  ymodel.set('id', (_cell$id = cell.id) !== null && _cell$id !== void 0 ? _cell$id : v4());
+  var ycell;
+  switch (cellTypeAdaptor(cell.cell_type)) {
+    case 'markdown':
+      {
+        ycell = new YMarkdownCell(ymodel, ysource, {
+          notebook: notebook
+        });
+        if (cell.attachments !== null) {
+          ycell.setAttachments(cell.attachments);
+        }
+        break;
+      }
+    case 'code':
+      {
+        var _cCell$execution_coun;
+        var youtputs = new Y.Array();
+        ymodel.set('outputs', youtputs);
+        ycell = new YCodeCell(ymodel, ysource, youtputs, {
+          notebook: notebook
+        });
+        var cCell = cell;
+        ycell.execution_count = (_cCell$execution_coun = cCell.execution_count) !== null && _cCell$execution_coun !== void 0 ? _cCell$execution_coun : null;
+        if (cCell.outputs) {
+          ycell.setOutputs(cCell.outputs);
+        }
+        break;
+      }
+    default:
+      {
+        // raw
+        ycell = new YRawCell(ymodel, ysource, {
+          notebook: notebook
+        });
+        if (cell.attachments) {
+          ycell.setAttachments(cell.attachments);
+        }
+        break;
+      }
+  }
+  if (cell.metadata !== null) {
+    ycell.setMetadata(cell.metadata);
+  }
+  if (cell.source !== null) {
+    ycell.setSource(typeof cell.source === 'string' ? cell.source : cell.source.join('\n'));
+  }
+  return ycell;
+};
+
+/**
+ * Create a new cell that cannot be inserted in an existing shared model.
+ *
+ * @param cell Cell JSON representation
+ */
+export var createStandaloneCell = function createStandaloneCell(cell, cellTypeAdaptor) {
+  return createCell(cell, undefined, cellTypeAdaptor);
+};
+export var YBaseCell = /*#__PURE__*/function () {
+  /**
+   * Base cell constructor
+   *
+   * ### Notes
+   * Don't use the constructor directly - prefer using ``YNotebook.insertCell``
+   *
+   * The ``ysource`` is needed because ``ymodel.get('source')`` will
+   * not return the real source if the model is not yet attached to
+   * a document. Requesting it explicitly allows to introspect a non-empty
+   * source before the cell is attached to the document.
+   *
+   * @param ymodel Cell map
+   * @param ysource Cell source
+   * @param options { notebook?: The notebook the cell is attached to }
+   */
+  function YBaseCell(ymodel, ysource) {
+    var _this5 = this;
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    _classCallCheck(this, YBaseCell);
+    /**
+     * Handle a change to the ymodel.
+     */
+    this._modelObserver = function (events) {
+      _this5._changedEmitter.fire(_this5.getChanges(events));
+    };
+    this._metadataChangedEmitter = new Emitter();
+    this._metadataChanged = this._metadataChangedEmitter.event;
+    /**
+     * The notebook that this cell belongs to.
+     */
+    this._notebook = null;
+    this._changedEmitter = new Emitter();
+    this._changed = this._changedEmitter.event;
+    this._isDisposed = false;
+    this._undoManager = null;
+    this.ymodel = ymodel;
+    this._ysource = ysource;
+    this._prevSourceLength = ysource ? ysource.length : 0;
+    this._notebook = null;
+    this._awareness = null;
+    this._undoManager = null;
+    if (options.notebook) {
+      this._notebook = options.notebook;
+      // We cannot create a undo manager with the cell not yet attached in the notebook
+      // so we defer that to the notebook insertCell method
+    } else {
+      // Standalone cell
+      var doc = new Y.Doc();
+      doc.getArray().insert(0, [this.ymodel]);
+      this._awareness = new Awareness(doc);
+      this._undoManager = new Y.UndoManager([this.ymodel], {
+        trackedOrigins: new Set([this])
+      });
+    }
+    this.ymodel.observeDeep(this._modelObserver);
+  }
+
+  /**
+   * Cell notebook awareness or null if the cell is standalone.
+   */
+  _createClass(YBaseCell, [{
+    key: "awareness",
+    get: function get() {
+      var _ref2, _this$_awareness, _this$notebook;
+      return (_ref2 = (_this$_awareness = this._awareness) !== null && _this$_awareness !== void 0 ? _this$_awareness : (_this$notebook = this.notebook) === null || _this$notebook === void 0 ? void 0 : _this$notebook.awareness) !== null && _ref2 !== void 0 ? _ref2 : null;
+    }
+
+    /**
+     * The type of the cell.
+     */
+  }, {
+    key: "cell_type",
+    get: function get() {
+      throw new Error('A YBaseCell must not be constructed');
+    }
+
+    /**
+     * The changed signal.
+     */
+  }, {
+    key: "changed",
+    get: function get() {
+      return this._changed;
+    }
+
+    /**
+     * Cell id
+     */
+  }, {
+    key: "id",
+    get: function get() {
+      return this.getId();
+    }
+
+    /**
+     * Whether the model has been disposed or not.
+     */
+  }, {
+    key: "isDisposed",
+    get: function get() {
+      return this._isDisposed;
+    }
+
+    /**
+     * Whether the cell is standalone or not.
+     *
+     * If the cell is standalone. It cannot be
+     * inserted into a YNotebook because the Yjs model is already
+     * attached to an anonymous Y.Doc instance.
+     */
+  }, {
+    key: "isStandalone",
+    get: function get() {
+      return this._notebook !== null;
+    }
+
+    /**
+     * Cell metadata.
+     */
+  }, {
+    key: "metadata",
+    get: function get() {
+      return this.getMetadata();
+    },
+    set: function set(v) {
+      this.setMetadata(v);
+    }
+
+    /**
+     * Signal triggered when the cell metadata changes.
+     */
+  }, {
+    key: "metadataChanged",
+    get: function get() {
+      return this._metadataChanged;
+    }
+
+    /**
+     * The notebook that this cell belongs to.
+     */
+  }, {
+    key: "notebook",
+    get: function get() {
+      return this._notebook;
+    }
+
+    /**
+     * Cell input content.
+     */
+  }, {
+    key: "source",
+    get: function get() {
+      return this.getSource();
+    },
+    set: function set(v) {
+      this.setSource(v);
+    }
+
+    /**
+     * The cell undo manager.
+     */
+  }, {
+    key: "undoManager",
+    get: function get() {
+      var _this$notebook2;
+      if (!this.notebook) {
+        return this._undoManager;
+      }
+      return (_this$notebook2 = this.notebook) !== null && _this$notebook2 !== void 0 && _this$notebook2.disableDocumentWideUndoRedo ? this._undoManager : this.notebook.undoManager;
+    }
+
+    /**
+     * Defer setting the undo manager as it requires the
+     * cell to be attached to the notebook Y document.
+     */
+  }, {
+    key: "setUndoManager",
+    value: function setUndoManager() {
+      if (this._undoManager) {
+        throw new Error('The cell undo manager is already set.');
+      }
+      if (this._notebook && this._notebook.disableDocumentWideUndoRedo) {
+        this._undoManager = new Y.UndoManager([this.ymodel], {
+          trackedOrigins: new Set([this])
+        });
+      }
+    }
+  }, {
+    key: "ysource",
+    get: function get() {
+      return this._ysource;
+    }
+
+    /**
+     * Whether the object can undo changes.
+     */
+  }, {
+    key: "canUndo",
+    value: function canUndo() {
+      return !!this.undoManager && this.undoManager.undoStack.length > 0;
+    }
+
+    /**
+     * Whether the object can redo changes.
+     */
+  }, {
+    key: "canRedo",
+    value: function canRedo() {
+      return !!this.undoManager && this.undoManager.redoStack.length > 0;
+    }
+
+    /**
+     * Clear the change stack.
+     */
+  }, {
+    key: "clearUndoHistory",
+    value: function clearUndoHistory() {
+      var _this$undoManager;
+      (_this$undoManager = this.undoManager) === null || _this$undoManager === void 0 ? void 0 : _this$undoManager.clear();
+    }
+
+    /**
+     * Undo an operation.
+     */
+  }, {
+    key: "undo",
+    value: function undo() {
+      var _this$undoManager2;
+      (_this$undoManager2 = this.undoManager) === null || _this$undoManager2 === void 0 ? void 0 : _this$undoManager2.undo();
+    }
+
+    /**
+     * Redo an operation.
+     */
+  }, {
+    key: "redo",
+    value: function redo() {
+      var _this$undoManager3;
+      (_this$undoManager3 = this.undoManager) === null || _this$undoManager3 === void 0 ? void 0 : _this$undoManager3.redo();
+    }
+
+    /**
+     * Dispose of the resources.
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this._isDisposed) {
+        return;
+      }
+      this._isDisposed = true;
+      this.ymodel.unobserveDeep(this._modelObserver);
+      if (this._awareness) {
+        // A new document is created for standalone cell.
+        var doc = this._awareness.doc;
+        this._awareness.destroy();
+        doc.destroy();
+      }
+      if (this._undoManager) {
+        var _this$notebook3;
+        // Be sure to not destroy the document undo manager.
+        if (this._undoManager === ((_this$notebook3 = this.notebook) === null || _this$notebook3 === void 0 ? void 0 : _this$notebook3.undoManager)) {
+          this._undoManager = null;
+        } else {
+          this._undoManager.destroy();
+        }
+      }
+    }
+
+    /**
+     * Get cell id.
+     *
+     * @returns Cell id
+     */
+  }, {
+    key: "getId",
+    value: function getId() {
+      return this.ymodel.get('id');
+    }
+
+    /**
+     * Gets cell's source.
+     *
+     * @returns Cell's source.
+     */
+  }, {
+    key: "getSource",
+    value: function getSource() {
+      return this.ysource.toString();
+    }
+
+    /**
+     * Sets cell's source.
+     *
+     * @param value: New source.
+     */
+  }, {
+    key: "setSource",
+    value: function setSource(value) {
+      var _this6 = this;
+      this.transact(function () {
+        _this6.ysource.delete(0, _this6.ysource.length);
+        _this6.ysource.insert(0, value);
+      });
+      // @todo Do we need proper replace semantic? This leads to issues in editor bindings because they don't switch source.
+      // this.ymodel.set('source', new Y.Text(value));
+    }
+
+    /**
+     * Replace content from `start' to `end` with `value`.
+     *
+     * @param start: The start index of the range to replace (inclusive).
+     *
+     * @param end: The end index of the range to replace (exclusive).
+     *
+     * @param value: New source (optional).
+     */
+  }, {
+    key: "updateSource",
+    value: function updateSource(start, end) {
+      var _this7 = this;
+      var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+      this.transact(function () {
+        var ysource = _this7.ysource;
+        // insert and then delete.
+        // This ensures that the cursor position is adjusted after the replaced content.
+        ysource.insert(start, value);
+        ysource.delete(start + value.length, end - start);
+      });
+    }
+
+    /**
+     * Delete a metadata cell.
+     *
+     * @param key The key to delete
+     */
+  }, {
+    key: "deleteMetadata",
+    value: function deleteMetadata(key) {
+      var allMetadata = deepCopy(this.ymodel.get('metadata'));
+      delete allMetadata[key];
+      this.setMetadata(allMetadata);
+    }
+
+    /**
+     * Returns the metadata associated with the cell.
+     *
+     * @param key
+     * @returns Cell metadata.
+     */
+  }, {
+    key: "getMetadata",
+    value: function getMetadata(key) {
+      var metadata = this.ymodel.get('metadata');
+      if (typeof key === 'string') {
+        return deepCopy(metadata[key]);
+      } else {
+        return deepCopy(metadata);
+      }
+    }
+
+    /**
+     * Sets some cell metadata.
+     *
+     * If only one argument is provided, it will override all cell metadata.
+     * Otherwise a single key will be set to a new value.
+     *
+     * @param metadata Cell's metadata or key.
+     * @param value Metadata value
+     */
+  }, {
+    key: "setMetadata",
+    value: function setMetadata(metadata, value) {
+      var _clone$jupyter,
+        _this8 = this;
+      if (typeof metadata === 'string') {
+        if (typeof value === 'undefined') {
+          throw new TypeError("Metadata value for ".concat(metadata, " cannot be 'undefined'; use deleteMetadata."));
+        }
+        var key = metadata;
+        // eslint-disable-next-line no-param-reassign
+        metadata = this.getMetadata();
+        // @ts-expect-error metadata type is changed at runtime.
+        metadata[key] = value;
+      }
+      var clone = deepCopy(metadata);
+      if (clone.collapsed !== null) {
+        clone.jupyter = clone.jupyter || {};
+        clone.jupyter.outputs_hidden = clone.collapsed;
+      } else if ((clone === null || clone === void 0 ? void 0 : (_clone$jupyter = clone.jupyter) === null || _clone$jupyter === void 0 ? void 0 : _clone$jupyter.outputs_hidden) !== null) {
+        clone.collapsed = clone.jupyter.outputs_hidden;
+      }
+      if (this.ymodel.doc === null || !deepEqual(clone, this.getMetadata())) {
+        this.transact(function () {
+          _this8.ymodel.set('metadata', clone);
+        });
+      }
+    }
+
+    /**
+     * Serialize the model to JSON.
+     */
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        id: this.getId(),
+        cell_type: this.cell_type,
+        source: this.getSource(),
+        metadata: this.getMetadata()
+      };
+    }
+
+    /**
+     * Perform a transaction. While the function f is called, all changes to the shared
+     * document are bundled into a single event.
+     */
+  }, {
+    key: "transact",
+    value: function transact(f) {
+      var undoable = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      this.notebook && undoable ? this.notebook.transact(f) : this.ymodel.doc === null ? f() : this.ymodel.doc.transact(f, this);
+    }
+
+    /**
+     * Extract changes from YJS events
+     *
+     * @param events YJS events
+     * @returns Cell changes
+     */
+  }, {
+    key: "getChanges",
+    value: function getChanges(events) {
+      var _this9 = this;
+      var changes = {};
+      var sourceEvent = events.find(function (event) {
+        return event.target === _this9.ymodel.get('source');
+      });
+      if (sourceEvent) {
+        changes.sourceChange = sourceEvent.changes.delta;
+      }
+      var modelEvent = events.find(function (event) {
+        return event.target === _this9.ymodel;
+      });
+      if (modelEvent && modelEvent.keysChanged.has('metadata')) {
+        var _metadataChange$oldVa;
+        var change = modelEvent.changes.keys.get('metadata');
+        var metadataChange = changes.metadataChange = {
+          oldValue: change !== null && change !== void 0 && change.oldValue ? change.oldValue : undefined,
+          newValue: this.getMetadata()
+        };
+        var oldValue = (_metadataChange$oldVa = metadataChange.oldValue) !== null && _metadataChange$oldVa !== void 0 ? _metadataChange$oldVa : {};
+        var oldKeys = Object.keys(oldValue);
+        var newKeys = Object.keys(metadataChange.newValue);
+        var _iterator = _createForOfIteratorHelper(new Set(oldKeys.concat(newKeys))),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var key = _step.value;
+            if (!oldKeys.includes(key)) {
+              this._metadataChangedEmitter.fire({
+                key: key,
+                newValue: metadataChange.newValue[key],
+                type: 'add'
+              });
+            } else if (!newKeys.includes(key)) {
+              this._metadataChangedEmitter.fire({
+                key: key,
+                oldValue: metadataChange.oldValue[key],
+                type: 'remove'
+              });
+            } else if (!deepEqual(oldValue[key], metadataChange.newValue[key])) {
+              this._metadataChangedEmitter.fire({
+                key: key,
+                newValue: metadataChange.newValue[key],
+                oldValue: metadataChange.oldValue[key],
+                type: 'change'
+              });
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+
+      // The model allows us to replace the complete source with a new string. We express this in the Delta format
+      // as a replace of the complete string.
+      var ysource = this.ymodel.get('source');
+      if (modelEvent && modelEvent.keysChanged.has('source')) {
+        changes.sourceChange = [{
+          delete: this._prevSourceLength
+        }, {
+          insert: ysource.toString()
+        }];
+      }
+      this._prevSourceLength = ysource.length;
+      return changes;
+    }
+  }], [{
+    key: "createStandalone",
+    value:
+    /**
+     * Create a new YCell that works standalone. It cannot be
+     * inserted into a YNotebook because the Yjs model is already
+     * attached to an anonymous Y.Doc instance.
+     */
+    function createStandalone(id) {
+      var cell = createCell({
+        id: id,
+        cell_type: this.prototype.cell_type,
+        source: '',
+        metadata: {}
+      });
+      return cell;
+    }
+  }]);
+  return YBaseCell;
+}();
+
+/**
+ * Shareable code cell.
+ */
+export var YCodeCell = /*#__PURE__*/function (_YBaseCell) {
+  _inherits(YCodeCell, _YBaseCell);
+  var _super2 = _createSuper(YCodeCell);
+  /**
+   * Code cell constructor
+   *
+   * ### Notes
+   * Don't use the constructor directly - prefer using ``YNotebook.insertCell``
+   *
+   * The ``ysource`` is needed because ``ymodel.get('source')`` will
+   * not return the real source if the model is not yet attached to
+   * a document. Requesting it explicitly allows to introspect a non-empty
+   * source before the cell is attached to the document.
+   *
+   * @param ymodel Cell map
+   * @param ysource Cell source
+   * @param youtputs Code cell outputs
+   * @param options { notebook?: The notebook the cell is attached to }
+   */
+  function YCodeCell(ymodel, ysource, youtputs) {
+    var _this10;
+    var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    _classCallCheck(this, YCodeCell);
+    _this10 = _super2.call(this, ymodel, ysource, options);
+    _this10._youtputs = youtputs;
+    return _this10;
+  }
+
+  /**
+   * The type of the cell.
+   */
+  _createClass(YCodeCell, [{
+    key: "cell_type",
+    get: function get() {
+      return this.ymodel.get('cell_type');
+    }
+
+    /**
+     * The code cell's prompt number. Will be null if the cell has not been run.
+     */
+  }, {
+    key: "execution_count",
+    get: function get() {
+      return this.ymodel.get('execution_count') || null;
+    },
+    set: function set(count) {
+      var _this11 = this;
+      // Do not use `this.execution_count`. When initializing the
+      // cell, we need to set execution_count to `null` if we compare
+      // using `this.execution_count` it will return `null` and we will
+      // never initialize it
+      if (this.ymodel.get('execution_count') !== count) {
+        this.transact(function () {
+          _this11.ymodel.set('execution_count', count);
+        });
+      }
+    }
+
+    /**
+     * Cell outputs.
+     */
+  }, {
+    key: "outputs",
+    get: function get() {
+      return this.getOutputs();
+    },
+    set: function set(v) {
+      this.setOutputs(v);
+    }
+
+    /**
+     * Execution, display, or stream outputs.
+     */
+  }, {
+    key: "getOutputs",
+    value: function getOutputs() {
+      return deepCopy(this._youtputs.toArray());
+    }
+
+    /**
+     * Replace all outputs.
+     */
+  }, {
+    key: "setOutputs",
+    value: function setOutputs(outputs) {
+      var _this12 = this;
+      this.transact(function () {
+        _this12._youtputs.delete(0, _this12._youtputs.length);
+        _this12._youtputs.insert(0, outputs);
+      }, false);
+    }
+
+    /**
+     * Replace content from `start' to `end` with `outputs`.
+     *
+     * @param start: The start index of the range to replace (inclusive).
+     *
+     * @param end: The end index of the range to replace (exclusive).
+     *
+     * @param outputs: New outputs (optional).
+     */
+  }, {
+    key: "updateOutputs",
+    value: function updateOutputs(start, end) {
+      var _this13 = this;
+      var outputs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      var fin = end < this._youtputs.length ? end - start : this._youtputs.length - start;
+      this.transact(function () {
+        _this13._youtputs.delete(start, fin);
+        _this13._youtputs.insert(start, outputs);
+      }, false);
+    }
+
+    /**
+     * Serialize the model to JSON.
+     */
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return _objectSpread(_objectSpread({}, _get(_getPrototypeOf(YCodeCell.prototype), "toJSON", this).call(this)), {}, {
+        outputs: this.getOutputs(),
+        execution_count: this.execution_count
+      });
+    }
+
+    /**
+     * Extract changes from YJS events
+     *
+     * @param events YJS events
+     * @returns Cell changes
+     */
+  }, {
+    key: "getChanges",
+    value: function getChanges(events) {
+      var _this14 = this;
+      var changes = _get(_getPrototypeOf(YCodeCell.prototype), "getChanges", this).call(this, events);
+      var outputEvent = events.find(function (event) {
+        return event.target === _this14.ymodel.get('outputs');
+      });
+      if (outputEvent) {
+        changes.outputsChange = outputEvent.changes.delta;
+      }
+      var modelEvent = events.find(function (event) {
+        return event.target === _this14.ymodel;
+      });
+      if (modelEvent && modelEvent.keysChanged.has('execution_count')) {
+        var change = modelEvent.changes.keys.get('execution_count');
+        changes.executionCountChange = {
+          oldValue: change.oldValue,
+          newValue: this.ymodel.get('execution_count')
+        };
+      }
+      return changes;
+    }
+  }], [{
+    key: "createStandalone",
+    value:
+    /**
+     * Create a new YCodeCell that works standalone. It cannot be
+     * inserted into a YNotebook because the Yjs model is already
+     * attached to an anonymous Y.Doc instance.
+     */
+    function createStandalone(id) {
+      return _get(_getPrototypeOf(YCodeCell), "createStandalone", this).call(this, id);
+    }
+  }]);
+  return YCodeCell;
+}(YBaseCell);
+var YAttachmentCell = /*#__PURE__*/function (_ref3) {
+  _inherits(YAttachmentCell, _ref3);
+  var _super3 = _createSuper(YAttachmentCell);
+  function YAttachmentCell() {
+    _classCallCheck(this, YAttachmentCell);
+    return _super3.apply(this, arguments);
+  }
+  _createClass(YAttachmentCell, [{
+    key: "attachments",
+    get:
+    /**
+     * Cell attachments
+     */
+    function get() {
+      return this.getAttachments();
+    },
+    set: function set(v) {
+      this.setAttachments(v);
+    }
+
+    /**
+     * Gets the cell attachments.
+     *
+     * @returns The cell attachments.
+     */
+  }, {
+    key: "getAttachments",
+    value: function getAttachments() {
+      return this.ymodel.get('attachments');
+    }
+
+    /**
+     * Sets the cell attachments
+     *
+     * @param attachments: The cell attachments.
+     */
+  }, {
+    key: "setAttachments",
+    value: function setAttachments(attachments) {
+      var _this15 = this;
+      this.transact(function () {
+        if (attachments === null) {
+          _this15.ymodel.delete('attachments');
+        } else {
+          _this15.ymodel.set('attachments', attachments);
+        }
+      });
+    }
+
+    /**
+     * Extract changes from YJS events
+     *
+     * @param events YJS events
+     * @returns Cell changes
+     */
+  }, {
+    key: "getChanges",
+    value: function getChanges(events) {
+      var _this16 = this;
+      var changes = _get(_getPrototypeOf(YAttachmentCell.prototype), "getChanges", this).call(this, events);
+      var modelEvent = events.find(function (event) {
+        return event.target === _this16.ymodel;
+      });
+      if (modelEvent && modelEvent.keysChanged.has('attachments')) {
+        var change = modelEvent.changes.keys.get('attachments');
+        changes.executionCountChange = {
+          oldValue: change.oldValue,
+          newValue: this.ymodel.get('attachments')
+        };
+      }
+      return changes;
+    }
+  }]);
+  return YAttachmentCell;
+}(YBaseCell);
+/**
+ * Shareable raw cell.
+ */
+export var YRawCell = /*#__PURE__*/function (_YAttachmentCell) {
+  _inherits(YRawCell, _YAttachmentCell);
+  var _super4 = _createSuper(YRawCell);
+  function YRawCell() {
+    _classCallCheck(this, YRawCell);
+    return _super4.apply(this, arguments);
+  }
+  _createClass(YRawCell, [{
+    key: "cell_type",
+    get:
+    /**
+     * String identifying the type of cell.
+     */
+    function get() {
+      return 'raw';
+    }
+
+    /**
+     * Serialize the model to JSON.
+     */
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        id: this.getId(),
+        cell_type: 'raw',
+        source: this.getSource(),
+        metadata: this.getMetadata(),
+        attachments: this.getAttachments()
+      };
+    }
+  }], [{
+    key: "createStandalone",
+    value:
+    /**
+     * Create a new YRawCell that works standalone. It cannot be
+     * inserted into a YNotebook because the Yjs model is already
+     * attached to an anonymous Y.Doc instance.
+     */
+    function createStandalone(id) {
+      return _get(_getPrototypeOf(YRawCell), "createStandalone", this).call(this, id);
+    }
+  }]);
+  return YRawCell;
+}(YAttachmentCell);
+
+/**
+ * Shareable markdown cell.
+ */
+export var YMarkdownCell = /*#__PURE__*/function (_YAttachmentCell2) {
+  _inherits(YMarkdownCell, _YAttachmentCell2);
+  var _super5 = _createSuper(YMarkdownCell);
+  function YMarkdownCell() {
+    _classCallCheck(this, YMarkdownCell);
+    return _super5.apply(this, arguments);
+  }
+  _createClass(YMarkdownCell, [{
+    key: "cell_type",
+    get:
+    /**
+     * String identifying the type of cell.
+     */
+    function get() {
+      return 'markdown';
+    }
+
+    /**
+     * Serialize the model to JSON.
+     */
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        id: this.getId(),
+        cell_type: 'markdown',
+        source: this.getSource(),
+        metadata: this.getMetadata(),
+        attachments: this.getAttachments()
+      };
+    }
+  }], [{
+    key: "createStandalone",
+    value:
+    /**
+     * Create a new YMarkdownCell that works standalone. It cannot be
+     * inserted into a YNotebook because the Yjs model is already
+     * attached to an anonymous Y.Doc instance.
+     */
+    function createStandalone(id) {
+      return _get(_getPrototypeOf(YMarkdownCell), "createStandalone", this).call(this, id);
+    }
+  }]);
+  return YMarkdownCell;
+}(YAttachmentCell);
+
+/**
+ * Cell type.
+ */
+
+/**
+ * Shared implementation of the Shared Document types.
+ *
+ * Shared cells can be inserted into a SharedNotebook.
+ * Shared cells only start emitting events when they are connected to a SharedNotebook.
+ *
+ * "Standalone" cells must not be inserted into a (Shared)Notebook.
+ * Standalone cells emit events immediately after they have been created, but they must not
+ * be included into a (Shared)Notebook.
+ */
+export var YNotebook = /*#__PURE__*/function (_YDocument) {
+  _inherits(YNotebook, _YDocument);
+  var _super6 = _createSuper(YNotebook);
+  function YNotebook() {
+    var _options$disableDocum, _options$cellTypeAdap;
+    var _this17;
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, YNotebook);
+    _this17 = _super6.call(this);
+    _this17._undoChangedEmitter = new Emitter();
+    _this17._redoChangedEmitter = new Emitter();
+    _this17._canRedo = false;
+    _this17._canUndo = false;
+    _this17.handleUndoChanged = function () {
+      var canRedo = _this17.undoManager.canRedo();
+      if (_this17._canRedo !== canRedo) {
+        _this17._canRedo = canRedo;
+        _this17._redoChangedEmitter.fire(canRedo);
+      }
+      var canUndo = _this17.undoManager.canUndo();
+      if (_this17._canUndo !== canUndo) {
+        _this17._canUndo = canUndo;
+        _this17._undoChangedEmitter.fire(canUndo);
+      }
+    };
+    _this17.cellTypeAdaptor = defaultCellTypeAdaptor;
+    /**
+     * YJS map for the notebook metadata
+     */
+    _this17.ymeta = _this17.ydoc.getMap('meta');
+    /**
+     * Handle a change to the ystate.
+     */
+    _this17._onMetaChanged = function (event) {
+      if (event.keysChanged.has('metadata')) {
+        var _metadataChange$oldVa2;
+        var change = event.changes.keys.get('metadata');
+        var metadataChange = {
+          oldValue: change !== null && change !== void 0 && change.oldValue ? change.oldValue : undefined,
+          newValue: _this17.getMetadata()
+        };
+        var oldValue = (_metadataChange$oldVa2 = metadataChange.oldValue) !== null && _metadataChange$oldVa2 !== void 0 ? _metadataChange$oldVa2 : {};
+        var oldKeys = Object.keys(oldValue);
+        var newKeys = Object.keys(metadataChange.newValue);
+        var _iterator2 = _createForOfIteratorHelper(new Set(oldKeys.concat(newKeys))),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var key = _step2.value;
+            if (!oldKeys.includes(key)) {
+              _this17._metadataChangedEmitter.fire({
+                key: key,
+                newValue: metadataChange.newValue[key],
+                type: 'add'
+              });
+            } else if (!newKeys.includes(key)) {
+              _this17._metadataChangedEmitter.fire({
+                key: key,
+                oldValue: metadataChange.oldValue[key],
+                type: 'remove'
+              });
+            } else if (!deepEqual(oldValue[key], metadataChange.newValue[key])) {
+              _this17._metadataChangedEmitter.fire({
+                key: key,
+                newValue: metadataChange.newValue[key],
+                oldValue: metadataChange.oldValue[key],
+                type: 'change'
+              });
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        _this17._changedEmitter.fire({
+          metadataChange: metadataChange
+        });
+      }
+      if (event.keysChanged.has('nbformat')) {
+        var _change = event.changes.keys.get('nbformat');
+        var nbformatChanged = {
+          key: 'nbformat',
+          oldValue: _change !== null && _change !== void 0 && _change.oldValue ? _change.oldValue : undefined,
+          newValue: _this17.nbformat
+        };
+        _this17._changedEmitter.fire({
+          nbformatChanged: nbformatChanged
+        });
+      }
+      if (event.keysChanged.has('nbformat_minor')) {
+        var _change2 = event.changes.keys.get('nbformat_minor');
+        var _nbformatChanged = {
+          key: 'nbformat_minor',
+          oldValue: _change2 !== null && _change2 !== void 0 && _change2.oldValue ? _change2.oldValue : undefined,
+          newValue: _this17.nbformat_minor
+        };
+        _this17._changedEmitter.fire({
+          nbformatChanged: _nbformatChanged
+        });
+      }
+    };
+    /**
+     * Handle a change to the list of cells.
+     */
+    _this17._onYCellsChanged = function (event) {
+      // update the type cell mapping by iterating through the added/removed types
+      event.changes.added.forEach(function (item) {
+        var type = item.content.type;
+        if (!_this17._ycellMapping.has(type)) {
+          var c = createCellModelFromSharedType(type, {
+            notebook: _assertThisInitialized(_this17)
+          }, _this17.cellTypeAdaptor);
+          c.setUndoManager();
+          _this17._ycellMapping.set(type, c);
+        }
+      });
+      event.changes.deleted.forEach(function (item) {
+        var type = item.content.type;
+        var model = _this17._ycellMapping.get(type);
+        if (model) {
+          model.dispose();
+          _this17._ycellMapping.delete(type);
+        }
+      });
+      var index = 0;
+
+      // this reflects the event.changes.delta, but replaces the content of delta.insert with ycells
+      var cellsChange = [];
+      event.changes.delta.forEach(function (d) {
+        if (d.insert !== null) {
+          var _this17$cells;
+          var insertedCells = d.insert.map(function (ycell) {
+            return _this17._ycellMapping.get(ycell);
+          });
+          cellsChange.push({
+            insert: insertedCells
+          });
+          (_this17$cells = _this17.cells).splice.apply(_this17$cells, [index, 0].concat(_toConsumableArray(insertedCells)));
+          _this17._cellsChangedEmitter.fire({
+            type: 'add',
+            newIndex: index,
+            newValues: insertedCells,
+            oldIndex: -2,
+            oldValues: []
+          });
+          index += d.insert.length;
+        } else if (d.delete !== null) {
+          cellsChange.push(d);
+          var oldValues = _this17.cells.splice(index, d.delete);
+          _this17._cellsChangedEmitter.fire({
+            type: 'remove',
+            newIndex: -1,
+            newValues: [],
+            oldIndex: index,
+            oldValues: oldValues
+          });
+        } else if (d.retain !== null) {
+          cellsChange.push(d);
+          index += d.retain;
+        }
+      });
+      _this17._changedEmitter.fire({
+        cellsChange: cellsChange
+      });
+    };
+    _this17._cellsChangedEmitter = new Emitter();
+    _this17._cellsChanged = _this17._cellsChangedEmitter.event;
+    _this17._metadataChangedEmitter = new Emitter();
+    _this17._metadataChanged = _this17._metadataChangedEmitter.event;
+    /**
+     * Internal Yjs cells list
+     */
+    _this17._ycells = _this17.ydoc.getArray('cells');
+    _this17._ycellMapping = new WeakMap();
+    _this17._disableDocumentWideUndoRedo = (_options$disableDocum = options.disableDocumentWideUndoRedo) !== null && _options$disableDocum !== void 0 ? _options$disableDocum : false;
+    _this17.cellTypeAdaptor = (_options$cellTypeAdap = options.cellTypeAdaptor) !== null && _options$cellTypeAdap !== void 0 ? _options$cellTypeAdap : defaultCellTypeAdaptor;
+    _this17.cells = _this17._ycells.toArray().map(function (ycell) {
+      if (!_this17._ycellMapping.has(ycell)) {
+        _this17._ycellMapping.set(ycell, createCellModelFromSharedType(ycell, {
+          notebook: _assertThisInitialized(_this17)
+        }, _this17.cellTypeAdaptor));
+      }
+      return _this17._ycellMapping.get(ycell);
+    });
+    _this17.undoManager.addToScope(_this17._ycells);
+    _this17._ycells.observe(_this17._onYCellsChanged);
+    _this17.ymeta.observe(_this17._onMetaChanged);
+    _this17.undoManager.on('stack-item-updated', _this17.handleUndoChanged);
+    _this17.undoManager.on('stack-item-added', _this17.handleUndoChanged);
+    _this17.undoManager.on('stack-item-popped', _this17.handleUndoChanged);
+    _this17.undoManager.on('stack-cleared', _this17.handleUndoChanged);
+    _this17._canRedo = _this17.undoManager.canRedo();
+    _this17._canUndo = _this17.undoManager.canUndo();
+    return _this17;
+  }
+  _createClass(YNotebook, [{
+    key: "undoChanged",
+    get:
+    /**
+     * Signal triggered when a undo stack changed.
+     */
+    function get() {
+      return this._undoChangedEmitter.event;
+    }
+  }, {
+    key: "redoChanged",
+    get:
+    /**
+     * Signal triggered when a undo stack changed.
+     */
+    function get() {
+      return this._redoChangedEmitter.event;
+    }
+
+    /**
+     * Create a new YNotebook.
+     */
+  }, {
+    key: "cellsChanged",
+    get:
+    /**
+     * Cells list
+     */
+
+    /**
+     * Signal triggered when the cells list changes.
+     */
+    function get() {
+      return this._cellsChanged;
+    }
+
+    /**
+     * Wether the undo/redo logic should be
+     * considered on the full document across all cells.
+     *
+     * Default: false
+     */
+  }, {
+    key: "disableDocumentWideUndoRedo",
+    get: function get() {
+      return this._disableDocumentWideUndoRedo;
+    }
+
+    /**
+     * Notebook metadata
+     */
+  }, {
+    key: "metadata",
+    get: function get() {
+      return this.getMetadata();
+    },
+    set: function set(v) {
+      this.setMetadata(v);
+    }
+
+    /**
+     * Signal triggered when a metadata changes.
+     */
+  }, {
+    key: "metadataChanged",
+    get: function get() {
+      return this._metadataChanged;
+    }
+
+    /**
+     * nbformat major version
+     */
+  }, {
+    key: "nbformat",
+    get: function get() {
+      return this.ymeta.get('nbformat');
+    },
+    set: function set(value) {
+      var _this18 = this;
+      this.transact(function () {
+        _this18.ymeta.set('nbformat', value);
+      }, false);
+    }
+
+    /**
+     * nbformat minor version
+     */
+  }, {
+    key: "nbformat_minor",
+    get: function get() {
+      return this.ymeta.get('nbformat_minor');
+    },
+    set: function set(value) {
+      var _this19 = this;
+      this.transact(function () {
+        _this19.ymeta.set('nbformat_minor', value);
+      }, false);
+    }
+
+    /**
+     * Dispose of the resources.
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this.isDisposed) {
+        return;
+      }
+      this._ycells.unobserve(this._onYCellsChanged);
+      this.ymeta.unobserve(this._onMetaChanged);
+      this.undoManager.off('stack-item-updated', this.handleUndoChanged);
+      this.undoManager.off('stack-item-added', this.handleUndoChanged);
+      this.undoManager.off('stack-item-popped', this.handleUndoChanged);
+      this.undoManager.off('stack-cleared', this.handleUndoChanged);
+      _get(_getPrototypeOf(YNotebook.prototype), "dispose", this).call(this);
+    }
+
+    /**
+     * Get a shared cell by index.
+     *
+     * @param index: Cell's position.
+     *
+     * @returns The requested shared cell.
+     */
+  }, {
+    key: "getCell",
+    value: function getCell(index) {
+      return this.cells[index];
+    }
+
+    /**
+     * Add a shared cell at the notebook bottom.
+     *
+     * @param cell Cell to add.
+     *
+     * @returns The added cell.
+     */
+  }, {
+    key: "addCell",
+    value: function addCell(cell) {
+      return this.insertCell(this._ycells.length, cell);
+    }
+
+    /**
+     * Insert a shared cell into a specific position.
+     *
+     * @param index: Cell's position.
+     * @param cell: Cell to insert.
+     *
+     * @returns The inserted cell.
+     */
+  }, {
+    key: "insertCell",
+    value: function insertCell(index, cell) {
+      return this.insertCells(index, [cell])[0];
+    }
+
+    /**
+     * Insert a list of shared cells into a specific position.
+     *
+     * @param index: Position to insert the cells.
+     * @param cells: Array of shared cells to insert.
+     *
+     * @returns The inserted cells.
+     */
+  }, {
+    key: "insertCells",
+    value: function insertCells(index, cells) {
+      var _this20 = this;
+      var yCells = cells.map(function (c) {
+        var cell = createCell(c, _this20);
+        _this20._ycellMapping.set(cell.ymodel, cell);
+        return cell;
+      });
+      this.transact(function () {
+        _this20._ycells.insert(index, yCells.map(function (cell) {
+          return cell.ymodel;
+        }));
+      });
+      yCells.forEach(function (c) {
+        c.setUndoManager();
+      });
+      return yCells;
+    }
+
+    /**
+     * Move a cell.
+     *
+     * @param fromIndex: Index of the cell to move.
+     * @param toIndex: New position of the cell.
+     */
+  }, {
+    key: "moveCell",
+    value: function moveCell(fromIndex, toIndex) {
+      var _this21 = this;
+      this.transact(function () {
+        // FIXME we need to use yjs move feature to preserve undo history
+        var clone = createCell(_this21.getCell(fromIndex).toJSON(), _this21);
+        _this21._ycells.delete(fromIndex, 1);
+        _this21._ycells.insert(toIndex, [clone.ymodel]);
+      });
+    }
+
+    /**
+     * Remove a cell.
+     *
+     * @param index: Index of the cell to remove.
+     */
+  }, {
+    key: "deleteCell",
+    value: function deleteCell(index) {
+      this.deleteCellRange(index, index + 1);
+    }
+
+    /**
+     * Remove a range of cells.
+     *
+     * @param from: The start index of the range to remove (inclusive).
+     * @param to: The end index of the range to remove (exclusive).
+     */
+  }, {
+    key: "deleteCellRange",
+    value: function deleteCellRange(from, to) {
+      var _this22 = this;
+      // Cells will be removed from the mapping in the model event listener.
+      this.transact(function () {
+        _this22._ycells.delete(from, to - from);
+      });
+    }
+
+    /**
+     * Delete a metadata notebook.
+     *
+     * @param key The key to delete
+     */
+  }, {
+    key: "deleteMetadata",
+    value: function deleteMetadata(key) {
+      var allMetadata = deepCopy(this.ymeta.get('metadata'));
+      delete allMetadata[key];
+      this.setMetadata(allMetadata);
+    }
+
+    /**
+     * Returns some metadata associated with the notebook.
+     *
+     * If no `key` is provided, it will return all metadata.
+     * Else it will return the value for that key.
+     *
+     * @param key Key to get from the metadata
+     * @returns Notebook's metadata.
+     */
+  }, {
+    key: "getMetadata",
+    value: function getMetadata(key) {
+      var meta = this.ymeta.get('metadata');
+      if (typeof key === 'string') {
+        return deepCopy(meta[key]);
+      } else {
+        return deepCopy(meta !== null && meta !== void 0 ? meta : {});
+      }
+    }
+
+    /**
+     * Sets some metadata associated with the notebook.
+     *
+     * If only one argument is provided, it will override all notebook metadata.
+     * Otherwise a single key will be set to a new value.
+     *
+     * @param metadata All Notebook's metadata or the key to set.
+     * @param value New metadata value
+     */
+  }, {
+    key: "setMetadata",
+    value: function setMetadata(metadata, value) {
+      if (typeof metadata === 'string') {
+        if (typeof value === 'undefined') {
+          throw new TypeError("Metadata value for ".concat(metadata, " cannot be 'undefined'; use deleteMetadata."));
+        }
+        var update = {};
+        update[metadata] = value;
+        this.updateMetadata(update);
+      } else {
+        this.ymeta.set('metadata', deepCopy(metadata));
+      }
+    }
+
+    /**
+     * Updates the metadata associated with the notebook.
+     *
+     * @param value: Metadata's attribute to update.
+     */
+  }, {
+    key: "updateMetadata",
+    value: function updateMetadata(value) {
+      // TODO: Maybe modify only attributes instead of replacing the whole metadata?
+      this.ymeta.set('metadata', _objectSpread(_objectSpread({}, this.getMetadata()), value));
+    }
+  }], [{
+    key: "create",
+    value: function create() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return new YNotebook(options);
+    }
+  }]);
+  return YNotebook;
+}(YDocument);