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

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

@@ -0,0 +1,442 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+var _slateEditTable = _interopRequireDefault(require("slate-edit-table"));
+
+var _index = _interopRequireWildcard(require("../index"));
+
+var _slate = require("slate");
+
+var _react = _interopRequireDefault(require("react"));
+
+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; }
+
+jest.mock('slate-edit-table', function () {
+  var mock = {
+    "default": jest.fn().mockReturnThis(),
+    utils: {
+      isSelectionInTable: jest.fn().mockReturnValue(true),
+      createTable: jest.fn(function (c) {
+        return {
+          toJSON: jest.fn().mockReturnValue({
+            object: 'block',
+            type: 'table'
+          })
+        };
+      })
+    },
+    changes: {
+      insertTable: jest.fn(function (c) {
+        return c;
+      })
+    }
+  };
+  return jest.fn().mockReturnValue(mock);
+});
+describe('table', function () {
+  describe('toolbar', function () {
+    describe('onClick', function () {
+      var plugin;
+      var onChange;
+      var findDescendant;
+      var insertBlock;
+      var changeMock;
+      beforeEach(function () {
+        plugin = (0, _index["default"])();
+        onChange = jest.fn();
+        insertBlock = jest.fn();
+        findDescendant = jest.fn();
+        changeMock = jest.fn().mockReturnValue({
+          insertBlock: insertBlock,
+          value: {
+            document: {
+              findDescendant: findDescendant
+            }
+          }
+        });
+      });
+      it('calls utils.createTable', function () {
+        plugin.toolbar.onClick({
+          change: changeMock
+        }, onChange);
+        expect((0, _slateEditTable["default"])().utils.createTable).toHaveBeenCalledWith(2, 2);
+      });
+      it('creates table with border: 1 as default', function () {
+        plugin.toolbar.onClick({
+          change: changeMock
+        }, onChange);
+        expect(insertBlock).toHaveBeenCalledWith(_slate.Block.create({
+          key: '2',
+          type: 'table',
+          data: {
+            border: '1',
+            newTable: true
+          }
+        }));
+      });
+      it('moves cursor to first cell of the table and removes the newTable property', function () {
+        var dataRemoveFn = jest.fn().mockReturnValue({
+          border: '1'
+        });
+        var setNodeByKey = jest.fn();
+        var newTableBlock = {
+          key: '2',
+          data: {
+            remove: dataRemoveFn
+          }
+        };
+        var collapseToStartOf = jest.fn();
+        changeMock = jest.fn().mockReturnValue({
+          insertBlock: insertBlock,
+          collapseToStartOf: collapseToStartOf,
+          setNodeByKey: setNodeByKey,
+          value: {
+            document: {
+              findDescendant: jest.fn().mockReturnValue(newTableBlock)
+            }
+          }
+        });
+        plugin.toolbar.onClick({
+          change: changeMock
+        }, onChange);
+        expect(collapseToStartOf).toHaveBeenCalledWith(newTableBlock);
+        expect(dataRemoveFn).toHaveBeenCalledWith('newTable');
+        expect(setNodeByKey).toHaveBeenCalledWith('2', {
+          data: {
+            border: '1'
+          }
+        });
+      });
+    });
+    describe('supports', function () {
+      var assertSupports = function assertSupports(inTable, object, expected) {
+        it("inTable: ".concat(inTable, ", type: ").concat(object, " => ").concat(expected), function () {
+          (0, _slateEditTable["default"])().utils.isSelectionInTable.mockReturnValue(inTable);
+          var plugin = (0, _index["default"])();
+          var supports = plugin.toolbar.supports({
+            object: object
+          });
+          expect(supports).toEqual(expected);
+        });
+      };
+
+      assertSupports(true, 'block', true);
+      assertSupports(false, 'block', false);
+      assertSupports(true, 'inline', false);
+      assertSupports(false, 'inline', false);
+    });
+    describe('customToolbar', function () {
+      describe('toggleBorder', function () {
+        var assertToggle = function assertToggle(border, expectedBorder) {
+          describe("with initial border of ".concat(border), function () {
+            var change;
+            var done;
+            beforeEach(function () {
+              var plugin = (0, _index["default"])();
+              change = {
+                setNodeByKey: jest.fn().mockReturnThis()
+              };
+              plugin.utils.getTableBlock = jest.fn().mockReturnValue({
+                key: 'tableKey',
+                data: _slate.Data.create({
+                  border: border
+                })
+              });
+              var node = {
+                key: 'nodeKey'
+              };
+              var value = {
+                change: jest.fn().mockReturnValue(change)
+              };
+              done = jest.fn();
+              var Comp = plugin.toolbar.customToolbar(node, value, done);
+              var c = Comp();
+              c.props.onToggleBorder();
+            });
+            it("calls setNodeByKey with ".concat(expectedBorder), function () {
+              expect(change.setNodeByKey).toHaveBeenCalledWith('tableKey', {
+                data: _slate.Data.create({
+                  border: expectedBorder
+                })
+              });
+            });
+            it('calls onToolbarDone', function () {
+              expect(done).toHaveBeenCalledWith(change, false);
+            });
+          });
+        };
+
+        assertToggle(null, '1');
+        assertToggle(undefined, '1');
+        assertToggle('0', '1');
+        assertToggle('1', '0');
+        assertToggle('2', '0');
+      });
+    });
+    describe('normalizeNode', function () {
+      it('should exit the function if the node is not of type document', function () {
+        var tablePlugin = (0, _index["default"])();
+        var returnValue = tablePlugin.normalizeNode({
+          object: 'table'
+        });
+        expect(returnValue).toEqual(undefined);
+      });
+      it('should exit there are no changes needed', function () {
+        var tablePlugin = (0, _index["default"])();
+        var nodes = {
+          size: 3,
+          findLastIndex: jest.fn().mockReturnValue(1)
+        };
+        var returnValue = tablePlugin.normalizeNode({
+          object: 'document',
+          nodes: nodes,
+          findDescendant: jest.fn().mockReturnValue({
+            object: 'block',
+            type: 'table'
+          }),
+          getParent: jest.fn().mockReturnValue(undefined)
+        });
+        expect(returnValue).toEqual(undefined);
+      });
+      it('should return a function if a table does not have a node before or after it', function () {
+        var tablePlugin = (0, _index["default"])();
+        var nodes = [{
+          object: 'block',
+          type: 'table',
+          key: '99',
+          data: _slate.Data.create({
+            newTable: true
+          })
+        }];
+        var findDescendant = jest.fn(function (callback) {
+          nodes.forEach(function (n) {
+            return callback(n);
+          });
+        });
+        var change = {
+          insertNodeByPath: jest.fn(),
+          value: {
+            document: {
+              getPath: jest.fn().mockReturnValue(_slate.PathUtils.create([0, 0]))
+            }
+          }
+        };
+        var returnValue = tablePlugin.normalizeNode({
+          object: 'document',
+          findDescendant: findDescendant,
+          getPath: jest.fn().mockReturnValue(_slate.PathUtils.create([0, 0])),
+          getPreviousNode: jest.fn().mockReturnValue(undefined),
+          getNextNode: jest.fn().mockReturnValue(undefined)
+        });
+        expect(returnValue).toEqual(expect.any(Function));
+        returnValue(change);
+        expect(change.insertNodeByPath).toHaveBeenCalledWith([0], 0, {
+          object: 'block',
+          type: 'div'
+        });
+      });
+    });
+  });
+});
+describe('parseStyleString', function () {
+  var parses = function parses(s, expected) {
+    it("parses ".concat(s, " -> ").concat(JSON.stringify(expected)), function () {
+      var result = (0, _index.parseStyleString)(s);
+      expect(result).toEqual(expected);
+    });
+  };
+
+  parses(' width: 10px ', {
+    width: '10px'
+  });
+  parses(' width: 10px; ', {
+    width: '10px'
+  });
+  parses(' border-width: 10px; ', {
+    'border-width': '10px'
+  });
+  parses(' border: solid 1px red; height: 1px', {
+    border: 'solid 1px red',
+    height: '1px'
+  });
+});
+describe('toStyleString', function () {
+  var styleString = function styleString(o, expected) {
+    it("".concat(JSON.stringify(s), " -> ").concat(expected), function () {
+      var result = toStyleString(o);
+      expect(result).toEqual(expected);
+    });
+  };
+});
+describe('reactAttributes', function () {
+  var attributes = function attributes(o, expected) {
+    it("".concat(JSON.stringify(o), " -> ").concat(JSON.stringify(expected)), function () {
+      var result = (0, _index.reactAttributes)(o);
+      expect(result).toEqual(expected);
+    });
+  };
+
+  attributes({
+    'border-width': '10px',
+    'line-height': 1.56
+  }, {
+    borderWidth: '10px',
+    lineHeight: '1.56'
+  });
+});
+describe('serialization', function () {
+  describe('deserialize', function () {
+    var next;
+    beforeEach(function () {
+      next = jest.fn().mockReturnValue([]);
+    });
+    describe('table', function () {
+      var el;
+      var out;
+      beforeEach(function () {
+        el = {
+          tagName: 'table',
+          children: [],
+          getAttribute: jest.fn(function (name) {
+            switch (name) {
+              case 'border':
+                return '1';
+
+              case 'cellspacing':
+                return '2';
+
+              case 'cellpadding':
+                return '3';
+
+              case 'class':
+                return 'table-class';
+
+              case 'style':
+                return 'width: 10px';
+            }
+          })
+        };
+        out = _index.serialization.deserialize(el, next);
+      });
+
+      var assertData = function assertData(name, value) {
+        it("data.".concat(name, " should eql ").concat(value), function () {
+          expect(out.data[name]).toEqual(value);
+        });
+      };
+
+      assertData('border', '1');
+      assertData('cellspacing', '2');
+      assertData('cellpadding', '3');
+      assertData('class', 'table-class');
+      assertData('style', {
+        width: '10px'
+      });
+      it('returns a table block', function () {
+        expect(out).toMatchObject({
+          object: 'block',
+          type: 'table',
+          nodes: []
+        });
+      });
+    });
+    it('deserializes tr', function () {
+      var el = {
+        tagName: 'tr',
+        children: []
+      };
+
+      var out = _index.serialization.deserialize(el, next);
+
+      expect(out).toEqual({
+        object: 'block',
+        type: 'table_row',
+        nodes: []
+      });
+    });
+    it('deserializes td', function () {
+      var el = {
+        tagName: 'td',
+        childNodes: [],
+        getAttribute: jest.fn(function (name) {
+          var o = {
+            "class": 'class name',
+            colspan: '1',
+            rowspan: '1'
+          };
+          return o[name];
+        })
+      };
+
+      var out = _index.serialization.deserialize(el, next);
+
+      expect(out).toEqual({
+        object: 'block',
+        type: 'table_cell',
+        nodes: [],
+        data: {
+          colspan: '1',
+          rowspan: '1',
+          "class": 'class name',
+          header: false
+        }
+      });
+    });
+  });
+  describe('serialize', function () {
+    it('serializes table', function () {
+      var el = _index.serialization.serialize({
+        object: 'block',
+        type: 'table',
+        nodes: [],
+        data: _slate.Data.create({
+          border: '1',
+          cellpadding: '2',
+          cellspacing: '3'
+        })
+      });
+
+      expect(el).toEqual( /*#__PURE__*/_react["default"].createElement("table", {
+        border: "1",
+        cellPadding: "2",
+        cellSpacing: "3"
+      }, /*#__PURE__*/_react["default"].createElement("tbody", null)));
+    });
+    it('serializes table_row', function () {
+      var el = _index.serialization.serialize({
+        object: 'block',
+        type: 'table_row',
+        nodes: []
+      });
+
+      expect(el).toEqual( /*#__PURE__*/_react["default"].createElement("tr", null));
+    });
+    it('serializes table_cell', function () {
+      var el = _index.serialization.serialize({
+        object: 'block',
+        type: 'table_cell',
+        nodes: [],
+        data: _slate.Data.create({
+          header: false,
+          style: {
+            width: '10px'
+          },
+          "class": 'foo'
+        })
+      });
+
+      expect(el).toEqual( /*#__PURE__*/_react["default"].createElement("td", {
+        style: {
+          width: '10px'
+        },
+        className: 'foo'
+      }));
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/plugins/table/__tests__/index.test.jsx"],"names":["jest","mock","fn","mockReturnThis","utils","isSelectionInTable","mockReturnValue","createTable","c","toJSON","object","type","changes","insertTable","describe","plugin","onChange","findDescendant","insertBlock","changeMock","beforeEach","value","document","it","toolbar","onClick","change","expect","toHaveBeenCalledWith","Block","create","key","data","border","newTable","dataRemoveFn","setNodeByKey","newTableBlock","remove","collapseToStartOf","assertSupports","inTable","expected","supports","toEqual","assertToggle","expectedBorder","done","getTableBlock","Data","node","Comp","customToolbar","props","onToggleBorder","undefined","tablePlugin","returnValue","normalizeNode","nodes","size","findLastIndex","getParent","callback","forEach","n","insertNodeByPath","getPath","PathUtils","getPreviousNode","getNextNode","any","Function","parses","s","JSON","stringify","result","width","height","styleString","o","toStyleString","attributes","borderWidth","lineHeight","next","el","out","tagName","children","getAttribute","name","serialization","deserialize","assertData","toMatchObject","childNodes","colspan","rowspan","header","serialize","cellpadding","cellspacing","style"],"mappings":"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","sourcesContent":["import EditTable from 'slate-edit-table';\nimport TablePlugin, { serialization, parseStyleString, reactAttributes } from '../index';\nimport { Data, Block, PathUtils } from 'slate';\nimport React from 'react';\n\njest.mock('slate-edit-table', () => {\n  const mock = {\n    default: jest.fn().mockReturnThis(),\n    utils: {\n      isSelectionInTable: jest.fn().mockReturnValue(true),\n      createTable: jest.fn(function(c) {\n        return {\n          toJSON: jest.fn().mockReturnValue({ object: 'block', type: 'table' }),\n        };\n      }),\n    },\n    changes: {\n      insertTable: jest.fn(function(c) {\n        return c;\n      }),\n    },\n  };\n\n  return jest.fn().mockReturnValue(mock);\n});\n\ndescribe('table', () => {\n  describe('toolbar', () => {\n    describe('onClick', () => {\n      let plugin;\n      let onChange;\n      let findDescendant;\n      let insertBlock;\n      let changeMock;\n\n      beforeEach(() => {\n        plugin = TablePlugin();\n        onChange = jest.fn();\n        insertBlock = jest.fn();\n        findDescendant = jest.fn();\n        changeMock = jest.fn().mockReturnValue({\n          insertBlock,\n          value: {\n            document: {\n              findDescendant,\n            },\n          },\n        });\n      });\n\n      it('calls utils.createTable', () => {\n        plugin.toolbar.onClick({ change: changeMock }, onChange);\n\n        expect(EditTable().utils.createTable).toHaveBeenCalledWith(2, 2);\n      });\n\n      it('creates table with border: 1 as default', () => {\n        plugin.toolbar.onClick({ change: changeMock }, onChange);\n\n        expect(insertBlock).toHaveBeenCalledWith(\n          Block.create({ key: '2', type: 'table', data: { border: '1', newTable: true } }),\n        );\n      });\n\n      it('moves cursor to first cell of the table and removes the newTable property', () => {\n        const dataRemoveFn = jest.fn().mockReturnValue({ border: '1' });\n        const setNodeByKey = jest.fn();\n        const newTableBlock = {\n          key: '2',\n          data: {\n            remove: dataRemoveFn,\n          },\n        };\n        const collapseToStartOf = jest.fn();\n\n        changeMock = jest.fn().mockReturnValue({\n          insertBlock,\n          collapseToStartOf,\n          setNodeByKey,\n          value: {\n            document: {\n              findDescendant: jest.fn().mockReturnValue(newTableBlock),\n            },\n          },\n        });\n        plugin.toolbar.onClick({ change: changeMock }, onChange);\n\n        expect(collapseToStartOf).toHaveBeenCalledWith(newTableBlock);\n        expect(dataRemoveFn).toHaveBeenCalledWith('newTable');\n        expect(setNodeByKey).toHaveBeenCalledWith('2', { data: { border: '1' } });\n      });\n    });\n\n    describe('supports', () => {\n      const assertSupports = (inTable, object, expected) => {\n        it(`inTable: ${inTable}, type: ${object} => ${expected}`, () => {\n          EditTable().utils.isSelectionInTable.mockReturnValue(inTable);\n          const plugin = TablePlugin();\n          const supports = plugin.toolbar.supports({ object });\n          expect(supports).toEqual(expected);\n        });\n      };\n\n      assertSupports(true, 'block', true);\n      assertSupports(false, 'block', false);\n      assertSupports(true, 'inline', false);\n      assertSupports(false, 'inline', false);\n    });\n\n    describe('customToolbar', () => {\n      describe('toggleBorder', () => {\n        const assertToggle = (border, expectedBorder) => {\n          describe(`with initial border of ${border}`, () => {\n            let change;\n            let done;\n\n            beforeEach(() => {\n              const plugin = TablePlugin();\n              change = {\n                setNodeByKey: jest.fn().mockReturnThis(),\n              };\n              plugin.utils.getTableBlock = jest.fn().mockReturnValue({\n                key: 'tableKey',\n                data: Data.create({ border }),\n              });\n              const node = { key: 'nodeKey' };\n              const value = {\n                change: jest.fn().mockReturnValue(change),\n              };\n              done = jest.fn();\n              const Comp = plugin.toolbar.customToolbar(node, value, done);\n              const c = Comp();\n              c.props.onToggleBorder();\n            });\n\n            it(`calls setNodeByKey with ${expectedBorder}`, () => {\n              expect(change.setNodeByKey).toHaveBeenCalledWith('tableKey', {\n                data: Data.create({ border: expectedBorder }),\n              });\n            });\n\n            it('calls onToolbarDone', () => {\n              expect(done).toHaveBeenCalledWith(change, false);\n            });\n          });\n        };\n\n        assertToggle(null, '1');\n        assertToggle(undefined, '1');\n        assertToggle('0', '1');\n        assertToggle('1', '0');\n        assertToggle('2', '0');\n      });\n    });\n\n    describe('normalizeNode', () => {\n      it('should exit the function if the node is not of type document', () => {\n        const tablePlugin = TablePlugin();\n        const returnValue = tablePlugin.normalizeNode({ object: 'table' });\n\n        expect(returnValue).toEqual(undefined);\n      });\n\n      it('should exit there are no changes needed', () => {\n        const tablePlugin = TablePlugin();\n        const nodes = {\n          size: 3,\n          findLastIndex: jest.fn().mockReturnValue(1),\n        };\n        const returnValue = tablePlugin.normalizeNode({\n          object: 'document',\n          nodes,\n          findDescendant: jest.fn().mockReturnValue({ object: 'block', type: 'table' }),\n          getParent: jest.fn().mockReturnValue(undefined),\n        });\n        expect(returnValue).toEqual(undefined);\n      });\n\n      it('should return a function if a table does not have a node before or after it', () => {\n        const tablePlugin = TablePlugin();\n        const nodes = [\n          {\n            object: 'block',\n            type: 'table',\n            key: '99',\n            data: Data.create({\n              newTable: true,\n            }),\n          },\n        ];\n        const findDescendant = jest.fn((callback) => {\n          nodes.forEach((n) => callback(n));\n        });\n        const change = {\n          insertNodeByPath: jest.fn(),\n          value: {\n            document: {\n              getPath: jest.fn().mockReturnValue(PathUtils.create([0, 0])),\n            },\n          },\n        };\n\n        const returnValue = tablePlugin.normalizeNode({\n          object: 'document',\n          findDescendant,\n          getPath: jest.fn().mockReturnValue(PathUtils.create([0, 0])),\n          getPreviousNode: jest.fn().mockReturnValue(undefined),\n          getNextNode: jest.fn().mockReturnValue(undefined),\n        });\n\n        expect(returnValue).toEqual(expect.any(Function));\n\n        returnValue(change);\n\n        expect(change.insertNodeByPath).toHaveBeenCalledWith([0], 0, {\n          object: 'block',\n          type: 'div',\n        });\n      });\n    });\n  });\n});\n\ndescribe('parseStyleString', () => {\n  const parses = (s, expected) => {\n    it(`parses ${s} -> ${JSON.stringify(expected)}`, () => {\n      const result = parseStyleString(s);\n      expect(result).toEqual(expected);\n    });\n  };\n  parses(' width: 10px ', { width: '10px' });\n  parses(' width: 10px; ', { width: '10px' });\n  parses(' border-width: 10px; ', { 'border-width': '10px' });\n  parses(' border: solid 1px red; height: 1px', {\n    border: 'solid 1px red',\n    height: '1px',\n  });\n});\n\ndescribe('toStyleString', () => {\n  const styleString = (o, expected) => {\n    it(`${JSON.stringify(s)} -> ${expected}`, () => {\n      const result = toStyleString(o);\n      expect(result).toEqual(expected);\n    });\n  };\n});\n\ndescribe('reactAttributes', () => {\n  const attributes = (o, expected) => {\n    it(`${JSON.stringify(o)} -> ${JSON.stringify(expected)}`, () => {\n      const result = reactAttributes(o);\n      expect(result).toEqual(expected);\n    });\n  };\n  attributes({ 'border-width': '10px', 'line-height': 1.56 }, { borderWidth: '10px', lineHeight: '1.56' });\n});\n\ndescribe('serialization', () => {\n  describe('deserialize', () => {\n    let next;\n\n    beforeEach(() => {\n      next = jest.fn().mockReturnValue([]);\n    });\n\n    describe('table', () => {\n      let el;\n      let out;\n      beforeEach(() => {\n        el = {\n          tagName: 'table',\n          children: [],\n          getAttribute: jest.fn((name) => {\n            switch (name) {\n              case 'border':\n                return '1';\n              case 'cellspacing':\n                return '2';\n              case 'cellpadding':\n                return '3';\n              case 'class':\n                return 'table-class';\n              case 'style':\n                return 'width: 10px';\n            }\n          }),\n        };\n        out = serialization.deserialize(el, next);\n      });\n\n      const assertData = (name, value) => {\n        it(`data.${name} should eql ${value}`, () => {\n          expect(out.data[name]).toEqual(value);\n        });\n      };\n\n      assertData('border', '1');\n      assertData('cellspacing', '2');\n      assertData('cellpadding', '3');\n      assertData('class', 'table-class');\n      assertData('style', { width: '10px' });\n      it('returns a table block', () => {\n        expect(out).toMatchObject({\n          object: 'block',\n          type: 'table',\n          nodes: [],\n        });\n      });\n    });\n\n    it('deserializes tr', () => {\n      const el = {\n        tagName: 'tr',\n        children: [],\n      };\n\n      const out = serialization.deserialize(el, next);\n\n      expect(out).toEqual({\n        object: 'block',\n        type: 'table_row',\n        nodes: [],\n      });\n    });\n\n    it('deserializes td', () => {\n      const el = {\n        tagName: 'td',\n        childNodes: [],\n        getAttribute: jest.fn(function(name) {\n          const o = {\n            class: 'class name',\n            colspan: '1',\n            rowspan: '1',\n          };\n          return o[name];\n        }),\n      };\n\n      const out = serialization.deserialize(el, next);\n\n      expect(out).toEqual({\n        object: 'block',\n        type: 'table_cell',\n        nodes: [],\n        data: {\n          colspan: '1',\n          rowspan: '1',\n          class: 'class name',\n          header: false,\n        },\n      });\n    });\n  });\n\n  describe('serialize', () => {\n    it('serializes table', () => {\n      const el = serialization.serialize({\n        object: 'block',\n        type: 'table',\n        nodes: [],\n        data: Data.create({\n          border: '1',\n          cellpadding: '2',\n          cellspacing: '3',\n        }),\n      });\n\n      expect(el).toEqual(\n        <table border=\"1\" cellPadding=\"2\" cellSpacing=\"3\">\n          <tbody />\n        </table>,\n      );\n    });\n\n    it('serializes table_row', () => {\n      const el = serialization.serialize({\n        object: 'block',\n        type: 'table_row',\n        nodes: [],\n      });\n\n      expect(el).toEqual(<tr />);\n    });\n    it('serializes table_cell', () => {\n      const el = serialization.serialize({\n        object: 'block',\n        type: 'table_cell',\n        nodes: [],\n        data: Data.create({\n          header: false,\n          style: { width: '10px' },\n          class: 'foo',\n        }),\n      });\n\n      expect(el).toEqual(<td style={{ width: '10px' }} className={'foo'} />);\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _tableToolbar = require("../table-toolbar");
+
+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('table-toolbar', function () {
+  var onDone, onAddColumn, onAddRow, onRemoveColumn, onRemoveRow, onRemoveTable, onToggleBorder;
+  beforeEach(function () {
+    onAddColumn = jest.fn();
+    onAddRow = jest.fn();
+    onRemoveColumn = jest.fn();
+    onRemoveRow = jest.fn();
+    onRemoveTable = jest.fn();
+    onDone = jest.fn();
+    onToggleBorder = jest.fn();
+  });
+
+  var mkWrapper = function mkWrapper(extras) {
+    var props = _objectSpread({
+      onDone: onDone,
+      onAddRow: onAddRow,
+      onRemoveRow: onRemoveRow,
+      onAddColumn: onAddColumn,
+      onRemoveColumn: onRemoveColumn,
+      onRemoveTable: onRemoveTable,
+      hasBorder: true,
+      onToggleBorder: onToggleBorder,
+      classes: {
+        tableToolbar: 'table-toolbar'
+      }
+    }, extras);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_tableToolbar.TableToolbar, props));
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      var w = mkWrapper();
+      expect(w).toMatchSnapshot();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/plugins/table/icons/index.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RemoveTable = exports.RemoveRow = exports.RemoveColumn = exports.AddRow = exports.AddColumn = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styles = require("@material-ui/core/styles");
+
+var styles = {
+  icon: {
+    fill: 'grey',
+    '&:hover': {
+      fill: 'black'
+    }
+  }
+};
+
+var SvgIcon = function SvgIcon(Component) {
+  return (0, _styles.withStyles)(styles)(function (props) {
+    return /*#__PURE__*/_react["default"].createElement("svg", {
+      xmlns: "http://www.w3.org/2000/svg",
+      version: "1.1",
+      width: "24",
+      height: "24",
+      viewBox: "0 0 24 24"
+    }, /*#__PURE__*/_react["default"].createElement(Component, {
+      className: props.classes.icon
+    }));
+  });
+};
+
+var AddRow = SvgIcon(function (props) {
+  return /*#__PURE__*/_react["default"].createElement("path", (0, _extends2["default"])({}, props, {
+    d: "M22,10A2,2 0 0,1 20,12H4A2,2 0 0,1 2,10V3H4V5H8V3H10V5H14V3H16V5H20V3H22V10M4,10H8V7H4V10M10,10H14V7H10V10M20,10V7H16V10H20M11,14H13V17H16V19H13V22H11V19H8V17H11V14Z"
+  }));
+});
+exports.AddRow = AddRow;
+var RemoveRow = SvgIcon(function (props) {
+  return /*#__PURE__*/_react["default"].createElement("path", (0, _extends2["default"])({}, props, {
+    d: "M9.41,13L12,15.59L14.59,13L16,14.41L13.41,17L16,19.59L14.59,21L12,18.41L9.41,21L8,19.59L10.59,17L8,14.41L9.41,13M22,9A2,2 0 0,1 20,11H4A2,2 0 0,1 2,9V6A2,2 0 0,1 4,4H20A2,2 0 0,1 22,6V9M4,9H8V6H4V9M10,9H14V6H10V9M16,9H20V6H16V9Z"
+  }));
+});
+exports.RemoveRow = RemoveRow;
+var AddColumn = SvgIcon(function (props) {
+  return /*#__PURE__*/_react["default"].createElement("path", (0, _extends2["default"])({}, props, {
+    d: "M11,2A2,2 0 0,1 13,4V20A2,2 0 0,1 11,22H2V2H11M4,10V14H11V10H4M4,16V20H11V16H4M4,4V8H11V4H4M15,11H18V8H20V11H23V13H20V16H18V13H15V11Z"
+  }));
+});
+exports.AddColumn = AddColumn;
+var RemoveColumn = SvgIcon(function (props) {
+  return /*#__PURE__*/_react["default"].createElement("path", (0, _extends2["default"])({}, props, {
+    d: "M4,2H11A2,2 0 0,1 13,4V20A2,2 0 0,1 11,22H4A2,2 0 0,1 2,20V4A2,2 0 0,1 4,2M4,10V14H11V10H4M4,16V20H11V16H4M4,4V8H11V4H4M17.59,12L15,9.41L16.41,8L19,10.59L21.59,8L23,9.41L20.41,12L23,14.59L21.59,16L19,13.41L16.41,16L15,14.59L17.59,12Z"
+  }));
+});
+exports.RemoveColumn = RemoveColumn;
+var RemoveTable = SvgIcon(function (props) {
+  return /*#__PURE__*/_react["default"].createElement("path", (0, _extends2["default"])({}, props, {
+    d: "M15.46,15.88L16.88,14.46L19,16.59L21.12,14.46L22.54,15.88L20.41,18L22.54,20.12L21.12,21.54L19,19.41L16.88,21.54L15.46,20.12L17.59,18L15.46,15.88M4,3H18A2,2 0 0,1 20,5V12.08C18.45,11.82 16.92,12.18 15.68,13H12V17H13.08C12.97,17.68 12.97,18.35 13.08,19H4A2,2 0 0,1 2,17V5A2,2 0 0,1 4,3M4,7V11H10V7H4M12,7V11H18V7H12M4,13V17H10V13H4Z"
+  }));
+});
+exports.RemoveTable = RemoveTable;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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