@opentiny/vue-renderless 3.13.2 → 3.14.1

package/rich-text/module/image-drop.js

@@ -0,0 +1,63 @@
+import "../../chunk-G2ADBYYC.js";
+const ImageDrop = function(quill) {
+  this.quill = quill;
+  this.handleDrop = this.handleDrop.bind(this);
+  this.handlePaste = this.handlePaste.bind(this);
+  this.quill.root.addEventListener("drop", this.handleDrop, false);
+  this.quill.root.addEventListener("paste", this.handlePaste, false);
+};
+ImageDrop.prototype.handleDrop = function(event) {
+  event.preventDefault();
+  if (event.dataTransfer && event.dataTransfer.files && event.dataTransfer.files.length) {
+    if (document.caretRangeFromPoint) {
+      const selection = document.getSelection();
+      const range = document.caretRangeFromPoint(event.clientX, event.clientY);
+      if (selection && range) {
+        selection.setBaseAndExtent(range.startContainer, range.startOffset, range.startContainer, range.startOffset);
+      }
+    }
+    this.readFiles(event.dataTransfer.files, this.insert.bind(this));
+  }
+};
+ImageDrop.prototype.handlePaste = function(e) {
+  if (e.clipboardData && e.clipboardData.items && e.clipboardData.items.length) {
+    this.readFiles(
+      e.clipboardData.items,
+      function(dataUrl) {
+        const selection = this.quill.getSelection();
+        if (!selection) {
+          setTimeout(
+            function() {
+              this.insert(dataUrl);
+            }.bind(this),
+            0
+          );
+        }
+      }.bind(this)
+    );
+  }
+};
+ImageDrop.prototype.insert = function(dataUrl) {
+  const index = (this.quill.getSelection() || {}).index || this.quill.getLength();
+  this.quill.insertEmbed(index, "image", dataUrl, "user");
+};
+ImageDrop.prototype.readFiles = function(files, callback) {
+  ;
+  [].forEach.call(files, function(file) {
+    if (!file.type.match(/^image\/(gif|jpe?g|a?png|svg|webp|bmp|vnd\.microsoft\.icon)/i)) {
+      return;
+    }
+    const reader = new FileReader();
+    reader.onload = function(e) {
+      callback(e.target.result);
+    };
+    const blob = file.getAsFile ? file.getAsFile() : file;
+    if (blob instanceof Blob) {
+      reader.readAsDataURL(blob);
+    }
+  });
+};
+var image_drop_default = ImageDrop;
+export {
+  image_drop_default as default
+};

package/rich-text/module/image-upload.js

@@ -0,0 +1,89 @@
+import "../../chunk-G2ADBYYC.js";
+import { xss } from "../../common/xss";
+const ImageUpload = function(quill, options) {
+  this.quill = quill;
+  this.options = options || {};
+  this.quill.getModule("toolbar").addHandler("image", this.selectLocalImage.bind(this));
+};
+ImageUpload.prototype.selectLocalImage = function() {
+  const input = document.createElement("input");
+  input.setAttribute("type", "file");
+  input.click();
+  input.onchange = function() {
+    const file = input.files[0];
+    if (/^image\//.test(file.type)) {
+      const checkBeforeSend = this.options.checkBeforeSend || this.checkBeforeSend.bind(this);
+      checkBeforeSend(file, this.sendToServer.bind(this));
+    } else {
+      throw new Error("You could only upload images.");
+    }
+  }.bind(this);
+};
+ImageUpload.prototype.checkBeforeSend = function(file, next) {
+  next(file);
+};
+ImageUpload.prototype.sendToServer = function(file) {
+  if (this.options.customUploader) {
+    this.options.customUploader(
+      file,
+      function(dataUrl) {
+        this.insert(dataUrl);
+      }.bind(this)
+    );
+  } else {
+    const url = xss.filterUrl(this.options.url);
+    const method = this.options.method || "POST";
+    const name = this.options.name || "image";
+    const headers = this.options.headers || {};
+    const callbackOK = this.options.success || this.uploadImageCallbackOK.bind(this);
+    const callbackKO = this.options.fail || this.uploadImageCallbackKO.bind(this);
+    if (url) {
+      const fd = new FormData();
+      fd.append(name, file);
+      if (this.options.csrf) {
+        fd.append(this.options.csrf.token, this.options.csrf.hash);
+      }
+      const xmlHttpRequest = new XMLHttpRequest();
+      xmlHttpRequest.open(method, url, true);
+      for (let index in headers) {
+        xmlHttpRequest.setRequestHeader(index, headers[index]);
+      }
+      xmlHttpRequest.onload = function() {
+        if (xmlHttpRequest.status === 200 || xmlHttpRequest.status === 201) {
+          callbackOK(JSON.parse(xmlHttpRequest.responseText), this.insert.bind(this));
+        } else {
+          callbackKO({
+            code: xmlHttpRequest.status,
+            type: xmlHttpRequest.statusText,
+            body: xmlHttpRequest.responseText
+          });
+        }
+      }.bind(this);
+      if (this.options.withCredentials) {
+        xmlHttpRequest.withCredentials = true;
+      }
+      xmlHttpRequest.send(fd);
+    } else {
+      const reader = new FileReader();
+      reader.onload = function(event) {
+        callbackOK(event.target.result, this.insert.bind(this));
+      }.bind(this);
+      reader.readAsDataURL(file);
+    }
+  }
+};
+ImageUpload.prototype.insert = function(dataUrl) {
+  const index = (this.quill.getSelection() || {}).index || this.quill.getLength();
+  this.quill.insertEmbed(index, "image", dataUrl, "user");
+  this.quill.setSelection(index + 1);
+};
+ImageUpload.prototype.uploadImageCallbackOK = function(response, next) {
+  next(response);
+};
+ImageUpload.prototype.uploadImageCallbackKO = function(error) {
+  throw new Error(error);
+};
+var image_upload_default = ImageUpload;
+export {
+  image_upload_default as default
+};

