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

package/lib/plugins/list/index.js

@@ -0,0 +1,334 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serialization = exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _slate = require("slate");
+
+var _immutable = _interopRequireDefault(require("immutable"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _slateEditList = _interopRequireDefault(require("slate-edit-list"));
+
+var _options = _interopRequireDefault(require("slate-edit-list/dist/options"));
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _this = void 0;
+
+var log = (0, _debug["default"])('@pie-lib:editable-html:plugins:list');
+
+var b = function b(type, next, childNodes) {
+  return {
+    object: 'block',
+    type: type,
+    nodes: next(childNodes)
+  };
+};
+
+var serialization = {
+  deserialize: function deserialize(el, next) {
+    var name = el.tagName.toLowerCase();
+
+    if (name === 'li') {
+      return b('list_item', next, el.childNodes);
+    }
+
+    if (name === 'ul') {
+      return b('ul_list', next, el.children.length ? Array.from(el.children) : el.childNodes);
+    }
+
+    if (name === 'ol') {
+      return b('ol_list', next, el.children.length ? Array.from(el.children) : el.childNodes);
+    }
+  },
+  serialize: function serialize(object, children) {
+    if (object.object !== 'block') return;
+
+    if (object.type === 'list_item') {
+      return /*#__PURE__*/_react["default"].createElement("li", null, children);
+    }
+
+    if (object.type === 'ul_list') {
+      return /*#__PURE__*/_react["default"].createElement("ul", null, children);
+    }
+
+    if (object.type === 'ol_list') {
+      return /*#__PURE__*/_react["default"].createElement("ol", null, children);
+    }
+  }
+};
+exports.serialization = serialization;
+
+var createEditList = function createEditList() {
+  var core = (0, _slateEditList["default"])({
+    typeDefault: 'span'
+  });
+  var listOptions = new _options["default"]({
+    typeDefault: 'span'
+  }); // fix outdated schema
+
+  if (core.schema && core.schema.blocks) {
+    Object.keys(core.schema.blocks).forEach(function (key) {
+      var block = core.schema.blocks[key];
+
+      if (block.parent) {
+        return;
+      }
+
+      block.nodes[0] = {
+        type: block.nodes[0].types[0]
+      };
+    });
+  }
+  /**
+   * This override of the core.changes.wrapInList is needed because the version
+   * of immutable that we have does not support getting the element at a specific
+   * index with a square bracket (list[0]). We have to use the list.get function instead
+   */
+
+  /**
+   * Returns the highest list of blocks that cover the current selection
+   */
+
+
+  var getHighestSelectedBlocks = function getHighestSelectedBlocks(value) {
+    var range = value.selection;
+    var document = value.document;
+    var startBlock = document.getClosestBlock(range.startKey);
+    var endBlock = document.getClosestBlock(range.endKey);
+
+    if (startBlock === endBlock) {
+      return _immutable["default"].List([startBlock]);
+    }
+
+    var ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);
+    var startPath = ancestor.getPath(startBlock.key);
+    var endPath = ancestor.getPath(endBlock.key);
+    return ancestor.nodes.slice(startPath.get(0), endPath.get(0) + 1);
+  };
+  /**
+   * Wrap the blocks in the current selection in a new list. Selected
+   * lists are merged together.
+   */
+
+
+  core.changes.wrapInList = function (change, type, data) {
+    var selectedBlocks = getHighestSelectedBlocks(change.value); // Wrap in container
+
+    change.wrapBlock({
+      type: type,
+      data: _slate.Data.create(data)
+    }, {
+      normalize: false
+    }); // Wrap in list items
+
+    selectedBlocks.forEach(function (node) {
+      if (core.utils.isList(node)) {
+        // Merge its items with the created list
+        node.nodes.forEach(function (_ref) {
+          var key = _ref.key;
+          return change.unwrapNodeByKey(key, {
+            normalize: false
+          });
+        });
+      } else if (node.type !== 'list_item') {
+        change.wrapBlockByKey(node.key, 'list_item', {
+          normalize: false
+        });
+      }
+    });
+    return change.normalize();
+  };
+
+  core.changes.unwrapList = function unwrapList(opts, change) {
+    var items = core.utils.getItemsAtRange(change.value);
+
+    if (items.isEmpty()) {
+      return change;
+    } // Unwrap the items from their list
+
+
+    items.forEach(function (item) {
+      return change.unwrapNodeByKey(item.key, {
+        normalize: false
+      });
+    }); // Parent of the list of the items
+
+    var firstItem = items.first();
+    var parent = change.value.document.getParent(firstItem.key);
+    var index = parent.nodes.findIndex(function (node) {
+      return node.key === firstItem.key;
+    }); // Unwrap the items' children
+
+    items.forEach(function (item) {
+      item.nodes.forEach(function (node) {
+        change.moveNodeByKey(node.key, parent.key, index, {
+          normalize: false
+        });
+        index += 1;
+      });
+    }); // Finally, remove the now empty items
+
+    items.forEach(function (item) {
+      return change.removeNodeByKey(item.key, {
+        normalize: false
+      });
+    });
+    return change;
+  }.bind(_this, listOptions);
+
+  core.utils.getItemsAtRange = function (opts, value, range) {
+    range = range || value.selection;
+
+    if (!range.startKey) {
+      return _immutable["default"].List();
+    }
+
+    var document = value.document;
+    var startBlock = document.getClosestBlock(range.startKey);
+    var endBlock = document.getClosestBlock(range.endKey);
+
+    if (startBlock === endBlock) {
+      var item = core.utils.getCurrentItem(value, startBlock);
+      return item ? _immutable["default"].List([item]) : _immutable["default"].List();
+    }
+
+    var ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);
+
+    if (core.utils.isList(ancestor)) {
+      var startPath = ancestor.getPath(startBlock.key);
+      var endPath = ancestor.getPath(endBlock.key);
+      return ancestor.nodes.slice(startPath.get(0), endPath.get(0) + 1);
+    } else if (ancestor.type === opts.typeItem) {
+      // The ancestor is the highest list item that covers the range
+      return _immutable["default"].List([ancestor]);
+    } // No list of items can cover the range
+
+
+    return _immutable["default"].List();
+  }.bind(_this, listOptions);
+
+  core.utils.getListForItem = function (opts, value, item) {
+    var document = value.document;
+    var parent = document.getParent(item.key);
+    return parent && core.utils.isList(parent) ? parent : null;
+  }.bind(_this, listOptions);
+
+  core.utils.isSelectionInList = function (opts, value, type) {
+    var items = core.utils.getItemsAtRange(value);
+    return !items.isEmpty() && ( // Check the type of the list if needed
+    !type || core.utils.getListForItem(value, items.first()).get('type') === type);
+  }.bind(_this, listOptions);
+
+  return core;
+};
+
+var _default = function _default(options) {
+  var type = options.type,
+      icon = options.icon;
+  var core = createEditList(); // eslint-disable-next-line react/display-name
+
+  core.renderNode = function (props) {
+    var node = props.node,
+        attributes = props.attributes,
+        children = props.children;
+
+    switch (node.type) {
+      case 'ul_list':
+        return /*#__PURE__*/_react["default"].createElement("ul", attributes, children);
+
+      case 'ol_list':
+        return /*#__PURE__*/_react["default"].createElement("ol", attributes, children);
+
+      case 'list_item':
+        return /*#__PURE__*/_react["default"].createElement("li", attributes, children);
+    }
+  };
+
+  core.toolbar = {
+    isMark: false,
+    ariaLabel: type == 'ul_list' ? 'bulleted list' : 'numbered-list',
+    type: type,
+    icon: icon,
+    isActive: function isActive(value, type) {
+      if (!core.utils.isSelectionInList(value)) {
+        return false;
+      }
+
+      var current = core.utils.getCurrentList(value);
+      return current ? current.type === type : false;
+    },
+    onClick: function onClick(value, onChange) {
+      log('[onClick]', value);
+      var inList = core.utils.isSelectionInList(value);
+
+      if (inList) {
+        var change = value.change().call(core.changes.unwrapList);
+        onChange(change);
+      } else {
+        var _change = value.change().call(core.changes.wrapInList, type);
+
+        onChange(_change);
+      }
+    }
+  };
+
+  core.normalizeNode = function (node) {
+    if (node.object !== 'document' && node.object !== 'block') {
+      return undefined;
+    }
+
+    var response = core.validateNode(node);
+    var invalidListItems = [];
+    node.forEachDescendant(function (d) {
+      if (d.type === 'list_item' && d.nodes.size === 1 && d.nodes.first().object === 'text') {
+        // if we have a list_item that has only a text inside, we need to add a block in it
+        invalidListItems.push(d);
+      }
+    });
+
+    if (!invalidListItems.length && !response) {
+      return undefined;
+    }
+
+    return function (change) {
+      if (response) {
+        response(change);
+      }
+
+      if (invalidListItems.length) {
+        change.withoutNormalization(function () {
+          invalidListItems.forEach(function (node) {
+            var textNode = node.nodes.first();
+            var wrappedBlock = {
+              object: 'block',
+              type: 'div',
+              nodes: [textNode.toJSON()]
+            };
+            change.removeNodeByKey(textNode.key);
+            change.insertNodeByKey(node.key, 0, wrappedBlock);
+          });
+        });
+      }
+    };
+  };
+
+  core.renderNode.propTypes = {
+    node: _propTypes["default"].object,
+    attributes: _propTypes["default"].object,
+    children: _propTypes["default"].func
+  };
+  core.name = type;
+  return core;
+};
+
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/plugins/list/index.jsx"],"names":["log","b","type","next","childNodes","object","nodes","serialization","deserialize","el","name","tagName","toLowerCase","children","length","Array","from","serialize","createEditList","core","typeDefault","listOptions","ListOptions","schema","blocks","Object","keys","forEach","key","block","parent","types","getHighestSelectedBlocks","value","range","selection","document","startBlock","getClosestBlock","startKey","endBlock","endKey","Immutable","List","ancestor","getCommonAncestor","startPath","getPath","endPath","slice","get","changes","wrapInList","change","data","selectedBlocks","wrapBlock","Data","create","normalize","node","utils","isList","_ref","unwrapNodeByKey","wrapBlockByKey","unwrapList","opts","items","getItemsAtRange","isEmpty","item","firstItem","first","getParent","index","findIndex","moveNodeByKey","removeNodeByKey","bind","getCurrentItem","typeItem","getListForItem","isSelectionInList","options","icon","renderNode","props","attributes","toolbar","isMark","ariaLabel","isActive","current","getCurrentList","onClick","onChange","inList","call","normalizeNode","undefined","response","validateNode","invalidListItems","forEachDescendant","d","size","push","withoutNormalization","textNode","wrappedBlock","toJSON","insertNodeByKey","propTypes","PropTypes","func"],"mappings":"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","sourcesContent":["import React from 'react';\nimport { Data } from 'slate';\nimport Immutable from 'immutable';\nimport PropTypes from 'prop-types';\nimport EditList from 'slate-edit-list';\nimport ListOptions from 'slate-edit-list/dist/options';\nimport debug from 'debug';\n\nconst log = debug('@pie-lib:editable-html:plugins:list');\n\nconst b = (type, next, childNodes) => ({\n  object: 'block',\n  type,\n  nodes: next(childNodes),\n});\n\nexport const serialization = {\n  deserialize(el, next) {\n    const name = el.tagName.toLowerCase();\n\n    if (name === 'li') {\n      return b('list_item', next, el.childNodes);\n    }\n\n    if (name === 'ul') {\n      return b('ul_list', next, el.children.length ? Array.from(el.children) : el.childNodes);\n    }\n\n    if (name === 'ol') {\n      return b('ol_list', next, el.children.length ? Array.from(el.children) : el.childNodes);\n    }\n  },\n  serialize(object, children) {\n    if (object.object !== 'block') return;\n\n    if (object.type === 'list_item') {\n      return <li>{children}</li>;\n    }\n\n    if (object.type === 'ul_list') {\n      return <ul>{children}</ul>;\n    }\n\n    if (object.type === 'ol_list') {\n      return <ol>{children}</ol>;\n    }\n  },\n};\n\nconst createEditList = () => {\n  const core = EditList({\n    typeDefault: 'span',\n  });\n\n  const listOptions = new ListOptions({\n    typeDefault: 'span',\n  });\n\n  // fix outdated schema\n  if (core.schema && core.schema.blocks) {\n    Object.keys(core.schema.blocks).forEach((key) => {\n      const block = core.schema.blocks[key];\n\n      if (block.parent) {\n        return;\n      }\n\n      block.nodes[0] = { type: block.nodes[0].types[0] };\n    });\n  }\n\n  /**\n   * This override of the core.changes.wrapInList is needed because the version\n   * of immutable that we have does not support getting the element at a specific\n   * index with a square bracket (list[0]). We have to use the list.get function instead\n   */\n\n  /**\n   * Returns the highest list of blocks that cover the current selection\n   */\n  const getHighestSelectedBlocks = (value) => {\n    const range = value.selection;\n    const document = value.document;\n\n    const startBlock = document.getClosestBlock(range.startKey);\n    const endBlock = document.getClosestBlock(range.endKey);\n\n    if (startBlock === endBlock) {\n      return Immutable.List([startBlock]);\n    }\n\n    const ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);\n    const startPath = ancestor.getPath(startBlock.key);\n    const endPath = ancestor.getPath(endBlock.key);\n\n    return ancestor.nodes.slice(startPath.get(0), endPath.get(0) + 1);\n  };\n\n  /**\n   * Wrap the blocks in the current selection in a new list. Selected\n   * lists are merged together.\n   */\n  core.changes.wrapInList = function(change, type, data) {\n    const selectedBlocks = getHighestSelectedBlocks(change.value);\n\n    // Wrap in container\n    change.wrapBlock({ type: type, data: Data.create(data) }, { normalize: false });\n\n    // Wrap in list items\n    selectedBlocks.forEach(function(node) {\n      if (core.utils.isList(node)) {\n        // Merge its items with the created list\n        node.nodes.forEach(function(_ref) {\n          const key = _ref.key;\n          return change.unwrapNodeByKey(key, { normalize: false });\n        });\n      } else if (node.type !== 'list_item') {\n        change.wrapBlockByKey(node.key, 'list_item', {\n          normalize: false,\n        });\n      }\n    });\n\n    return change.normalize();\n  };\n\n  core.changes.unwrapList = function unwrapList(opts, change) {\n    const items = core.utils.getItemsAtRange(change.value);\n\n    if (items.isEmpty()) {\n      return change;\n    }\n\n    // Unwrap the items from their list\n    items.forEach((item) => change.unwrapNodeByKey(item.key, { normalize: false }));\n\n    // Parent of the list of the items\n    const firstItem = items.first();\n    const parent = change.value.document.getParent(firstItem.key);\n\n    let index = parent.nodes.findIndex((node) => node.key === firstItem.key);\n\n    // Unwrap the items' children\n    items.forEach((item) => {\n      item.nodes.forEach((node) => {\n        change.moveNodeByKey(node.key, parent.key, index, {\n          normalize: false,\n        });\n        index += 1;\n      });\n    });\n\n    // Finally, remove the now empty items\n    items.forEach((item) => change.removeNodeByKey(item.key, { normalize: false }));\n\n    return change;\n  }.bind(this, listOptions);\n\n  core.utils.getItemsAtRange = function(opts, value, range) {\n    range = range || value.selection;\n\n    if (!range.startKey) {\n      return Immutable.List();\n    }\n\n    const { document } = value;\n\n    const startBlock = document.getClosestBlock(range.startKey);\n    const endBlock = document.getClosestBlock(range.endKey);\n\n    if (startBlock === endBlock) {\n      const item = core.utils.getCurrentItem(value, startBlock);\n      return item ? Immutable.List([item]) : Immutable.List();\n    }\n\n    const ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);\n\n    if (core.utils.isList(ancestor)) {\n      const startPath = ancestor.getPath(startBlock.key);\n      const endPath = ancestor.getPath(endBlock.key);\n\n      return ancestor.nodes.slice(startPath.get(0), endPath.get(0) + 1);\n    } else if (ancestor.type === opts.typeItem) {\n      // The ancestor is the highest list item that covers the range\n      return Immutable.List([ancestor]);\n    }\n    // No list of items can cover the range\n    return Immutable.List();\n  }.bind(this, listOptions);\n\n  core.utils.getListForItem = function(opts, value, item) {\n    const { document } = value;\n    const parent = document.getParent(item.key);\n    return parent && core.utils.isList(parent) ? parent : null;\n  }.bind(this, listOptions);\n\n  core.utils.isSelectionInList = function(opts, value, type) {\n    const items = core.utils.getItemsAtRange(value);\n    return (\n      !items.isEmpty() &&\n      // Check the type of the list if needed\n      (!type || core.utils.getListForItem(value, items.first()).get('type') === type)\n    );\n  }.bind(this, listOptions);\n\n  return core;\n};\n\nexport default (options) => {\n  const { type, icon } = options;\n\n  const core = createEditList();\n\n  // eslint-disable-next-line react/display-name\n  core.renderNode = (props) => {\n    const { node, attributes, children } = props;\n\n    switch (node.type) {\n      case 'ul_list':\n        return <ul {...attributes}>{children}</ul>;\n      case 'ol_list':\n        return <ol {...attributes}>{children}</ol>;\n      case 'list_item':\n        return <li {...attributes}>{children}</li>;\n    }\n  };\n\n  core.toolbar = {\n    isMark: false,\n    ariaLabel: type == 'ul_list' ? 'bulleted list' : 'numbered-list',\n    type,\n    icon,\n    isActive: (value, type) => {\n      if (!core.utils.isSelectionInList(value)) {\n        return false;\n      }\n      const current = core.utils.getCurrentList(value);\n      return current ? current.type === type : false;\n    },\n    onClick: (value, onChange) => {\n      log('[onClick]', value);\n      const inList = core.utils.isSelectionInList(value);\n      if (inList) {\n        const change = value.change().call(core.changes.unwrapList);\n        onChange(change);\n      } else {\n        const change = value.change().call(core.changes.wrapInList, type);\n        onChange(change);\n      }\n    },\n  };\n\n  core.normalizeNode = (node) => {\n    if (node.object !== 'document' && node.object !== 'block') {\n      return undefined;\n    }\n\n    const response = core.validateNode(node);\n\n    const invalidListItems = [];\n\n    node.forEachDescendant((d) => {\n      if (d.type === 'list_item' && d.nodes.size === 1 && d.nodes.first().object === 'text') {\n        // if we have a list_item that has only a text inside, we need to add a block in it\n        invalidListItems.push(d);\n      }\n    });\n\n    if (!invalidListItems.length && !response) {\n      return undefined;\n    }\n\n    return (change) => {\n      if (response) {\n        response(change);\n      }\n\n      if (invalidListItems.length) {\n        change.withoutNormalization(() => {\n          invalidListItems.forEach((node) => {\n            const textNode = node.nodes.first();\n            const wrappedBlock = {\n              object: 'block',\n              type: 'div',\n              nodes: [textNode.toJSON()],\n            };\n\n            change.removeNodeByKey(textNode.key);\n\n            change.insertNodeByKey(node.key, 0, wrappedBlock);\n          });\n        });\n      }\n    };\n  };\n\n  core.renderNode.propTypes = {\n    node: PropTypes.object,\n    attributes: PropTypes.object,\n    children: PropTypes.func,\n  };\n  core.name = type;\n\n  return core;\n};\n"]}