@opentiny/vue-renderless 3.13.2 → 3.14.1

package/popover/vue.js

@@ -52,7 +52,7 @@ const initState = ({
   });
   return state;
 };
-const initApi = ({ api: api2, props, state, refs, emit, doDestroy, constants, nextTick, vm, mode }) => {
+const initApi = ({ api: api2, props, state, emit, doDestroy, constants, nextTick, vm, mode }) => {
   Object.assign(api2, {
     state,
     mounted: mounted({ api: api2, state, constants, props, nextTick, mode }),
@@ -71,8 +71,8 @@ const initApi = ({ api: api2, props, state, refs, emit, doDestroy, constants, ne
     handleMouseLeave: handleMouseLeave({ props, state }),
     handleAfterLeave: handleAfterLeave(emit),
     handleMouseEnter: handleMouseEnter({ props, state }),
-    handleDocumentClick: handleDocumentClick({ refs, state }),
-    wrapMounted: wrapMounted({ api: api2, props, refs, state }),
+    handleDocumentClick: handleDocumentClick({ vm, state }),
+    wrapMounted: wrapMounted({ api: api2, props, vm, state }),
     handleItemClick: handleItemClick({ emit, state }),
     observeCallback: observeCallback({ vm, state })
   });
@@ -130,13 +130,13 @@ const renderless = (props, {
   onUnmounted,
   onActivated,
   onDeactivated
-}, { $prefix, emit, vm, refs, slots, nextTick, mode }) => {
+}, { $prefix, emit, vm, slots, nextTick, mode }) => {
   const api2 = {};
   const constants = { IDPREFIX: `${$prefix.toLowerCase()}-popover` };
-  const options = { emit, onBeforeUnmount, nextTick, reactive, props, watch, onDeactivated, refs, slots, toRefs };
+  const options = { emit, onBeforeUnmount, nextTick, reactive, props, watch, onDeactivated, vm, slots, toRefs };
   const { showPopper, popperElm, referenceElm, doDestroy, updatePopper } = userPopper(options);
   const state = initState({ reactive, computed, api: api2, popperElm, showPopper, referenceElm });
-  initApi({ api: api2, constants, props, state, refs, emit, doDestroy, nextTick, vm, mode });
+  initApi({ api: api2, constants, props, state, emit, doDestroy, nextTick, vm, mode });
   onDeactivated(() => {
     api2.destroyed();
     api2.cleanup();

package/popup/index.js

@@ -52,10 +52,10 @@ const close = ({ api, constants, emit, props, state }) => () => {
   emit("update:modelValue", false);
   emit("close");
 };
-const onTouchMove = ({ refs, state }) => (event) => {
+const onTouchMove = ({ vm, state }) => (event) => {
   touchMove(event);
   const direction = state.deltaY > 0 ? "10" : "01";
-  const el = getScroller()(event.target, refs.$el);
+  const el = getScroller()(event.target, vm.$refs.$el);
   const { scrollHeight, offsetHeight, scrollTop } = el;
   let status = "11";
   if (scrollTop === 0) {
@@ -78,7 +78,7 @@ const renderOverlay = ({ api, nextTick, props, state }) => () => {
     }
   });
 };
-const updateZIndex = ({ refs, state }) => (value = 0) => refs.popup.style.zIndex = ++state.context.zIndex + value;
+const updateZIndex = ({ vm, state }) => (value = 0) => vm.$refs.popup.style.zIndex = ++state.context.zIndex + value;
 const clickOverlay = ({ api, props, emit }) => () => {
   if (props.closeOnClickOverlay) {
     api.close();

package/popup/vue.js

@@ -38,25 +38,25 @@ const initState = ({ reactive, computed, props, api: api2 }) => {
   });
   return state;
 };
-const initApi = ({ api: api2, props, state, refs, emit, nextTick, constants }) => {
+const initApi = ({ api: api2, props, state, vm, emit, nextTick, constants }) => {
   Object.assign(api2, {
     state,
     opened: opened(emit),
     closed: closed(emit),
     getStyle: getStyle(props),
     watchValue: watchValue(api2),
-    updateZIndex: updateZIndex({ refs, state }),
+    updateZIndex: updateZIndex({ vm, state }),
     clickOverlay: clickOverlay({ api: api2, emit, props }),
     renderOverlay: renderOverlay({ api: api2, nextTick, props, state }),
-    onTouchMove: onTouchMove({ refs, state }),
+    onTouchMove: onTouchMove({ vm, state }),
     open: open({ api: api2, constants, emit, props, state }),
     close: close({ api: api2, constants, emit, props, state })
   });
 };
-const renderless = (props, { computed, onMounted, reactive, watch, nextTick }, { constants, refs, emit }) => {
+const renderless = (props, { computed, onMounted, reactive, watch, nextTick }, { constants, vm, emit }) => {
   const api2 = {};
   const state = initState({ reactive, computed, props, api: api2 });
-  initApi({ api: api2, props, state, refs, emit, nextTick, constants });
+  initApi({ api: api2, props, state, vm, emit, nextTick, constants });
   watch(() => props.modelValue, api2.watchValue, { immediate: true });
   onMounted(() => {
     props.modelValue && api2.open();

package/pull-refresh/index.js

@@ -2,6 +2,7 @@ import {
   __spreadValues
 } from "../chunk-G2ADBYYC.js";
 import { on, off } from "../common/deps/dom";
+const PULL_UP_TIME_OUT = 300;
 const initPullRefresh = ({ t, props, state }) => () => {
   var _a, _b, _c;
   const defaultOption = {
@@ -21,22 +22,15 @@ const onTouchstart = (state) => (event) => {
   state.draggposition = event.touches[0].clientY;
 };
 const onTouchmove = ({ state, refs }) => (event) => {
-  if (event.touches[0].clientY < state.draggposition) {
-    pullUpTouchMove(state);
-  } else {
+  if (event.touches[0].clientY > state.draggposition) {
     pullDownTouchMove(state, refs, event);
   }
 };
-const pullUpTouchMove = (state) => {
-  if (state.disabledPullUp || state.pullUpLoading || !state.hasMore) {
-    return;
-  }
-};
 const pullDownTouchMove = (state, refs, event) => {
   if (state.disabledPullDown || state.pullDownLoading) {
     return;
   }
-  if (refs.content.scrollTop <= 0) {
+  if (refs.content.scrollTop <= 0 && window.scrollY <= 0 && event.cancelable) {
     event.preventDefault();
     state.translate3d = (event.touches[0].clientY - state.draggposition) / 2;
     state.pullDownReplaces = Math.abs(state.translate3d) > state.pullDown.headHeight ? state.loosingText : state.pullDown.pullingDownText;
@@ -63,7 +57,8 @@ const pullDownTouchEnd = (api, state, emit) => {
   emit("pullDown");
 };
 const pullUpTouchEnd = (state, emit, refs) => {
-  setTimeout(() => {
+  clearTimeout(state.timer);
+  state.timer = setTimeout(() => {
     const footNode = refs.foot;
     if (!state.hasMore || !footNode) {
       return;
@@ -75,19 +70,24 @@ const pullUpTouchEnd = (state, emit, refs) => {
       emit("update:modelValue", true);
       emit("pullUp");
     }
-  }, 300);
+  }, PULL_UP_TIME_OUT);
+};
+const onScroll = ({ state, emit, refs }) => () => {
+  pullUpTouchEnd(state, emit, refs);
 };
 const mountedHandler = ({ api, refs }) => () => {
   const track = refs.track;
   on(track, "touchstart", api.onTouchstart);
   on(track, "touchmove", api.onTouchmove);
   on(track, "touchend", api.onTouchend);
+  on(track, "scroll", api.onScroll);
 };
 const beforeUnmountHandler = ({ api, refs }) => () => {
   const track = refs.track;
   off(track, "touchstart", api.onTouchstart);
   off(track, "touchmove", api.onTouchmove);
   off(track, "touchend", api.onTouchend);
+  off(track, "scroll", api.onScroll);
 };
 const handlerModelValue = ({ api, state }) => (value, result) => {
   state.pullUpLoading = false;
@@ -113,11 +113,11 @@ export {
   handlerModelValue,
   initPullRefresh,
   mountedHandler,
+  onScroll,
   onTouchend,
   onTouchmove,
   onTouchstart,
   pullDownTouchEnd,
   pullDownTouchMove,
-  pullUpTouchEnd,
-  pullUpTouchMove
+  pullUpTouchEnd
 };

package/pull-refresh/vue.js

@@ -6,6 +6,7 @@ import {
   onTouchstart,
   onTouchmove,
   onTouchend,
+  onScroll,
   initPullRefresh,
   clearPullRefresh
 } from "./index";
@@ -32,13 +33,15 @@ const renderless = (props, { watch, onMounted, reactive, onBeforeUnmount }, { t,
     animationDuration: props.animationDuration,
     disabledPullDown: props.disabledPullDown,
     disabledPullUp: props.disabledPullUp,
-    pullUpDistance: typeof props.pullUpDistance === "string" ? Number(props.pullUpDistance) : props.pullUpDistance
+    pullUpDistance: typeof props.pullUpDistance === "string" ? Number(props.pullUpDistance) : props.pullUpDistance,
+    timer: null
   });
   Object.assign(api2, {
     state,
     onTouchstart: onTouchstart(state),
     onTouchmove: onTouchmove({ state, refs }),
     onTouchend: onTouchend({ api: api2, props, state, emit, refs }),
+    onScroll: onScroll({ state, emit, refs }),
     mountedHandler: mountedHandler({ api: api2, refs }),
     beforeUnmountHandler: beforeUnmountHandler({ api: api2, refs }),
     handlerModelValue: handlerModelValue({ api: api2, state }),
@@ -48,9 +51,7 @@ const renderless = (props, { watch, onMounted, reactive, onBeforeUnmount }, { t,
   watch(
     () => props.hasMore,
     (value) => {
-      if (!value) {
-        state.hasMore = false;
-      }
+      state.hasMore = value;
     },
     { immediate: true }
   );

package/radio/index.js

@@ -61,24 +61,7 @@ const toggleEvent = ({ props, vm, type }) => {
     });
   }
 };
-const dispatchDisplayedValue = ({ state, dispatch, api }) => () => {
-  if (state.isDisplayOnly) {
-    dispatch("FormItem", "displayed-value-changed", {
-      type: "radio",
-      val: api.getDisplayedValue()
-    });
-  }
-};
-const getDisplayedValue = ({ vm, state, props }) => () => {
-  if (state.model === props.label) {
-    return vm.$refs.label && vm.$refs.label.innerText || props.text || props.label;
-  } else {
-    return "";
-  }
-};
 export {
-  dispatchDisplayedValue,
-  getDisplayedValue,
   getModel,
   handleChange,
   isDisabled,

package/radio/vue.js

@@ -8,17 +8,15 @@ import {
   tabIndex,
   getModel,
   setModel,
-  toggleEvent,
-  dispatchDisplayedValue,
-  getDisplayedValue
+  toggleEvent
 } from "./index";
 const api = ["state", "handleChange"];
-const renderless = (props, { onMounted, onBeforeUnmount, computed, reactive, inject, watch }, { vm, parent, emit, constants, nextTick, dispatch }) => {
+const renderless = (props, { onMounted, onBeforeUnmount, computed, reactive, inject }, { vm, parent, emit, constants, nextTick, dispatch }) => {
   parent.tinyForm = parent.tinyForm || inject("form", null);
   const api2 = {};
   const state = reactive({
     vertical: inject("radioVertical", false),
-    size: props.size || inject("size", null),
+    size: computed(() => props.size || inject("size", null) || (parent.tinyForm || {}).size),
     focus: false,
     radioGroup: null,
     isGroup: computed(() => api2.isGroup()),
@@ -41,13 +39,9 @@ const renderless = (props, { onMounted, onBeforeUnmount, computed, reactive, inj
     isDisabled: isDisabled({ props, state }),
     isDisplayOnly: isDisplayOnly({ props }),
     setModel: setModel({ constants, dispatch, emit, props, vm, state }),
-    handleChange: handleChange({ constants, dispatch, emit, state, nextTick }),
-    dispatchDisplayedValue: dispatchDisplayedValue({ state, api: api2, dispatch }),
-    getDisplayedValue: getDisplayedValue({ vm, state, props })
+    handleChange: handleChange({ constants, dispatch, emit, state, nextTick })
   });
-  watch(() => state.isDisplayOnly, api2.dispatchDisplayedValue);
   onMounted(() => {
-    api2.dispatchDisplayedValue();
     dispatch("Tooltip", "tooltip-update");
     toggleEvent({ props, vm, type: "add" });
   });

package/rate/index.js

@@ -136,7 +136,7 @@ const computedText = ({ props, state }) => {
     currentValue = props.texts.length;
   }
   if (props.showScore) {
-    result = props.scoreTemplate.replace(/\{\s*value\s*\}/, currentValue);
+    result = props.scoreTemplate.replace(/\{\s*value\s*\}/, String(currentValue));
     return result;
   }
   if (props.showText && currentValue > 0) {

package/rate/vue.js

@@ -30,7 +30,6 @@ const api = [
   "resetCurrentValue"
 ];
 const useChangeValue = ({
-  computed,
   constants,
   emit,
   props,
@@ -85,7 +84,6 @@ const useChangeValue = ({
 const renderless = (props, { computed, reactive, toRefs, watch, onMounted, onUnmounted, inject }, { constants, emit, parent }) => {
   const api2 = {};
   const changeValue = useChangeValue({
-    computed,
     constants,
     emit,
     props,

package/record/index.js

@@ -148,7 +148,9 @@ const toogleRecord = ({ state, api, emit, constants, props }) => ($event) => {
 };
 const handleConfirm = ({ state, emit, props, constants, api }) => ($event) => {
   if (props.isHwh5) {
-    api.triggerClick($event, constants.HWH5_STATUS.CANCEL, () => emit("update:modelValue", false));
+    api.triggerClick($event, constants.HWH5_STATUS.END, () => {
+      emit("update:modelValue", false);
+    });
   } else {
     state.isClickConfirm = true;
     emit("update:modelValue", false);
@@ -195,6 +197,7 @@ const calcVoice = (analyser) => {
     if (highValue <= val) {
       return voiceNum = idx + 1 + (val === 0 ? lowValue / 1e3 : highValue / val);
     }
+    return false;
   });
   !ismatch && (voiceNum = 6);
   return voiceNum;

package/rich-text/clipboard.js

@@ -0,0 +1,54 @@
+import "../chunk-G2ADBYYC.js";
+let selectors = [];
+let doms = [];
+let scrolls = [];
+function backup() {
+  doms.push(window);
+  scrolls.push({ left: window.pageXOffset, top: window.pageYOffset });
+  selectors.forEach((selector) => {
+    const dom = document.querySelector(`.${selector}`);
+    if (dom) {
+      doms.push(dom);
+      scrolls.push({ left: dom.scrollLeft, top: dom.scrollTop });
+    }
+  });
+}
+function restore() {
+  doms.forEach((dom, i) => dom.scrollTo(scrolls[i]));
+  doms = [];
+  scrolls = [];
+}
+function registerCustomClipboard(Quill, keepClass) {
+  const Clipboard = Quill.import("modules/clipboard");
+  const Delta = Quill.import("delta");
+  if (typeof keepClass === "string") {
+    selectors.push(keepClass);
+  } else if (Array.isArray(keepClass)) {
+    selectors = keepClass.slice(0);
+  }
+  class CustomClipboard extends Clipboard {
+    onPaste(e) {
+      backup();
+      if (e.defaultPrevented || !this.quill.isEnabled())
+        return;
+      const range = this.quill.getSelection();
+      let delta = new Delta().retain(range.index);
+      const scrollTop = this.quill.scrollingContainer.scrollTop;
+      this.container.focus();
+      this.quill.selection.update(Quill.sources.SILENT);
+      setTimeout(() => {
+        delta = delta.concat(this.convert()).delete(range.length);
+        this.quill.updateContents(delta, Quill.sources.USER);
+        this.quill.setSelection(delta.length() - range.length, Quill.sources.SILENT);
+        this.quill.scrollingContainer.scrollTop = scrollTop;
+        this.quill.focus();
+        restore();
+      }, 1);
+    }
+  }
+  Quill.register("modules/clipboard", CustomClipboard, true);
+}
+var clipboard_default = registerCustomClipboard;
+export {
+  clipboard_default as default
+};

package/rich-text/index.js

@@ -0,0 +1,192 @@
+import "../chunk-G2ADBYYC.js";
+import { extend } from "../common/object";
+import { xss } from "../common/xss";
+import { getToolbarTips, defaultOptions } from "./options";
+import registerTableModule from "./table-module";
+import registerCustomClipboard from "./clipboard";
+const initContent = ({ state, props, nextTick }) => () => {
+  if (state.quill) {
+    const flag = state.quill.selection.hasFocus();
+    if (state.content && state.content !== state.innerContent) {
+      state.innerContent = state.content;
+      state.quill.pasteHTML(xss.filterHtml(state.content));
+    } else {
+      if (!state.content) {
+        state.quill.setText("");
+      }
+    }
+    nextTick(() => {
+      if (!props.disabled && !props.displayOnly) {
+        state.quill.enable(true);
+      }
+      flag ? state.quill.selection.focus() : state.quill.blur();
+    });
+  }
+};
+const initQuill = ({ api, emit, props, vm, service, state, Quill, ImageDrop, ImageUpload, FileUpload }) => () => {
+  state.innerOptions = extend(true, {}, defaultOptions, props.globalOptions, props.options);
+  if (document.caretRangeFromPoint) {
+    if (props.imageDrop) {
+      Quill.register("modules/imageDrop", ImageDrop, true);
+      state.innerOptions.modules.imageDrop = props.imageDrop;
+    }
+    if (props.imageUpload) {
+      Quill.register("modules/imageUpload", ImageUpload, true);
+      state.innerOptions.modules.imageUpload = props.imageUpload;
+    }
+    if (props.fileUpload) {
+      Quill.register("modules/fileUpload", FileUpload, true);
+      state.innerOptions.modules.fileUpload = extend(
+        true,
+        {},
+        { httpRequest: service && service.network.request },
+        props.fileUpload,
+        { url: state.fileUploadUrl }
+      );
+    }
+  }
+  registerTableModule(Quill);
+  if (state.innerOptions.modules) {
+    state.innerOptions.modules.tableModule = props.tableModule === true;
+  }
+  registerCustomClipboard(Quill, props.keepClass);
+  state.quill = Object.freeze(new Quill(vm.$refs.editor, state.innerOptions));
+  state.quill.enable(false);
+  state.quill.on("selection-change", api.selectionChange);
+  state.quill.on("text-change", api.textChange);
+  if (state.content) {
+    state.quill.pasteHTML(xss.filterHtml(state.content));
+    api.textChange();
+  }
+  if (!props.disabled && !props.displayOnly) {
+    state.quill.enable(true);
+  }
+  emit("ready", state.quill);
+  api.setToolbarTips();
+};
+const setToolbarTips = ({ t, vm }) => () => {
+  let tip;
+  const item = getToolbarTips(t);
+  const length = item.length;
+  const richTextEl = vm.$el;
+  for (let i = 0; i < length; i++) {
+    tip = richTextEl.querySelectorAll(".quill-editor " + item[i].Choice);
+    if (tip.length) {
+      Array.prototype.slice.call(tip).forEach((ite) => {
+        ite.setAttribute("title", item[i].title);
+      });
+    }
+  }
+  tip = richTextEl.querySelectorAll(".quill-editor .ql-file");
+  if (tip.length) {
+    const iconEl = vm.$refs.iconFile.$el;
+    Array.prototype.slice.call(tip).forEach((ite) => {
+      ite.innerHTML = getOuterHTML(iconEl);
+    });
+  }
+};
+const setPlaceholder = ({ state, props }) => () => {
+  if (state.quill) {
+    state.quill.root.setAttribute("data-placeholder", props.options.placeholder);
+  }
+};
+const getFileUploadUrl = ({ service }) => () => {
+  return service ? service.common.getFileUploadUrl() : Promise.resolve("");
+};
+const selectionChange = ({ emit, state }) => (range) => {
+  if (!range) {
+    emit("blur", state.quill);
+  } else {
+    emit("focus", state.quill);
+  }
+};
+const handlePaste = ({ state }) => (event) => {
+  const rangeLength = state.quill.selection.savedRange.length || 0;
+  const newLength = event.clipboardData.getData("text").length || 0;
+  const currentLength = state.quill.getText().length || 0;
+  const totalLength = currentLength - rangeLength + newLength;
+  if (totalLength > state.maxLength) {
+    event.preventDefault();
+    state.pasteCanceled = true;
+  } else {
+    state.pasteCanceled = false;
+  }
+};
+const maxLength = ({ props, constants }) => () => {
+  return props.maxLength > 0 ? props.maxLength : constants.MAX_LENGTH;
+};
+const isDisplayOnly = ({ state, props, parent, nextTick }) => () => {
+  let displayOnly = props.displayOnly || (parent.auiForm || {}).displayOnly;
+  nextTick(() => {
+    if (state.quill && !props.disabled) {
+      state.quill.root.setAttribute("contenteditable", !displayOnly);
+    }
+  });
+  return displayOnly;
+};
+const textChange = ({ emit, vm, state, Modal, t }) => (delta, oldDelta) => {
+  const quill = state.quill;
+  if (state.pasteCanceled) {
+    state.pasteCanceled = false;
+    quill.setContents(oldDelta);
+    Modal.message({ message: `${t("ui.richText.maxLength")}${state.maxLength}`, status: "warning" });
+    return;
+  }
+  const text = quill.getText();
+  const currentLength = text.length;
+  const maxLength2 = state.maxLength;
+  if (currentLength > maxLength2) {
+    quill.setContents(oldDelta);
+    Modal.message({ message: `${t("ui.richText.maxLength")}${state.maxLength}`, status: "warning" });
+    return;
+  }
+  let html = xss.filterHtml(vm.$refs.editor.children[0].innerHTML);
+  if (html === "<p><br></p>")
+    html = "";
+  state.innerContent = html;
+  emit("update:modelValue", html);
+  emit("change", { html, text, quill });
+};
+const getOuterHTML = (el) => {
+  if (!el.outerHTML) {
+    const container = document.createElement("div");
+    container.appendChild(el);
+    return xss.filterHtml(container.innerHTML);
+  } else {
+    return xss.filterHtml(el.outerHTML);
+  }
+};
+const mounted = ({ api, props, state, i18n, watch }) => () => {
+  if (props.fileUpload && !props.fileUpload.url) {
+    api.getFileUploadUrl().then((url) => {
+      url = xss.filterUrl(url);
+      state.fileUploadUrl = url;
+      api.initQuill();
+    });
+  } else {
+    api.initQuill();
+  }
+  if (i18n) {
+    watch(() => i18n.locale, api.setToolbarTips);
+  }
+};
+const beforeUnmount = ({ api, state }) => () => {
+  state.quill.off("selection-change", api.selectionChange);
+  state.quill.off("text-change", api.textChange);
+  state.quill = null;
+  delete state.quill;
+};
+export {
+  beforeUnmount,
+  getFileUploadUrl,
+  handlePaste,
+  initContent,
+  initQuill,
+  isDisplayOnly,
+  maxLength,
+  mounted,
+  selectionChange,
+  setPlaceholder,
+  setToolbarTips,
+  textChange
+};

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

@@ -0,0 +1,107 @@
+import "../../chunk-G2ADBYYC.js";
+import { xss } from "../../common/xss";
+const Upload = function(quill, options) {
+  this.quill = quill;
+  this.options = options || {};
+  this.quill.getModule("toolbar").addHandler("file", this.selectLocalFile.bind(this));
+};
+const FormDataRequest = function({ file, url, method, name, headers, callbackOK, callbackKO }) {
+  const fd = new FormData();
+  url = xss.filterUrl(url);
+  fd.append(name, file, file.name);
+  this.options.csrf && fd.append(this.options.csrf.token, this.options.csrf.hash);
+  if (this.options.httpRequest) {
+    const option = {
+      url,
+      headers,
+      method,
+      data: fd,
+      onSuccess: function(res) {
+        callbackOK(res && res.data, this.insert.bind(this));
+      }.bind(this),
+      onError(error) {
+        callbackKO(error);
+      }
+    };
+    const req = this.options.httpRequest(option);
+    if (req && req.then) {
+      req.then(option.onSuccess, option.onError);
+    }
+  } else {
+    const xmlRequest = new XMLHttpRequest();
+    xmlRequest.withCredentials = this.options.withCredentials !== false;
+    xmlRequest.open(method, url, true);
+    for (let index in headers) {
+      xmlRequest.setRequestHeader(index, headers[index]);
+    }
+    xmlRequest.onload = function() {
+      if (xmlRequest.status === 200 || xmlRequest.status === 201) {
+        callbackOK(JSON.parse(xmlRequest.responseText), this.insert.bind(this));
+      } else {
+        callbackKO({
+          code: xmlRequest.status,
+          type: xmlRequest.statusText,
+          body: xmlRequest.responseText
+        });
+      }
+    }.bind(this);
+    xmlRequest.send(fd);
+  }
+};
+const defaultUploader = function(file) {
+  const url = this.options.url;
+  const method = this.options.method || "POST";
+  const name = this.options.name || "file";
+  const headers = this.options.headers || {};
+  const callbackOK = this.options.success || this.uploadCallbackOK.bind(this);
+  const callbackKO = this.options.fail || this.uploadCallbackKO.bind(this);
+  if (url) {
+    FormDataRequest.call(this, { file, url, method, name, headers, callbackOK, callbackKO });
+  } else {
+    const reader = new FileReader();
+    reader.onload = function(event) {
+      callbackOK(event.target.result, this.insert.bind(this));
+    }.bind(this);
+    reader.readAsDataURL(file);
+  }
+};
+Upload.prototype.selectLocalFile = function() {
+  const input = document.createElement("input");
+  input.setAttribute("type", "file");
+  input.click();
+  input.onchange = function() {
+    const file = input.files[0];
+    const checkBeforeSend = this.options.checkBeforeSend || this.checkBeforeSend.bind(this);
+    checkBeforeSend(file, this.sendToServer.bind(this));
+  }.bind(this);
+};
+Upload.prototype.checkBeforeSend = function(file, next) {
+  next(file);
+};
+Upload.prototype.sendToServer = function(file) {
+  if (this.options.customUploader) {
+    this.options.customUploader(
+      file,
+      function(file2) {
+        this.insert(file2);
+      }.bind(this)
+    );
+  } else {
+    defaultUploader.call(this, file);
+  }
+};
+Upload.prototype.insert = function(file) {
+  const index = (this.quill.getSelection() || {}).index || this.quill.getLength();
+  this.quill.insertText(index, file.name, "link", file.url);
+  this.quill.setSelection(index + file.name.length);
+};
+Upload.prototype.uploadCallbackOK = function(response, next) {
+  next(response);
+};
+Upload.prototype.uploadCallbackKO = function(error) {
+  throw new Error(error);
+};
+var file_upload_default = Upload;
+export {
+  file_upload_default as default
+};