@opentiny/vue-renderless 3.1.0-alpha.0 → 3.4.7

package/rich-text/table-module.js

@@ -0,0 +1,557 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _get from "@babel/runtime/helpers/get";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+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 _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; } }
+import { random } from '@opentiny/vue-renderless/common/string';
+import { isNull } from '@opentiny/vue-renderless/common/type';
+function cellName() {
+  return random().toString(36).slice(2);
+}
+function addMatcherTable(_ref) {
+  var _quill = _ref._quill,
+    oper = _ref.oper;
+  _quill.clipboard.addMatcher('TABLE', function (node, delta) {
+    var id = cellName();
+    oper.setTableId(id);
+    return delta;
+  });
+}
+function addMatcherTr(_ref2) {
+  var _quill = _ref2._quill,
+    oper = _ref2.oper;
+  _quill.clipboard.addMatcher('TR', function (node, delta) {
+    var id = cellName();
+    oper.setRowId(id);
+    return delta;
+  });
+}
+function addMatcherTd(_ref3) {
+  var _quill = _ref3._quill,
+    oper = _ref3.oper,
+    Delta = _ref3.Delta;
+  _quill.clipboard.addMatcher('TD', function (node, delta) {
+    var tableId = oper.getTableId();
+    var rowId = oper.getRowId();
+    var cellId = cellName();
+    if (delta.ops.length) {
+      var lastOp = delta.ops[delta.ops.length - 1];
+      if (typeof lastOp.insert === 'string' && !lastOp.insert.endsWith('\n')) {
+        lastOp.insert += '\n';
+      }
+    } else {
+      delta.insert('\n');
+    }
+    var attributes = {
+      td: tableId + '|' + rowId + '|' + cellId
+    };
+    if (node.rowSpan) {
+      attributes.rowSpan = node.rowSpan;
+    }
+    if (node.colSpan) {
+      attributes.colSpan = node.colSpan;
+    }
+    if (node.width) {
+      attributes.width = node.width;
+    }
+    if (node.height) {
+      attributes.height = node.height;
+    }
+    return delta.compose(new Delta().retain(delta.length(), attributes));
+  });
+}
+function addMatcher3(_quill) {
+  _quill.clipboard.addMatcher(3, function (node, delta) {
+    if (['TABLE', 'TR'].indexOf(node.parentNode.tagName) !== -1) {
+      return {
+        ops: []
+      };
+    } else {
+      return delta;
+    }
+  });
+}
+function addMatcherFont(_quill) {
+  _quill.clipboard.addMatcher('FONT', function (node, delta) {
+    if (node.innerText === '') {
+      return {
+        ops: []
+      };
+    } else {
+      return delta;
+    }
+  });
+}
+function addMatcher(_ref4) {
+  var _quill = _ref4.qil,
+    Delta = _ref4.Delta;
+  var tableId = cellName();
+  var rowId = cellName();
+  var oper = {
+    getTableId: function getTableId() {
+      return tableId;
+    },
+    setTableId: function setTableId(id) {
+      tableId = id;
+    },
+    getRowId: function getRowId() {
+      return rowId;
+    },
+    setRowId: function setRowId(id) {
+      rowId = id;
+    }
+  };
+  addMatcherTable({
+    _quill: _quill,
+    oper: oper
+  });
+  addMatcherTr({
+    _quill: _quill,
+    oper: oper
+  });
+  addMatcherTd({
+    _quill: _quill,
+    oper: oper,
+    Delta: Delta
+  });
+  addMatcher3(_quill);
+  addMatcherFont(_quill);
+}
+var quill = Object.create(null);
+function setQuill(q) {
+  quill = q;
+}
+function getQuill() {
+  return quill;
+}
+function getLeafFromQuill() {
+  var q = getQuill();
+  return q ? q.getLeaf(q.getSelection().index) : [];
+}
+function provideTableTrick(_ref5) {
+  var Parchment = _ref5.Parchment;
+  var TableTrick = function () {
+    function TableTrick() {
+      _classCallCheck(this, TableTrick);
+    }
+    _createClass(TableTrick, null, [{
+      key: "findTd",
+      value: function findTd(what) {
+        var leaf = getLeafFromQuill();
+        var blot = leaf[0];
+        while (!isNull(blot) && blot.statics.blotName !== what) {
+          blot = blot.parent;
+        }
+        return blot;
+      }
+    }, {
+      key: "appendCol",
+      value: function appendCol() {
+        var td = TableTrick.findTd('td');
+        if (td) {
+          var table = td.parent.parent;
+          var tableId = table.domNode.getAttribute('table_id');
+          td.parent.parent.children.forEach(function (tr) {
+            var rowId = tr.domNode.getAttribute('row_id');
+            var cellId = cellName();
+            var tdNew = Parchment.create('td', tableId + '|' + rowId + '|' + cellId);
+            tr.appendChild(tdNew);
+          });
+        }
+      }
+    }, {
+      key: "appendRow",
+      value: function appendRow() {
+        var td = TableTrick.findTd('td');
+        if (td) {
+          var colCount = td.parent.children.length;
+          var table = td.parent.parent;
+          var newRow = td.parent.clone();
+          var tableId = table.domNode.getAttribute('table_id');
+          var rowId = cellName();
+          newRow.domNode.setAttribute('row_id', rowId);
+          for (var i = colCount - 1; i >= 0; i--) {
+            var cellId = cellName();
+            var tdNew = Parchment.create('td', tableId + '|' + rowId + '|' + cellId);
+            newRow.appendChild(tdNew);
+          }
+          table.appendChild(newRow);
+        }
+      }
+    }]);
+    return TableTrick;
+  }();
+  return {
+    TableTrick: TableTrick
+  };
+}
+function createTable(_ref6) {
+  var value = _ref6.value,
+    Container = _ref6.Container,
+    Parchment = _ref6.Parchment,
+    Scroll = _ref6.Scroll;
+  var node = null;
+  var sizes = value.split('_');
+  var rowCount = Number.parseInt(sizes[1]);
+  var colCount = Number.parseInt(sizes[2]);
+  var tableId = cellName();
+  var table = Parchment.create('table', tableId);
+  for (var ri = 0; ri < rowCount; ri++) {
+    var rowId = cellName();
+    var tr = Parchment.create('tr', rowId);
+    table.appendChild(tr);
+    for (var ci = 0; ci < colCount; ci++) {
+      var cellId = cellName();
+      value = tableId + '|' + rowId + '|' + cellId;
+      var td = Parchment.create('td', value);
+      var p = Parchment.create('block');
+      var br = Parchment.create('break');
+      tr.appendChild(td);
+      td.appendChild(p);
+      p.appendChild(br);
+      node = p;
+    }
+  }
+  var leaf = getLeafFromQuill();
+  var blot = leaf[0];
+  var topBranch = null;
+  while (!isNull(blot) && !(blot instanceof Container || blot instanceof Scroll)) {
+    topBranch = blot;
+    blot = blot.parent;
+  }
+  blot && blot.insertBefore(table, topBranch);
+  return node;
+}
+function provideTable(_ref7) {
+  var Container = _ref7.Container,
+    Parchment = _ref7.Parchment,
+    Scroll = _ref7.Scroll,
+    TableTrick = _ref7.TableTrick,
+    TableRow = _ref7.TableRow;
+  var Table = function (_Container) {
+    _inherits(Table, _Container);
+    var _super = _createSuper(Table);
+    function Table() {
+      _classCallCheck(this, Table);
+      return _super.apply(this, arguments);
+    }
+    _createClass(Table, [{
+      key: "optimize",
+      value: function optimize() {
+        _get(_getPrototypeOf(Table.prototype), "optimize", this).call(this);
+        var next = this.next;
+        if (!isNull(next) && next.prev === this && next.statics.blotName === this.statics.blotName && next.domNode.tagName === this.domNode.tagName && next.domNode.getAttribute('table_id') === this.domNode.getAttribute('table_id')) {
+          next.moveChildren(this);
+          next.remove();
+        }
+      }
+    }], [{
+      key: "create",
+      value: function create(value) {
+        if (value === 'append-row') {
+          return TableTrick.appendRow();
+        } else if (value === 'append-col') {
+          return TableTrick.appendCol();
+        } else if (value.includes('newtable_')) {
+          return createTable({
+            value: value,
+            Container: Container,
+            Parchment: Parchment,
+            Scroll: Scroll
+          });
+        } else {
+          var tagName = 'table';
+          var node = _get(_getPrototypeOf(Table), "create", this).call(this, tagName);
+          node.setAttribute('table_id', value);
+          return node;
+        }
+      }
+    }]);
+    return Table;
+  }(Container);
+  Table.blotName = 'table';
+  Table.tagName = 'table';
+  Table.scope = Parchment.Scope.BLOCK_BLOT;
+  Table.defaultChild = 'tr';
+  Table.allowedChildren = [TableRow];
+  return {
+    Table: Table
+  };
+}
+function provideTableModule(_ref8) {
+  var Container = _ref8.Container,
+    Parchment = _ref8.Parchment,
+    Module = _ref8.Module,
+    Quill = _ref8.Quill,
+    Scroll = _ref8.Scroll,
+    Delta = _ref8.Delta,
+    ContainBlot = _ref8.ContainBlot,
+    TableRow = _ref8.TableRow,
+    TableCell = _ref8.TableCell;
+  var _provideTableTrick = provideTableTrick({
+      Parchment: Parchment
+    }),
+    TableTrick = _provideTableTrick.TableTrick;
+  var _provideTable = provideTable({
+      Container: Container,
+      Parchment: Parchment,
+      Scroll: Scroll,
+      TableTrick: TableTrick,
+      TableRow: TableRow
+    }),
+    Table = _provideTable.Table;
+  var TableModule = function (_Module) {
+    _inherits(TableModule, _Module);
+    var _super2 = _createSuper(TableModule);
+    function TableModule(qil, opt) {
+      var _this;
+      _classCallCheck(this, TableModule);
+      _this = _super2.call(this, qil, opt);
+      addMatcher({
+        qil: qil,
+        Delta: Delta
+      });
+      setQuill(qil);
+      return _this;
+    }
+    _createClass(TableModule, null, [{
+      key: "register",
+      value: function register() {
+        Quill.register(ContainBlot, true);
+        Quill.register(TableRow, true);
+        Quill.register(Table, true);
+        Quill.register(TableCell, true);
+      }
+    }]);
+    return TableModule;
+  }(Module);
+  return {
+    TableModule: TableModule
+  };
+}
+function provideContainBlot(_ref9) {
+  var Container = _ref9.Container,
+    Parchment = _ref9.Parchment,
+    Block = _ref9.Block,
+    BlockEmbed = _ref9.BlockEmbed;
+  var ContainBlot = function (_Container2) {
+    _inherits(ContainBlot, _Container2);
+    var _super3 = _createSuper(ContainBlot);
+    function ContainBlot() {
+      _classCallCheck(this, ContainBlot);
+      return _super3.apply(this, arguments);
+    }
+    _createClass(ContainBlot, [{
+      key: "insertBefore",
+      value: function insertBefore(blot, ref) {
+        if (blot.statics.blotName === this.statics.blotName) {
+          _get(_getPrototypeOf(ContainBlot.prototype), "insertBefore", this).call(this, blot.children.head, ref);
+        } else {
+          _get(_getPrototypeOf(ContainBlot.prototype), "insertBefore", this).call(this, blot, ref);
+        }
+      }
+    }, {
+      key: "formats",
+      value: function formats() {
+        return _defineProperty({}, this.statics.blotName, this.statics.formats(this.domNode));
+      }
+    }, {
+      key: "replace",
+      value: function replace(target) {
+        if (target.statics.blotName !== this.statics.blotName) {
+          var item = Parchment.create(this.statics.defaultChild);
+          target.moveChildren(item);
+          this.appendChild(item);
+        }
+        if (isNull(target.parent)) {
+          return;
+        }
+        _get(_getPrototypeOf(ContainBlot.prototype), "replace", this).call(this, target);
+      }
+    }], [{
+      key: "create",
+      value: function create() {
+        return _get(_getPrototypeOf(ContainBlot), "create", this).call(this, 'contain');
+      }
+    }, {
+      key: "formats",
+      value: function formats(domNode) {
+        return domNode.tagName;
+      }
+    }]);
+    return ContainBlot;
+  }(Container);
+  ContainBlot.blotName = 'contain';
+  ContainBlot.tagName = 'contain';
+  ContainBlot.scope = Parchment.Scope.BLOCK_BLOT;
+  ContainBlot.defaultChild = 'block';
+  ContainBlot.allowedChildren = [Block, BlockEmbed, Container];
+  return {
+    ContainBlot: ContainBlot
+  };
+}
+function provideTableRow(_ref11) {
+  var Container = _ref11.Container,
+    Parchment = _ref11.Parchment;
+  var TableRow = function (_Container3) {
+    _inherits(TableRow, _Container3);
+    var _super4 = _createSuper(TableRow);
+    function TableRow() {
+      _classCallCheck(this, TableRow);
+      return _super4.apply(this, arguments);
+    }
+    _createClass(TableRow, [{
+      key: "optimize",
+      value: function optimize() {
+        _get(_getPrototypeOf(TableRow.prototype), "optimize", this).call(this);
+        var next = this.next;
+        if (!isNull(next) && next.prev === this && next.statics.blotName === this.statics.blotName && next.domNode.tagName === this.domNode.tagName && next.domNode.getAttribute('row_id') === this.domNode.getAttribute('row_id')) {
+          next.moveChildren(this);
+          next.remove();
+        }
+      }
+    }], [{
+      key: "create",
+      value: function create(value) {
+        var node = _get(_getPrototypeOf(TableRow), "create", this).call(this, 'tr');
+        node.setAttribute('row_id', value);
+        return node;
+      }
+    }]);
+    return TableRow;
+  }(Container);
+  TableRow.blotName = 'tr';
+  TableRow.tagName = 'tr';
+  TableRow.scope = Parchment.Scope.BLOCK_BLOT;
+  TableRow.defaultChild = 'td';
+  return {
+    TableRow: TableRow
+  };
+}
+function setAttrs(_ref12) {
+  var node = _ref12.node,
+    value = _ref12.value;
+  var ids = value.split('|');
+  node.setAttribute('table_id', ids[0]);
+  node.setAttribute('row_id', ids[1]);
+  node.setAttribute('cell_id', ids[2]);
+  return node;
+}
+function provideTableCell(_ref13) {
+  var Container = _ref13.Container,
+    Parchment = _ref13.Parchment,
+    Block = _ref13.Block,
+    BlockEmbed = _ref13.BlockEmbed,
+    ContainBlot = _ref13.ContainBlot;
+  var TableCell = function (_ContainBlot) {
+    _inherits(TableCell, _ContainBlot);
+    var _super5 = _createSuper(TableCell);
+    function TableCell() {
+      _classCallCheck(this, TableCell);
+      return _super5.apply(this, arguments);
+    }
+    _createClass(TableCell, [{
+      key: "formatAt",
+      value: function formatAt(index, length, name, value) {
+        _get(_getPrototypeOf(TableCell.prototype), "formatAt", this).call(this, index, length, name, value);
+        var attrWhitelist = ['colSpan', 'rowSpan', 'width', 'height'];
+        attrWhitelist.indexOf(name) !== -1 && this.domNode.setAttribute(name, value);
+      }
+    }, {
+      key: "formats",
+      value: function formats() {
+        var domNode = this.domNode;
+        var blotName = this.statics.blotName;
+        var attr = function attr(domNode, _attr) {
+          return domNode.getAttribute(_attr);
+        };
+        return _defineProperty({}, blotName, "".concat(attr(domNode, 'table_id'), "|").concat(attr(domNode, 'row_id'), "|").concat(attr(domNode, 'row_id')));
+      }
+    }, {
+      key: "optimize",
+      value: function optimize() {
+        _get(_getPrototypeOf(TableCell.prototype), "optimize", this).call(this);
+        if (!isNull(this.parent) && this.parent.statics.blotName !== 'tr') {
+          var mark = Parchment.create('block');
+          this.parent.insertBefore(mark, this.next);
+          var table = Parchment.create('table', this.domNode.getAttribute('table_id'));
+          var tr = Parchment.create('tr', this.domNode.getAttribute('row_id'));
+          table.appendChild(tr);
+          tr.appendChild(this);
+          table.replace(mark);
+        }
+        if (!isNull(this.next) && this.next.prev === this && this.next.statics.blotName === this.statics.blotName && this.next.domNode.tagName === this.domNode.tagName && this.next.domNode.getAttribute('cell_id') === this.domNode.getAttribute('cell_id')) {
+          this.next.moveChildren(this);
+          this.next.remove();
+        }
+      }
+    }], [{
+      key: "create",
+      value: function create(value) {
+        return setAttrs({
+          node: _get(_getPrototypeOf(TableCell), "create", this).call(this, 'td'),
+          value: value
+        });
+      }
+    }]);
+    return TableCell;
+  }(ContainBlot);
+  TableCell.blotName = 'td';
+  TableCell.tagName = 'td';
+  TableCell.scope = Parchment.Scope.BLOCK_BLOT;
+  TableCell.defaultChild = 'block';
+  TableCell.allowedChildren = [Block, BlockEmbed, Container];
+  return {
+    TableCell: TableCell
+  };
+}
+function tableModule(Quill) {
+  var Container = Quill["import"]('blots/container');
+  var Scroll = Quill["import"]('blots/scroll');
+  var Module = Quill["import"]('core/module');
+  var Block = Quill["import"]('blots/block');
+  var Delta = Quill["import"]('delta');
+  var Parchment = Quill["import"]('parchment');
+  var BlockEmbed = Quill["import"]('blots/block/embed');
+  var _provideContainBlot = provideContainBlot({
+      Container: Container,
+      Parchment: Parchment,
+      Block: Block,
+      BlockEmbed: BlockEmbed
+    }),
+    ContainBlot = _provideContainBlot.ContainBlot;
+  var _provideTableRow = provideTableRow({
+      Container: Container,
+      Parchment: Parchment
+    }),
+    TableRow = _provideTableRow.TableRow;
+  var _provideTableCell = provideTableCell({
+      Container: Container,
+      Parchment: Parchment,
+      Block: Block,
+      BlockEmbed: BlockEmbed,
+      ContainBlot: ContainBlot
+    }),
+    TableCell = _provideTableCell.TableCell;
+  var params = {
+    Container: Container,
+    Parchment: Parchment,
+    Module: Module,
+    Quill: Quill,
+    Scroll: Scroll,
+    Delta: Delta,
+    ContainBlot: ContainBlot,
+    TableRow: TableRow,
+    TableCell: TableCell
+  };
+  var _provideTableModule = provideTableModule(params),
+    TableModule = _provideTableModule.TableModule;
+  TableRow.allowedChildren = [TableCell];
+  Container.order = ['list', 'contain', 'td', 'tr', 'table'];
+  Quill.register('modules/tableModule', TableModule, true);
+}
+export default tableModule;

