@pie-lib/editable-html-tip-tap 1.0.0

package/lib/plugins/html/index.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = HtmlPlugin;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _icons = _interopRequireDefault(require("./icons"));
+
+var _serialization = require("./../../serialization");
+
+var toggleToRichText = function toggleToRichText(value, onChange, dismiss) {
+  var plainText = value.document.text;
+  var slateValue = dismiss ? value : (0, _serialization.htmlToValue)(plainText);
+  var change = value.change().selectAll()["delete"]().insertFragment(slateValue.document);
+  onChange(change);
+};
+
+function HtmlPlugin(opts) {
+  var _ref = opts || {},
+      isHtmlMode = _ref.isHtmlMode,
+      isEditedInHtmlMode = _ref.isEditedInHtmlMode,
+      toggleHtmlMode = _ref.toggleHtmlMode,
+      handleAlertDialog = _ref.handleAlertDialog,
+      currentValue = _ref.currentValue;
+
+  var handleHtmlModeOn = function handleHtmlModeOn(value, onChange) {
+    var dialogProps = {
+      title: 'Warning',
+      text: 'Returning to rich text mode without saving will cause edits to be lost.',
+      onConfirmText: 'Dismiss changes',
+      onCloseText: 'Continue Editing',
+      onConfirm: function onConfirm() {
+        handleAlertDialog(false);
+        toggleToRichText(currentValue, onChange, true);
+        toggleHtmlMode();
+      },
+      onClose: function onClose() {
+        handleAlertDialog(false);
+      }
+    };
+    handleAlertDialog(true, dialogProps);
+  };
+
+  var handleHtmlModeOff = function handleHtmlModeOff(value, onChange) {
+    var change = value.change().selectAll()["delete"]().insertText((0, _serialization.valueToHtml)(value));
+    onChange(change);
+  };
+
+  return {
+    name: 'html',
+    toolbar: {
+      icon: /*#__PURE__*/_react["default"].createElement(_icons["default"], {
+        isHtmlMode: isHtmlMode
+      }),
+      ariaLabel: 'Html editor',
+      buttonStyles: {
+        margin: '0 20px 0 auto'
+      },
+      type: 'html',
+      onClick: function onClick(value, onChange) {
+        if (isHtmlMode) {
+          if (isEditedInHtmlMode) {
+            handleHtmlModeOn(value, onChange);
+          } else {
+            toggleToRichText(value, onChange);
+            toggleHtmlMode();
+          }
+        } else {
+          handleHtmlModeOff(value, onChange);
+          toggleHtmlMode();
+        }
+      }
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/plugins/image/__tests__/component.test.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _slate = require("slate");
+
+var _component = require("../component");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactTestRenderer = _interopRequireDefault(require("react-test-renderer"));
+
+it('renders correctly', function () {
+  var node = _slate.Block.fromJSON({
+    type: 'image',
+    data: _slate.Data.create({
+      width: 50,
+      height: 50
+    })
+  });
+
+  var editor = {
+    value: {},
+    change: jest.fn()
+  };
+  var onDelete = jest.fn();
+  var classes = {
+    active: 'active',
+    loading: 'loading',
+    pendingDelete: 'pendingDelete'
+  };
+
+  var tree = _reactTestRenderer["default"].create( /*#__PURE__*/_react["default"].createElement(_component.Component, {
+    node: node,
+    editor: editor,
+    classes: classes,
+    onDelete: onDelete
+  }), {
+    createNodeMock: function createNodeMock(el) {
+      if (el.type === 'img') {
+        return {
+          naturalWidth: 100,
+          naturalHeight: 100
+        };
+      }
+    }
+  }).toJSON();
+
+  expect(tree).toMatchSnapshot();
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/plugins/image/__tests__/image-toolbar-logic.test.js

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _slate = require("slate");
+
+var _imageToolbar = require("../image-toolbar");
+
+var _mockChange = _interopRequireDefault(require("./mock-change"));
+
+var _react = _interopRequireDefault(require("react"));
+
+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) { (0, _defineProperty2["default"])(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; }
+
+describe('ImageToolbar', function () {
+  var onChange;
+  beforeEach(function () {
+    onChange = jest.fn();
+  });
+
+  var mkWrapper = function mkWrapper(extras) {
+    var props = _objectSpread({
+      onChange: onChange,
+      classes: {}
+    }, extras);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_imageToolbar.ImageToolbar, props));
+  };
+
+  describe('onChange', function () {
+    it('renders', function () {
+      return expect(mkWrapper()).toMatchSnapshot();
+    });
+    it('calls onChange with alignment', function () {
+      var w = mkWrapper();
+      w.instance().onAlignmentClick('center');
+      expect(onChange).toHaveBeenCalledWith({
+        alignment: 'center'
+      });
+    });
+    it('calls onChange with alt text', function () {
+      var w = mkWrapper();
+      w.instance().onAltTextDone('alt text');
+      expect(onChange).toHaveBeenCalledWith({
+        alt: 'alt text'
+      }, true);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/plugins/image/__tests__/image-toolbar.test.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _imageToolbar = _interopRequireDefault(require("../image-toolbar"));
+
+var _reactTestRenderer = _interopRequireDefault(require("react-test-renderer"));
+
+var _slate = require("slate");
+
+it('renders correctly', function () {
+  var classes = {
+    holder: 'holder'
+  };
+
+  var tree = _reactTestRenderer["default"].create( /*#__PURE__*/_react["default"].createElement(_imageToolbar["default"], {
+    percent: 50,
+    classes: classes,
+    onChange: jest.fn()
+  })).toJSON();
+
+  expect(tree).toMatchSnapshot();
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wbHVnaW5zL2ltYWdlL19fdGVzdHNfXy9pbWFnZS10b29sYmFyLnRlc3QuanN4Il0sIm5hbWVzIjpbIml0IiwiY2xhc3NlcyIsImhvbGRlciIsInRyZWUiLCJyZW5kZXJlciIsImNyZWF0ZSIsImplc3QiLCJmbiIsInRvSlNPTiIsImV4cGVjdCIsInRvTWF0Y2hTbmFwc2hvdCJdLCJtYXBwaW5ncyI6Ijs7OztBQUFBOztBQUNBOztBQUNBOztBQUNBOztBQUVBQSxFQUFFLENBQUMsbUJBQUQsRUFBc0IsWUFBTTtBQUM1QixNQUFNQyxPQUFPLEdBQUc7QUFBRUMsSUFBQUEsTUFBTSxFQUFFO0FBQVYsR0FBaEI7O0FBRUEsTUFBTUMsSUFBSSxHQUFHQyw4QkFBU0MsTUFBVCxlQUFnQixnQ0FBQyx3QkFBRDtBQUFTLElBQUEsT0FBTyxFQUFFLEVBQWxCO0FBQXNCLElBQUEsT0FBTyxFQUFFSixPQUEvQjtBQUF3QyxJQUFBLFFBQVEsRUFBRUssSUFBSSxDQUFDQyxFQUFMO0FBQWxELElBQWhCLEVBQWlGQyxNQUFqRixFQUFiOztBQUNBQyxFQUFBQSxNQUFNLENBQUNOLElBQUQsQ0FBTixDQUFhTyxlQUFiO0FBQ0QsQ0FMQyxDQUFGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcbmltcG9ydCBUb29sYmFyIGZyb20gJy4uL2ltYWdlLXRvb2xiYXInO1xuaW1wb3J0IHJlbmRlcmVyIGZyb20gJ3JlYWN0LXRlc3QtcmVuZGVyZXInO1xuaW1wb3J0IHsgRGF0YSwgQmxvY2ssIFZhbHVlIH0gZnJvbSAnc2xhdGUnO1xuXG5pdCgncmVuZGVycyBjb3JyZWN0bHknLCAoKSA9PiB7XG4gIGNvbnN0IGNsYXNzZXMgPSB7IGhvbGRlcjogJ2hvbGRlcicgfTtcblxuICBjb25zdCB0cmVlID0gcmVuZGVyZXIuY3JlYXRlKDxUb29sYmFyIHBlcmNlbnQ9ezUwfSBjbGFzc2VzPXtjbGFzc2VzfSBvbkNoYW5nZT17amVzdC5mbigpfSAvPikudG9KU09OKCk7XG4gIGV4cGVjdCh0cmVlKS50b01hdGNoU25hcHNob3QoKTtcbn0pO1xuIl19

package/lib/plugins/image/__tests__/index.test.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+var _mockChange = _interopRequireWildcard(require("./mock-change"));
+
+var _slate = require("slate");
+
+var _ = _interopRequireDefault(require("../"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+describe('image plugin', function () {
+  var value = {};
+  var imageSupport = {
+    "delete": jest.fn(),
+    add: jest.fn()
+  };
+  var imagePlugin = (0, _["default"])({
+    onDelete: function onDelete(src, done) {
+      imageSupport["delete"](src, function (e) {
+        done(e, value);
+      });
+    },
+    insertImageRequested: function insertImageRequested(node, getHandler) {
+      var handler = getHandler(function () {
+        return value;
+      });
+      imageSupport.add(handler);
+    }
+  });
+  describe('normalizeNode', function () {
+    it('should exit the function if the node is not of type document', function () {
+      var returnValue = imagePlugin.normalizeNode({
+        object: 'image'
+      });
+      expect(returnValue).toEqual(undefined);
+    });
+    it('should exit if the function if there are no changes needed', function () {
+      var nodes = [{
+        object: 'text',
+        text: 'Before Image'
+      }, {
+        type: 'image'
+      }, {
+        object: 'text',
+        text: 'After Image'
+      }];
+      var returnValue = imagePlugin.normalizeNode({
+        object: 'document',
+        findDescendant: jest.fn(function (callback) {
+          nodes.forEach(function (n) {
+            return callback(n);
+          });
+        })
+      });
+      expect(returnValue).toEqual(undefined);
+    });
+    it('should return a function if there is a node with an empty text before an image', function () {
+      var nodes = [{
+        object: 'text',
+        text: '',
+        key: '1'
+      }, {
+        type: 'image',
+        key: '2'
+      }, {
+        object: 'text',
+        text: 'After Image',
+        key: '3'
+      }];
+      var findDescendant = jest.fn(function (callback) {
+        nodes.forEach(function (n) {
+          return callback(n);
+        });
+      });
+      var change = {
+        withoutNormalization: jest.fn(function (callback) {
+          callback();
+        }),
+        insertTextByKey: jest.fn()
+      };
+      var returnValue = imagePlugin.normalizeNode({
+        object: 'document',
+        findDescendant: findDescendant
+      });
+      expect(returnValue).toEqual(expect.any(Function));
+      returnValue(change);
+      expect(change.withoutNormalization).toHaveBeenCalledWith(expect.any(Function));
+      expect(change.insertTextByKey).toHaveBeenCalledWith('1', 0, ' ');
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/plugins/image/__tests__/insert-image-handler.test.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+var _mockChange = _interopRequireWildcard(require("./mock-change"));
+
+var _slate = require("slate");
+
+var _insertImageHandler = _interopRequireDefault(require("../insert-image-handler"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+expect.extend({
+  toMatchData: function toMatchData(received, argument) {
+    var argData = _slate.Data.create(argument);
+
+    var pass = argData.equals(received.data);
+
+    if (pass) {
+      return {
+        message: function message() {
+          return "expected ".concat(received.toJSON(), " not to be divisible by ").concat(argData.toJSON());
+        },
+        pass: true
+      };
+    } else {
+      return {
+        message: function message() {
+          return "expected ".concat(received.toJSON(), " to be divisible by ").concat(argData.toJSON());
+        },
+        pass: false
+      };
+    }
+  }
+});
+describe('insert image handler', function () {
+  var _change, document, value;
+
+  beforeEach(function () {
+    document = new _mockChange.MockDocument();
+    _change = new _mockChange["default"]();
+    value = {
+      change: function change() {
+        return _change;
+      },
+      document: document
+    };
+  });
+  var block = {
+    key: 1
+  };
+  var onChange = jest.fn();
+  var handler = new _insertImageHandler["default"](block, function () {}, function () {
+    return value;
+  }, onChange);
+  test('it constructs', function () {
+    expect(handler).not.toEqual(undefined);
+  });
+  describe('fileChosen', function () {
+    var fileReader;
+    beforeEach(function () {
+      fileReader = {
+        readAsDataURL: jest.fn()
+      };
+
+      global.FileReader = function () {
+        return fileReader;
+      };
+
+      handler.fileChosen({});
+    });
+    test('calls readAsDataURL', function () {
+      expect(fileReader.readAsDataURL).toBeCalledWith({});
+    });
+    test('calls onChange with src -> dataUrl', function () {
+      fileReader.result = 'dataURL';
+      fileReader.onload();
+      expect(_change.setNodeByKey).toBeCalledWith(block.key, expect.anything());
+      expect(_change.setNodeByKey.mock.calls[0][1]).toMatchData({
+        src: 'dataURL'
+      });
+      expect(onChange).toBeCalledWith(_change);
+    });
+  });
+  describe('progress', function () {
+    test('calls change w/ percent', function () {
+      handler.progress(40, 40, 100);
+      expect(_change.setNodeByKey).toBeCalledWith(block.key, expect.anything());
+      expect(_change.setNodeByKey.mock.calls[0][1].data.toJS()).toMatchObject({
+        percent: 40
+      });
+    });
+  });
+  describe('done', function () {
+    test('calls setNodeByKey', function () {
+      handler.done(null, 'src');
+      expect(_change.setNodeByKey).toBeCalledWith(block.key, expect.anything());
+      expect(_change.setNodeByKey.mock.calls[0][1].data.toJS()).toMatchObject({
+        src: 'src',
+        loaded: true,
+        percent: 100
+      });
+    });
+  });
+  describe('cancel', function () {
+    beforeEach(function () {
+      document.getChild = jest.fn().mockReturnValue({
+        data: _slate.Data.create({}),
+        key: block.key
+      });
+      handler.cancel();
+    });
+    test('calls onChange', function () {
+      expect(onChange).toBeCalled();
+    });
+    test('calls removeNodeByKey', function () {
+      expect(_change.removeNodeByKey).toBeCalledWith(block.key);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/plugins/image/__tests__/insert-image-handler.test.js"],"names":["expect","extend","toMatchData","received","argument","argData","Data","create","pass","equals","data","message","toJSON","describe","change","document","value","beforeEach","MockDocument","MockChange","block","key","onChange","jest","fn","handler","InsertImageHandler","test","not","toEqual","undefined","fileReader","readAsDataURL","global","FileReader","fileChosen","toBeCalledWith","result","onload","setNodeByKey","anything","mock","calls","src","progress","toJS","toMatchObject","percent","done","loaded","getChild","mockReturnValue","cancel","toBeCalled","removeNodeByKey"],"mappings":"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","sourcesContent":["import MockChange, { MockDocument } from './mock-change';\n\nimport { Data } from 'slate';\nimport InsertImageHandler from '../insert-image-handler';\n\nexpect.extend({\n  toMatchData: (received, argument) => {\n    const argData = Data.create(argument);\n    const pass = argData.equals(received.data);\n    if (pass) {\n      return {\n        message: () => `expected ${received.toJSON()} not to be divisible by ${argData.toJSON()}`,\n        pass: true,\n      };\n    } else {\n      return {\n        message: () => `expected ${received.toJSON()} to be divisible by ${argData.toJSON()}`,\n        pass: false,\n      };\n    }\n  },\n});\ndescribe('insert image handler', () => {\n  let change, document, value;\n  beforeEach(() => {\n    document = new MockDocument();\n    change = new MockChange();\n    value = {\n      change: () => change,\n      document,\n    };\n  });\n\n  const block = { key: 1 };\n  const onChange = jest.fn();\n\n  const handler = new InsertImageHandler(\n    block,\n    () => {},\n    () => value,\n    onChange,\n  );\n\n  test('it constructs', () => {\n    expect(handler).not.toEqual(undefined);\n  });\n\n  describe('fileChosen', () => {\n    let fileReader;\n    beforeEach(() => {\n      fileReader = {\n        readAsDataURL: jest.fn(),\n      };\n\n      global.FileReader = () => fileReader;\n      handler.fileChosen({});\n    });\n\n    test('calls readAsDataURL', () => {\n      expect(fileReader.readAsDataURL).toBeCalledWith({});\n    });\n\n    test('calls onChange with src -> dataUrl', () => {\n      fileReader.result = 'dataURL';\n      fileReader.onload();\n      expect(change.setNodeByKey).toBeCalledWith(block.key, expect.anything());\n      expect(change.setNodeByKey.mock.calls[0][1]).toMatchData({\n        src: 'dataURL',\n      });\n      expect(onChange).toBeCalledWith(change);\n    });\n  });\n\n  describe('progress', () => {\n    test('calls change w/ percent', () => {\n      handler.progress(40, 40, 100);\n      expect(change.setNodeByKey).toBeCalledWith(block.key, expect.anything());\n\n      expect(change.setNodeByKey.mock.calls[0][1].data.toJS()).toMatchObject({\n        percent: 40,\n      });\n    });\n  });\n\n  describe('done', () => {\n    test('calls setNodeByKey', () => {\n      handler.done(null, 'src');\n\n      expect(change.setNodeByKey).toBeCalledWith(block.key, expect.anything());\n\n      expect(change.setNodeByKey.mock.calls[0][1].data.toJS()).toMatchObject({\n        src: 'src',\n        loaded: true,\n        percent: 100,\n      });\n    });\n  });\n\n  describe('cancel', () => {\n    beforeEach(() => {\n      document.getChild = jest.fn().mockReturnValue({ data: Data.create({}), key: block.key });\n      handler.cancel();\n    });\n\n    test('calls onChange', () => {\n      expect(onChange).toBeCalled();\n    });\n\n    test('calls removeNodeByKey', () => {\n      expect(change.removeNodeByKey).toBeCalledWith(block.key);\n    });\n  });\n});\n"]}

package/lib/plugins/image/__tests__/mock-change.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MockDocument = MockDocument;
+exports["default"] = MockChange;
+
+var _slate = require("slate");
+
+function MockChange() {
+  this.setNodeByKey = jest.fn().mockReturnValue(this);
+  this.removeNodeByKey = jest.fn().mockReturnValue(this);
+  this.insertInline = jest.fn().mockReturnValue(this);
+  this.moveFocusTo = jest.fn().mockReturnValue(this);
+  this.moveAnchorTo = jest.fn().mockReturnValue(this);
+}
+
+function MockDocument() {
+  this.getChild = jest.fn().mockReturnValue({
+    data: _slate.Data.create({})
+  });
+  this.getDescendant = jest.fn();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wbHVnaW5zL2ltYWdlL19fdGVzdHNfXy9tb2NrLWNoYW5nZS5qcyJdLCJuYW1lcyI6WyJNb2NrQ2hhbmdlIiwic2V0Tm9kZUJ5S2V5IiwiamVzdCIsImZuIiwibW9ja1JldHVyblZhbHVlIiwicmVtb3ZlTm9kZUJ5S2V5IiwiaW5zZXJ0SW5saW5lIiwibW92ZUZvY3VzVG8iLCJtb3ZlQW5jaG9yVG8iLCJNb2NrRG9jdW1lbnQiLCJnZXRDaGlsZCIsImRhdGEiLCJEYXRhIiwiY3JlYXRlIiwiZ2V0RGVzY2VuZGFudCJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFBQTs7QUFFZSxTQUFTQSxVQUFULEdBQXNCO0FBQ25DLE9BQUtDLFlBQUwsR0FBb0JDLElBQUksQ0FBQ0MsRUFBTCxHQUFVQyxlQUFWLENBQTBCLElBQTFCLENBQXBCO0FBQ0EsT0FBS0MsZUFBTCxHQUF1QkgsSUFBSSxDQUFDQyxFQUFMLEdBQVVDLGVBQVYsQ0FBMEIsSUFBMUIsQ0FBdkI7QUFDQSxPQUFLRSxZQUFMLEdBQW9CSixJQUFJLENBQUNDLEVBQUwsR0FBVUMsZUFBVixDQUEwQixJQUExQixDQUFwQjtBQUNBLE9BQUtHLFdBQUwsR0FBbUJMLElBQUksQ0FBQ0MsRUFBTCxHQUFVQyxlQUFWLENBQTBCLElBQTFCLENBQW5CO0FBQ0EsT0FBS0ksWUFBTCxHQUFvQk4sSUFBSSxDQUFDQyxFQUFMLEdBQVVDLGVBQVYsQ0FBMEIsSUFBMUIsQ0FBcEI7QUFDRDs7QUFFTSxTQUFTSyxZQUFULEdBQXdCO0FBQzdCLE9BQUtDLFFBQUwsR0FBZ0JSLElBQUksQ0FBQ0MsRUFBTCxHQUFVQyxlQUFWLENBQTBCO0FBQUVPLElBQUFBLElBQUksRUFBRUMsWUFBS0MsTUFBTCxDQUFZLEVBQVo7QUFBUixHQUExQixDQUFoQjtBQUVBLE9BQUtDLGFBQUwsR0FBcUJaLElBQUksQ0FBQ0MsRUFBTCxFQUFyQjtBQUNEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGF0YSB9IGZyb20gJ3NsYXRlJztcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gTW9ja0NoYW5nZSgpIHtcbiAgdGhpcy5zZXROb2RlQnlLZXkgPSBqZXN0LmZuKCkubW9ja1JldHVyblZhbHVlKHRoaXMpO1xuICB0aGlzLnJlbW92ZU5vZGVCeUtleSA9IGplc3QuZm4oKS5tb2NrUmV0dXJuVmFsdWUodGhpcyk7XG4gIHRoaXMuaW5zZXJ0SW5saW5lID0gamVzdC5mbigpLm1vY2tSZXR1cm5WYWx1ZSh0aGlzKTtcbiAgdGhpcy5tb3ZlRm9jdXNUbyA9IGplc3QuZm4oKS5tb2NrUmV0dXJuVmFsdWUodGhpcyk7XG4gIHRoaXMubW92ZUFuY2hvclRvID0gamVzdC5mbigpLm1vY2tSZXR1cm5WYWx1ZSh0aGlzKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIE1vY2tEb2N1bWVudCgpIHtcbiAgdGhpcy5nZXRDaGlsZCA9IGplc3QuZm4oKS5tb2NrUmV0dXJuVmFsdWUoeyBkYXRhOiBEYXRhLmNyZWF0ZSh7fSkgfSk7XG5cbiAgdGhpcy5nZXREZXNjZW5kYW50ID0gamVzdC5mbigpO1xufVxuIl19