package/rich-text/options.js

@@ -0,0 +1,141 @@
+import "../chunk-G2ADBYYC.js";
+const size = ["small", false, "large", "huge"];
+const underline = ["bold", "italic", "underline", "strike"];
+const media = ["link", "image", "video", "file"];
+const header = [{ header: [1, 2, 3, 4, 5, 6, false] }];
+const script = [{ script: "sub" }, { script: "super" }];
+const defaultOptions = {
+  theme: "snow",
+  boundary: document.body,
+  modules: {
+    tableModule: true,
+    toolbar: {
+      container: [
+        underline,
+        ["blockquote", "code-block"],
+        [{ header: 1 }, { header: 2 }],
+        [{ list: "ordered" }, { list: "bullet" }],
+        script,
+        [{ indent: "-1" }, { indent: "+1" }],
+        [{ direction: "rtl" }],
+        [{ size }],
+        header,
+        [{ color: [] }, { background: [] }],
+        [{ font: [] }],
+        [{ align: [] }],
+        ["clean"],
+        media
+      ],
+      handlers: {
+        file(value) {
+          if (!value) {
+            this.quill.format("file", false);
+          }
+        }
+      }
+    },
+    clipboard: { matchVisual: false }
+  },
+  placeholder: "Insert text here ...",
+  readOnly: false
+};
+const getToolbarTips = (t) => [
+  { Choice: ".ql-bold", title: t("ui.richText.bold") },
+  { Choice: ".ql-italic", title: t("ui.richText.italic") },
+  { Choice: ".ql-underline", title: t("ui.richText.underline") },
+  { Choice: ".ql-header", title: t("ui.richText.header") },
+  { Choice: ".ql-strike", title: t("ui.richText.strike") },
+  { Choice: ".ql-blockquote", title: t("ui.richText.blockquote") },
+  { Choice: ".ql-code-block", title: t("ui.richText.codeBlock") },
+  { Choice: ".ql-size", title: t("ui.richText.size") },
+  { Choice: '.ql-list[value="ordered"]', title: t("ui.richText.listOrdered") },
+  { Choice: '.ql-list[value="bullet"]', title: t("ui.richText.listBullet") },
+  { Choice: '.ql-header[value="1"]', title: t("ui.richText.header1") },
+  { Choice: '.ql-header[value="2"]', title: t("ui.richText.header2") },
+  { Choice: ".ql-align", title: t("ui.richText.align") },
+  { Choice: ".ql-color", title: t("ui.richText.color") },
+  { Choice: ".ql-background", title: t("ui.richText.background") },
+  { Choice: ".ql-image", title: t("ui.richText.image") },
+  { Choice: ".ql-video", title: t("ui.richText.video") },
+  { Choice: ".ql-link", title: t("ui.richText.link") },
+  { Choice: ".ql-formula", title: t("ui.richText.formula") },
+  { Choice: ".ql-clean", title: t("ui.richText.clean") },
+  { Choice: '.ql-indent[value="-1"]', title: t("ui.richText.indent1") },
+  { Choice: '.ql-indent[value="+1"]', title: t("ui.richText.indent2") },
+  {
+    Choice: ".ql-header .ql-picker-label",
+    title: t("ui.richText.pickerLabel")
+  },
+  {
+    Choice: '.ql-header .ql-picker-item[data-value="1"]',
+    title: t("ui.richText.headerPicker1")
+  },
+  {
+    Choice: '.ql-header .ql-picker-item[data-value="2"]',
+    title: t("ui.richText.headerPicker2")
+  },
+  {
+    Choice: '.ql-header .ql-picker-item[data-value="3"]',
+    title: t("ui.richText.headerPicker3")
+  },
+  {
+    Choice: '.ql-header .ql-picker-item[data-value="4"]',
+    title: t("ui.richText.headerPicker4")
+  },
+  {
+    Choice: '.ql-header .ql-picker-item[data-value="5"]',
+    title: t("ui.richText.headerPicker5")
+  },
+  {
+    Choice: '.ql-header .ql-picker-item[data-value="6"]',
+    title: t("ui.richText.headerPicker6")
+  },
+  {
+    Choice: ".ql-header .ql-picker-item:last-child",
+    title: t("ui.richText.normal")
+  },
+  {
+    Choice: '.ql-size .ql-picker-item[data-value="small"]',
+    title: t("ui.richText.sizeSmall")
+  },
+  {
+    Choice: '.ql-size .ql-picker-item[data-value="large"]',
+    title: t("ui.richText.sizeLarge")
+  },
+  {
+    Choice: '.ql-size .ql-picker-item[data-value="huge"]',
+    title: t("ui.richText.sizeHuge")
+  },
+  {
+    Choice: ".ql-size .ql-picker-item:nth-child(2)",
+    title: t("ui.richText.normal")
+  },
+  {
+    Choice: ".ql-align .ql-picker-item:first-child",
+    title: t("ui.richText.alignPicker1")
+  },
+  {
+    Choice: '.ql-align .ql-picker-item[data-value="center"]',
+    title: t("ui.richText.alignPicker2")
+  },
+  {
+    Choice: '.ql-align .ql-picker-item[data-value="right"]',
+    title: t("ui.richText.alignPicker3")
+  },
+  {
+    Choice: '.ql-align .ql-picker-item[data-value="justify"]',
+    title: t("ui.richText.alignPicker4")
+  },
+  { Choice: '.ql-script[value="sub"]', title: t("ui.richText.subScript") },
+  { Choice: '.ql-script[value="super"]', title: t("ui.richText.superScript") },
+  {
+    Choice: '.ql-direction[value="rtl"]',
+    title: t("ui.richText.directionRTL")
+  },
+  { Choice: ".ql-font", title: t("ui.richText.font") },
+  { Choice: ".ql-file", title: t("ui.richText.file") }
+];
+export {
+  defaultOptions,
+  getToolbarTips
+};