package/rich-text/vue.js

@@ -0,0 +1,149 @@
+import { initContent, initQuill, setToolbarTips, getFileUploadUrl, selectionChange, textChange, mounted, beforeUnmount } from './index';
+export var api = ['state', 'initContent', 'initQuill', 'setToolbarTips', 'selectionChange', 'textChange'];
+var initState = function initState(_ref) {
+  var reactive = _ref.reactive,
+    props = _ref.props;
+  var state = reactive({
+    innerOptions: {},
+    innerContent: '',
+    fileUploadUrl: props.fileUpload && props.fileUpload.url || '',
+    content: props.modelValue || props.content
+  });
+  return state;
+};
+var initApi = function initApi(args) {
+  var api = args.api,
+    props = args.props,
+    state = args.state,
+    refs = args.refs,
+    emit = args.emit,
+    service = args.service,
+    ImageDrop = args.ImageDrop;
+  var FileUpload = args.FileUpload,
+    ImageUpload = args.ImageUpload,
+    Quill = args.Quill,
+    t = args.t,
+    vm = args.vm,
+    i18n = args.i18n,
+    watch = args.watch;
+  Object.assign(api, {
+    state: state,
+    initContent: initContent({
+      state: state
+    }),
+    initQuill: initQuill({
+      service: service,
+      emit: emit,
+      props: props,
+      api: api,
+      state: state,
+      refs: refs,
+      ImageDrop: ImageDrop,
+      FileUpload: FileUpload,
+      ImageUpload: ImageUpload,
+      Quill: Quill
+    }),
+    setToolbarTips: setToolbarTips({
+      refs: refs,
+      t: t,
+      vm: vm
+    }),
+    getFileUploadUrl: getFileUploadUrl({
+      service: service
+    }),
+    selectionChange: selectionChange({
+      emit: emit,
+      state: state
+    }),
+    textChange: textChange({
+      emit: emit,
+      refs: refs,
+      state: state
+    }),
+    mounted: mounted({
+      api: api,
+      props: props,
+      state: state,
+      i18n: i18n,
+      watch: watch
+    }),
+    beforeUnmount: beforeUnmount({
+      api: api,
+      state: state
+    })
+  });
+};
+var initWatch = function initWatch(_ref2) {
+  var watch = _ref2.watch,
+    props = _ref2.props,
+    api = _ref2.api,
+    state = _ref2.state;
+  watch(function () {
+    return props.modelValue;
+  }, function (value) {
+    state.content = value;
+    state.content && api.initContent();
+  });
+  watch(function () {
+    return props.content;
+  }, function (value) {
+    state.content = value;
+    state.content && api.initContent();
+  });
+  watch(function () {
+    return props.disabled;
+  }, function (param) {
+    if (state.quill) {
+      state.quill.enable(!param);
+    }
+  });
+};
+export var renderless = function renderless(props, _ref3, _ref4, _ref5) {
+  var reactive = _ref3.reactive,
+    watch = _ref3.watch,
+    onMounted = _ref3.onMounted,
+    onBeforeUnmount = _ref3.onBeforeUnmount;
+  var service = _ref4.service,
+    emit = _ref4.emit,
+    refs = _ref4.refs,
+    t = _ref4.t,
+    vm = _ref4.vm,
+    i18n = _ref4.i18n;
+  var Quill = _ref5.Quill,
+    ImageDrop = _ref5.ImageDrop,
+    ImageUpload = _ref5.ImageUpload,
+    FileUpload = _ref5.FileUpload;
+  var api = {};
+  var state = initState({
+    reactive: reactive,
+    props: props
+  });
+  var args = {
+    api: api,
+    props: props,
+    state: state,
+    refs: refs,
+    emit: emit,
+    service: service,
+    ImageDrop: ImageDrop
+  };
+  Object.assign(args, {
+    FileUpload: FileUpload,
+    ImageUpload: ImageUpload,
+    Quill: Quill,
+    t: t,
+    vm: vm,
+    i18n: i18n,
+    watch: watch
+  });
+  initApi(args);
+  initWatch({
+    watch: watch,
+    props: props,
+    api: api,
+    state: state
+  });
+  onMounted(api.mounted);
+  onBeforeUnmount(api.beforeUnmount);
+  return api;
+};