package/rich-text/table-module.js

@@ -0,0 +1,382 @@
+import "../chunk-G2ADBYYC.js";
+import { random } from "../common/string";
+import { isNull } from "../common/type";
+function cellName() {
+  return random().toString(36).slice(2);
+}
+function addMatcherTable({ _quill, oper }) {
+  _quill.clipboard.addMatcher("TABLE", function(node, delta) {
+    const id = cellName();
+    oper.setTableId(id);
+    return delta;
+  });
+}
+function addMatcherTr({ _quill, oper }) {
+  _quill.clipboard.addMatcher("TR", function(node, delta) {
+    const id = cellName();
+    oper.setRowId(id);
+    return delta;
+  });
+}
+function addMatcherTd({ _quill, oper, Delta }) {
+  _quill.clipboard.addMatcher("TD", function(node, delta) {
+    const tableId = oper.getTableId();
+    const rowId = oper.getRowId();
+    const cellId = cellName();
+    if (delta.ops.length) {
+      const lastOp = delta.ops[delta.ops.length - 1];
+      if (typeof lastOp.insert === "string" && !lastOp.insert.endsWith("\n")) {
+        lastOp.insert += "\n";
+      }
+    } else {
+      delta.insert("\n");
+    }
+    const 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"].includes(node.parentNode.tagName)) {
+      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({ qil: _quill, Delta }) {
+  let tableId = cellName();
+  let rowId = cellName();
+  let oper = {
+    getTableId() {
+      return tableId;
+    },
+    setTableId(id) {
+      tableId = id;
+    },
+    getRowId() {
+      return rowId;
+    },
+    setRowId(id) {
+      rowId = id;
+    }
+  };
+  addMatcherTable({ _quill, oper });
+  addMatcherTr({ _quill, oper });
+  addMatcherTd({ _quill, oper, Delta });
+  addMatcher3(_quill);
+  addMatcherFont(_quill);
+}
+let quill = /* @__PURE__ */ Object.create(null);
+function setQuill(q) {
+  quill = q;
+}
+function getQuill() {
+  return quill;
+}
+function getLeafFromQuill() {
+  let q = getQuill();
+  return q ? q.getLeaf(q.getSelection().index) : [];
+}
+function provideTableTrick({ Parchment }) {
+  class TableTrick {
+    static findTd(what) {
+      const leaf = getLeafFromQuill();
+      let blot = leaf[0];
+      while (!isNull(blot) && blot.statics.blotName !== what) {
+        blot = blot.parent;
+      }
+      return blot;
+    }
+    static appendCol() {
+      const td = TableTrick.findTd("td");
+      if (td) {
+        const table = td.parent.parent;
+        const tableId = table.domNode.getAttribute("table_id");
+        td.parent.parent.children.forEach(function(tr) {
+          const rowId = tr.domNode.getAttribute("row_id");
+          const cellId = cellName();
+          const tdNew = Parchment.create("td", tableId + "|" + rowId + "|" + cellId);
+          tr.appendChild(tdNew);
+        });
+      }
+    }
+    static appendRow() {
+      const td = TableTrick.findTd("td");
+      if (td) {
+        const colCount = td.parent.children.length;
+        const table = td.parent.parent;
+        const newRow = td.parent.clone();
+        const tableId = table.domNode.getAttribute("table_id");
+        const rowId = cellName();
+        newRow.domNode.setAttribute("row_id", rowId);
+        for (let i = colCount - 1; i >= 0; i--) {
+          const cellId = cellName();
+          const tdNew = Parchment.create("td", tableId + "|" + rowId + "|" + cellId);
+          newRow.appendChild(tdNew);
+        }
+        table.appendChild(newRow);
+      }
+    }
+  }
+  return { TableTrick };
+}
+function createTable({ value, Container, Parchment, Scroll }) {
+  let node = null;
+  const sizes = value.split("_");
+  const rowCount = Number.parseInt(sizes[1]);
+  const colCount = Number.parseInt(sizes[2]);
+  const tableId = cellName();
+  const table = Parchment.create("table", tableId);
+  for (let ri = 0; ri < rowCount; ri++) {
+    const rowId = cellName();
+    const tr = Parchment.create("tr", rowId);
+    table.appendChild(tr);
+    for (let ci = 0; ci < colCount; ci++) {
+      const cellId = cellName();
+      value = tableId + "|" + rowId + "|" + cellId;
+      const td = Parchment.create("td", value);
+      const p = Parchment.create("block");
+      const br = Parchment.create("break");
+      tr.appendChild(td);
+      td.appendChild(p);
+      p.appendChild(br);
+      node = p;
+    }
+  }
+  const leaf = getLeafFromQuill();
+  let blot = leaf[0];
+  let 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({ Container, Parchment, Scroll, TableTrick, TableRow }) {
+  class Table extends Container {
+    static 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, Container, Parchment, Scroll });
+      } else {
+        const tagName = "table";
+        const node = super.create(tagName);
+        node.setAttribute("table_id", value);
+        return node;
+      }
+    }
+    optimize() {
+      super.optimize();
+      const 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();
+      }
+    }
+  }
+  Table.blotName = "table";
+  Table.tagName = "table";
+  Table.scope = Parchment.Scope.BLOCK_BLOT;
+  Table.defaultChild = "tr";
+  Table.allowedChildren = [TableRow];
+  return { Table };
+}
+function provideTableModule({ Container, Parchment, Module, Quill, Scroll, Delta, ContainBlot, TableRow, TableCell }) {
+  const { TableTrick } = provideTableTrick({ Parchment });
+  const { Table } = provideTable({
+    Container,
+    Parchment,
+    Scroll,
+    TableTrick,
+    TableRow
+  });
+  class TableModule extends Module {
+    constructor(qil, opt) {
+      super(qil, opt);
+      addMatcher({ qil, Delta });
+      setQuill(qil);
+    }
+    static register() {
+      Quill.register(ContainBlot, true);
+      Quill.register(TableRow, true);
+      Quill.register(Table, true);
+      Quill.register(TableCell, true);
+    }
+  }
+  return { TableModule };
+}
+function provideContainBlot({ Container, Parchment, Block, BlockEmbed }) {
+  class ContainBlot extends Container {
+    static create() {
+      return super.create("contain");
+    }
+    static formats(domNode) {
+      return domNode.tagName;
+    }
+    insertBefore(blot, ref) {
+      if (blot.statics.blotName === this.statics.blotName) {
+        super.insertBefore(blot.children.head, ref);
+      } else {
+        super.insertBefore(blot, ref);
+      }
+    }
+    formats() {
+      return { [this.statics.blotName]: this.statics.formats(this.domNode) };
+    }
+    replace(target) {
+      if (target.statics.blotName !== this.statics.blotName) {
+        const item = Parchment.create(this.statics.defaultChild);
+        target.moveChildren(item);
+        this.appendChild(item);
+      }
+      if (isNull(target.parent))
+        return;
+      super.replace(target);
+    }
+  }
+  ContainBlot.blotName = "contain";
+  ContainBlot.tagName = "contain";
+  ContainBlot.scope = Parchment.Scope.BLOCK_BLOT;
+  ContainBlot.defaultChild = "block";
+  ContainBlot.allowedChildren = [Block, BlockEmbed, Container];
+  return { ContainBlot };
+}
+function provideTableRow({ Container, Parchment }) {
+  class TableRow extends Container {
+    static create(value) {
+      const node = super.create("tr");
+      node.setAttribute("row_id", value);
+      return node;
+    }
+    optimize() {
+      super.optimize();
+      const 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();
+      }
+    }
+  }
+  TableRow.blotName = "tr";
+  TableRow.tagName = "tr";
+  TableRow.scope = Parchment.Scope.BLOCK_BLOT;
+  TableRow.defaultChild = "td";
+  return { TableRow };
+}
+function setAttrs({ node, value }) {
+  const 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({ Container, Parchment, Block, BlockEmbed, ContainBlot }) {
+  class TableCell extends ContainBlot {
+    static create(value) {
+      return setAttrs({ node: super.create("td"), value });
+    }
+    formatAt(index, length, name, value) {
+      super.formatAt(index, length, name, value);
+      const attrWhitelist = ["colSpan", "rowSpan", "width", "height"];
+      attrWhitelist.includes(name) && this.domNode.setAttribute(name, value);
+    }
+    formats() {
+      const domNode = this.domNode;
+      const blotName = this.statics.blotName;
+      const attr = (domNode2, attr2) => domNode2.getAttribute(attr2);
+      return {
+        [blotName]: `${attr(domNode, "table_id")}|${attr(domNode, "row_id")}|${attr(domNode, "row_id")}`
+      };
+    }
+    optimize() {
+      super.optimize();
+      if (!isNull(this.parent) && this.parent.statics.blotName !== "tr") {
+        const mark = Parchment.create("block");
+        this.parent.insertBefore(mark, this.next);
+        const table = Parchment.create("table", this.domNode.getAttribute("table_id"));
+        const 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();
+      }
+    }
+  }
+  TableCell.blotName = "td";
+  TableCell.tagName = "td";
+  TableCell.scope = Parchment.Scope.BLOCK_BLOT;
+  TableCell.defaultChild = "block";
+  TableCell.allowedChildren = [Block, BlockEmbed, Container];
+  return { TableCell };
+}
+function tableModule(Quill) {
+  const Container = Quill.import("blots/container");
+  const Scroll = Quill.import("blots/scroll");
+  const Module = Quill.import("core/module");
+  const Block = Quill.import("blots/block");
+  const Delta = Quill.import("delta");
+  const Parchment = Quill.import("parchment");
+  const BlockEmbed = Quill.import("blots/block/embed");
+  const { ContainBlot } = provideContainBlot({
+    Container,
+    Parchment,
+    Block,
+    BlockEmbed
+  });
+  const { TableRow } = provideTableRow({ Container, Parchment });
+  const { TableCell } = provideTableCell({
+    Container,
+    Parchment,
+    Block,
+    BlockEmbed,
+    ContainBlot
+  });
+  const params = {
+    Container,
+    Parchment,
+    Module,
+    Quill,
+    Scroll,
+    Delta,
+    ContainBlot,
+    TableRow,
+    TableCell
+  };
+  const { TableModule } = provideTableModule(params);
+  TableRow.allowedChildren = [TableCell];
+  Container.order = ["list", "contain", "td", "tr", "table"];
+  Quill.register("modules/tableModule", TableModule, true);
+}
+var table_module_default = tableModule;
+export {
+  table_module_default as default
+};