@epxing/designer 0.0.0-stage → 5.3.0-beta.2

package/dist/src/visual/config/Input.js

@@ -0,0 +1,177 @@
+import '../../../style.css';
+import _sfc_main from "./Input.vue.js";
+import { resolveComponent, openBlock, createElementBlock, createElementVNode, withModifiers, createVNode, withCtx, createCommentVNode, normalizeStyle, createBlock, toDisplayString, Fragment, renderList } from "vue";
+/* empty css           */
+/* empty css           */
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.js";
+const _hoisted_1 = {
+  class: "config-input",
+  ref: "configInput"
+};
+const _hoisted_2 = { class: "input-container" };
+const _hoisted_3 = { class: "input-inner" };
+const _hoisted_4 = ["contenteditable", "placeholder"];
+const _hoisted_5 = ["onMousedown"];
+const _hoisted_6 = ["onMousedown"];
+const _hoisted_7 = ["onMousedown"];
+const _hoisted_8 = { class: "language" };
+const _hoisted_9 = {
+  class: "language-item__label",
+  for: ""
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_tooltip = resolveComponent("el-tooltip");
+  const _component_el_tree = resolveComponent("el-tree");
+  const _component_el_tab_pane = resolveComponent("el-tab-pane");
+  const _component_el_tabs = resolveComponent("el-tabs");
+  const _component_epx_visual_config_input = resolveComponent("epx-visual-config-input");
+  const _component_el_popover = resolveComponent("el-popover");
+  return openBlock(), createElementBlock("div", _hoisted_1, [
+    createElementVNode("div", _hoisted_2, [
+      createElementVNode("div", _hoisted_3, [
+        createElementVNode("div", {
+          class: "input",
+          ref: "input",
+          contenteditable: !$props.readonly ? "true" : "false",
+          onFocus: _cache[0] || (_cache[0] = (...args) => $options.inputFocus && $options.inputFocus(...args)),
+          onBlur: _cache[1] || (_cache[1] = (...args) => $options.onBlur && $options.onBlur(...args)),
+          onPaste: _cache[2] || (_cache[2] = (...args) => $options.paste && $options.paste(...args)),
+          onClick: _cache[3] || (_cache[3] = (...args) => $options.inputClick && $options.inputClick(...args)),
+          onDblclick: _cache[4] || (_cache[4] = (...args) => $options.onDblclick && $options.onDblclick(...args)),
+          placeholder: $options.isInputVariable ? "输入“/”插入变量或函数" : "",
+          onInput: _cache[5] || (_cache[5] = (...args) => $options.changeValue && $options.changeValue(...args))
+        }, null, 40, _hoisted_4)
+      ]),
+      $options.isInputVariable && !$props.readonly ? (openBlock(), createElementBlock("div", {
+        key: 0,
+        class: "input-suffix",
+        onClick: _cache[9] || (_cache[9] = withModifiers(() => {
+        }, ["stop"]))
+      }, [
+        createVNode(_component_el_tooltip, {
+          effect: "dark",
+          content: "点击插入变量或函数",
+          placement: "top",
+          onClick: _cache[8] || (_cache[8] = withModifiers(() => {
+          }, ["stop"]))
+        }, {
+          default: withCtx(() => [
+            createElementVNode("i", {
+              class: "epx-icon-bianliang",
+              onMousedown: _cache[6] || (_cache[6] = (...args) => $options.openContextMenu && $options.openContextMenu(...args)),
+              onClick: _cache[7] || (_cache[7] = withModifiers(() => {
+              }, ["stop"]))
+            }, null, 32)
+          ]),
+          _: 1
+        })
+      ])) : createCommentVNode("", true)
+    ]),
+    $data.showContentMenu ? (openBlock(), createElementBlock("div", {
+      key: 0,
+      class: "variable-menu__container",
+      style: normalizeStyle({ left: $data.variablePos && $data.variablePos.x, top: $data.variablePos && $data.variablePos.y }),
+      onClick: _cache[11] || (_cache[11] = withModifiers(() => {
+      }, ["stop"]))
+    }, [
+      $props.designer.mode === "template" ? (openBlock(), createBlock(_component_el_tree, {
+        key: 0,
+        data: $options.templateAttributeTree,
+        props: $data.templateAttributeProps
+      }, {
+        default: withCtx(({ data }) => [
+          createElementVNode("span", {
+            style: { flex: 1 },
+            onMousedown: (e) => $options.addParams(data, e)
+          }, toDisplayString(data.text), 41, _hoisted_5)
+        ]),
+        _: 1
+      }, 8, ["data", "props"])) : (openBlock(), createBlock(_component_el_tabs, {
+        key: 1,
+        class: "variable-tabs",
+        modelValue: $data.activeVariableTab,
+        "onUpdate:modelValue": _cache[10] || (_cache[10] = ($event) => $data.activeVariableTab = $event)
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_el_tab_pane, {
+            label: "插入变量",
+            name: "variable"
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_el_tree, {
+                class: "variable-tree",
+                data: $options.variableList,
+                props: $data.variableProps
+              }, {
+                default: withCtx(({ data }) => [
+                  createElementVNode("span", {
+                    style: { flex: 1 },
+                    onMousedown: (e) => $options.addVariable(data, e)
+                  }, toDisplayString(data.name || data.code), 41, _hoisted_6)
+                ]),
+                _: 1
+              }, 8, ["data", "props"])
+            ]),
+            _: 1
+          }),
+          createVNode(_component_el_tab_pane, {
+            label: "插入函数",
+            name: "function"
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_el_tree, {
+                class: "variable-tree",
+                data: $data.functionLibrary,
+                props: $data.variableProps
+              }, {
+                default: withCtx(({ data }) => [
+                  createElementVNode("span", {
+                    style: { flex: 1 },
+                    onMousedown: (e) => $options.addFunction(data, e)
+                  }, toDisplayString(data.name || data.code), 41, _hoisted_7)
+                ]),
+                _: 1
+              }, 8, ["data", "props"])
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["modelValue"]))
+    ], 4)) : createCommentVNode("", true),
+    $props.isInternational && !$props.readonly ? (openBlock(), createBlock(_component_el_popover, {
+      key: 1,
+      placement: "bottom",
+      width: "330",
+      trigger: "click",
+      persistent: false
+    }, {
+      reference: withCtx(() => [..._cache[12] || (_cache[12] = [
+        createElementVNode("i", { class: "language-icon epx-icon-diqiu" }, null, -1)
+      ])]),
+      default: withCtx(() => [
+        createElementVNode("div", _hoisted_8, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList($options.languageList, (language) => {
+            return openBlock(), createElementBlock("div", {
+              class: "language-item",
+              key: language.id
+            }, [
+              createElementVNode("label", _hoisted_9, toDisplayString(language.name) + "：", 1),
+              createVNode(_component_epx_visual_config_input, {
+                designer: $props.designer,
+                value: $props.i18nValue[language.id],
+                isInternational: false,
+                onChangeConfigs: (v) => $options.changeLanguageValue(language.id, v)
+              }, null, 8, ["designer", "value", "onChangeConfigs"])
+            ]);
+          }), 128))
+        ])
+      ]),
+      _: 1
+    })) : createCommentVNode("", true)
+  ], 512);
+}
+const Input = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-da0d44e3"]]);
+export {
+  Input as default
+};

package/dist/src/visual/config/Input.vue.js

@@ -0,0 +1,479 @@
+import { markRaw } from "vue";
+import { loadSystemVariables, loadFunctionTree } from "./variable-sources.js";
+const _sfc_main = {
+  name: "epx-visual-config-input",
+  props: {
+    designer: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
+    label: String,
+    value: [String, Number],
+    i18nValue: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
+    defaultValue: String,
+    change: Function,
+    readonly: Boolean,
+    regExp: String,
+    isInternational: {
+      type: Boolean,
+      default: true
+    },
+    inputVariable: {
+      type: Boolean,
+      default: false
+    },
+    pageParams: Array
+  },
+  data() {
+    return {
+      inputContent: "",
+      computedValue: "",
+      showContentMenu: false,
+      inputFocused: false,
+      templateAttributeProps: {
+        children: "children",
+        label: "text"
+      },
+      variableProps: {
+        children: "children",
+        label: "name"
+      },
+      systemVariableList: [],
+      activeVariableTab: "variable",
+      functionLibrary: [],
+      variablePos: {}
+    };
+  },
+  watch: {
+    value(v) {
+      if (this.initValue) {
+        this.setInputContent(v);
+      }
+    },
+    // 首次打开变量菜单再拉系统变量与函数树；此前每个输入框挂载都各发两次请求
+    showContentMenu(v) {
+      if (v) this.ensureVariableSources();
+    }
+  },
+  computed: {
+    isInputVariable() {
+      return this.inputVariable || this.designer.mode === "template";
+    },
+    languageList() {
+      const {
+        LANGUAGES: languages = "",
+        "LANGUAGES#": languageNames = "",
+        LANGUAGE_DEFAULT: defaultLanguage
+      } = this.clientConfig;
+      if (!languages) return [];
+      const languageIdList = languages.split(",");
+      const languageNameList = languageNames.split(",");
+      const languageList = languageIdList.map((item, index) => ({
+        id: item,
+        name: languageNameList[index]
+      }));
+      return languageList.filter((item) => item.id !== defaultLanguage);
+    },
+    pageVariableSets() {
+      var _a;
+      return this.pageParams || ((_a = this.designer.pageConfig) == null ? void 0 : _a.variableSets) || [];
+    },
+    templateAttributeTree() {
+      return this.designer.mode === "template" ? this.designer.templateAttributeTree : [];
+    },
+    fieldConfigs() {
+      const fieldConfigs = {
+        attriName: "configInput",
+        dataType: "text",
+        state: "ADD",
+        attriLabel: this.label,
+        readonly: this.readonly ? "1" : "0",
+        attribute: {
+          international: "1"
+        }
+      };
+      if (this.regExp) {
+        fieldConfigs.attribute.format = "reg_exp";
+        fieldConfigs.attribute.regexp = this.regExp;
+      }
+      return fieldConfigs;
+    },
+    variableList() {
+      return [{
+        name: "页面变量",
+        code: "page",
+        children: this.pageVariableSets
+      }, {
+        name: "系统变量",
+        code: "system",
+        children: this.systemVariableList
+      }, {
+        name: "自定义变量",
+        code: "customize"
+      }];
+    }
+  },
+  methods: {
+    ensureVariableSources() {
+      if (this._variableSourcesLoaded) return;
+      this._variableSourcesLoaded = true;
+      loadSystemVariables(this.$http).then((list) => {
+        this.systemVariableList = list;
+      });
+      loadFunctionTree(this.$http).then((tree) => {
+        this.functionLibrary = markRaw(tree);
+      });
+    },
+    getTemplateAttribute(key) {
+      for (const item of this.templateAttributeTree) {
+        if (item.entity.data.CODE === key) {
+          return item.entity.data;
+        } else if (item.children && item.children.length > 0) {
+          for (const child of item.children) {
+            if (child.entity.data.CODE === key) return child.entity.data;
+          }
+        }
+      }
+    },
+    highlightFunctionCall(expression) {
+      let result = "";
+      let i = 0;
+      while (i < expression.length) {
+        const char = expression[i];
+        if (/[a-zA-Z]/.test(char)) {
+          let functionName = "";
+          while (i < expression.length && /[a-zA-Z]/.test(expression[i])) {
+            functionName += expression[i];
+            i++;
+          }
+          if (expression[i] === "(") {
+            result += `<span class="function">${functionName}</span>`;
+          } else {
+            result += `<span class="epx-visual-config-input__variable" contenteditable="false">${functionName}</span>`;
+          }
+          continue;
+        }
+        if (char === '"' || char === "'") {
+          const quote = char;
+          result += `<span class="string">${quote}`;
+          i++;
+          while (i < expression.length && expression[i] !== quote) {
+            result += expression[i];
+            i++;
+          }
+          if (i < expression.length) {
+            result += quote + "</span>";
+          }
+          i++;
+          continue;
+        }
+        if (/[0-9]/.test(char)) {
+          let number = "";
+          while (i < expression.length && /[0-9.]/.test(expression[i])) {
+            number += expression[i];
+            i++;
+          }
+          result += `<span class="number">${number}</span>`;
+          continue;
+        }
+        if (char === "(" || char === ")" || char === ",") {
+          result += `<span class="parenthesis">${char}</span>`;
+          i++;
+          continue;
+        }
+        result += char;
+        i++;
+      }
+      return result;
+    },
+    setInputContent(v = "") {
+      if (!v) return;
+      const html = String(v).replace(/\{\{([\w-.,|$#[\]()"'\s]+)\}\}/g, (match, key) => `<span class="epx-visual-config-input__expression" data-type="expression" contenteditable="false" data-value="{{${key}}}">${this.highlightFunctionCall(key)}</span>`).replace(/\$\[([\w-.|$#]+)\]/g, (match, key) => `<span class="epx-visual-config-input__variable" contenteditable="false" data-value="$[${key}]">${key}</span>`).replace(/@\[([\w-.|$#]+)\]/g, (match, key) => {
+        const param = this.getTemplateAttribute(key);
+        return `<span class="epx-visual-config-input__params" contenteditable="false" data-value="@[${key}]">${(param == null ? void 0 : param.NAME) || key}</span>`;
+      });
+      this.inputContent = this.xss.process(html);
+      if (this.$refs.input) this.$refs.input.innerHTML = this.inputContent;
+    },
+    getInputValue(v) {
+      const node = document.createElement("div");
+      node.innerHTML = v;
+      node.querySelectorAll('[data-type="expression"]').forEach((item) => {
+        item.innerHTML = `{{${item.innerText}}}`;
+      });
+      node.querySelectorAll(".epx-visual-config-input__variable").forEach((item) => {
+        item.innerText = `$[${item.innerText}]`;
+      });
+      node.querySelectorAll(".epx-visual-config-input__params").forEach((item) => {
+        item.innerText = `${item.getAttribute("data-value")}`;
+      });
+      node.querySelectorAll("div").forEach((item) => {
+        item.parentNode.insertBefore(document.createTextNode("\n"), item);
+      });
+      return node.innerText;
+    },
+    clearValue() {
+      if (this.inputFocused) {
+        this.$refs.input.innerHTML = "";
+        this.changeValue("");
+        this.$refs.input.focus();
+      }
+    },
+    changeValue(e) {
+      if (e.data === "/") {
+        if (!this.isInputVariable) return;
+        this.showContentMenu = true;
+        this.lastEditRange = null;
+        const selection = window.getSelection();
+        const range = selection.getRangeAt(0);
+        const rect = range.getBoundingClientRect();
+        const inputRect = this.$refs.configInput.getBoundingClientRect();
+        const top = rect.bottom - inputRect.top;
+        this.variablePos = {
+          x: 0,
+          y: top + 20 + "px"
+        };
+      } else {
+        this.showContentMenu = false;
+      }
+    },
+    insertAtCursor(el, newElement) {
+      const range = this.range;
+      let selectedNode = range.startContainer;
+      if (!this.$refs.input.contains(selectedNode)) {
+        selectedNode = this.$refs.input;
+      }
+      const parent = selectedNode.nodeName === "#text" ? selectedNode.parentNode : selectedNode;
+      if (selectedNode.nodeName === "#text") {
+        const start = selectedNode.data.substring(0, range.startOffset);
+        const end = selectedNode.data.substring(range.startOffset);
+        parent.insertBefore(newElement, selectedNode);
+        const startNode = document.createTextNode(start.endsWith("/") ? start.slice(0, -1) : start);
+        parent.insertBefore(startNode, newElement);
+        if (end.length > 0) {
+          const endNode = document.createTextNode(end);
+          parent.insertBefore(endNode, newElement.nextSibling);
+        }
+      } else {
+        parent.insertBefore(newElement, parent.childNodes[range.startOffset]);
+      }
+      selectedNode.data = "";
+    },
+    addVariable(variable, e) {
+      if (variable.children) return;
+      const selection = window.getSelection();
+      const range = document.createRange();
+      const span = document.createElement("span");
+      span.className = "epx-visual-config-input__variable";
+      if (variable.code === "customize") {
+        const textNode = document.createTextNode(" ");
+        span.appendChild(textNode);
+        this.insertAtCursor(this.$refs.input, span);
+        range.setStart(span, 0);
+        range.setEnd(span, 1);
+      } else {
+        span.innerHTML = variable.code;
+        span.contentEditable = "false";
+        span.setAttribute("data-value", `$[${variable.code}]`);
+        this.insertAtCursor(this.$refs.input, span);
+        range.setStart(span.nextSibling, 0);
+        range.collapse(true);
+      }
+      e.preventDefault();
+      selection.removeAllRanges();
+      selection.addRange(range);
+    },
+    addFunction(item, e) {
+      if (!item.leaf) return;
+      const selection = window.getSelection();
+      const range = document.createRange();
+      const span = document.createElement("span");
+      span.className = "epx-visual-config-input__expression";
+      span.contentEditable = "false";
+      span.innerHTML = item.code + "()";
+      span.setAttribute("data-type", "expression");
+      span.setAttribute("data-value", `{{${item.code}}}`);
+      this.insertAtCursor(this.$refs.input, span);
+      range.setStart(span, 1);
+      range.collapse(true);
+      e.preventDefault();
+      selection.removeAllRanges();
+      selection.addRange(range);
+    },
+    addParams(data, e) {
+      e.preventDefault();
+      if (data.leaf) {
+        const param = data.entity.data;
+        const span = document.createElement("span");
+        span.innerHTML = param.NAME;
+        span.className = "epx-visual-config-input__params";
+        span.contentEditable = "false";
+        span.setAttribute("data-value", `@[${param.CODE}]`);
+        this.insertAtCursor(this.$refs.input, span);
+        this.$refs.input.focus();
+      }
+    },
+    inputFocus() {
+      this.inputFocused = true;
+    },
+    paste(e) {
+      e.preventDefault();
+      const text = e.clipboardData.getData("text/plain");
+      document.execCommand("insertText", false, text);
+      if (/@\[([\w-.|$#]+)\]/.test(text)) {
+        setTimeout(() => {
+          this.setInputContent(this.getInputValue(this.$refs.input.innerHTML));
+        }, 0);
+      }
+    },
+    onBlur(e) {
+      setTimeout(() => {
+        this.inputFocused = false;
+        if (document.activeElement !== this.$refs.input) {
+          let value = this.getInputValue(this.$refs.input.innerHTML);
+          value = value !== this.defaultValue ? value : null;
+          this.$emit("change-configs", value);
+          if (this.change) this.change(value);
+        }
+      }, 20);
+    },
+    onDblclick(e) {
+      if (e.target.className === "epx-visual-config-input__variable") {
+        e.target.contentEditable = "true";
+      }
+    },
+    inputClick(e) {
+      if (e.target.className === "epx-visual-config-input__variable") {
+        if (e.target.contentEditable === "false") {
+          e.target.contentEditable = "true";
+          const selection = document.getSelection();
+          const range = document.createRange();
+          range.selectNodeContents(e.target);
+          range.collapse();
+          selection.removeAllRanges();
+          selection.addRange(range);
+        }
+      } else if (e.target.getAttribute("data-type") === "expression" || e.target.parentNode.getAttribute("data-type") === "expression") {
+        const node = e.target.getAttribute("data-type") === "expression" ? e.target : e.target.parentNode;
+        if (node.contentEditable === "false") {
+          node.contentEditable = "true";
+          const selection = document.getSelection();
+          const range = document.createRange();
+          range.selectNodeContents(node);
+          range.collapse();
+          selection.removeAllRanges();
+          selection.addRange(range);
+        }
+      } else {
+        document.querySelectorAll(".epx-visual-config-input__variable").forEach((span) => {
+          span.contentEditable = "false";
+        });
+        document.querySelectorAll('[data-type="expression"]').forEach((span) => {
+          span.contentEditable = "false";
+        });
+      }
+    },
+    changeLanguageValue(id, v) {
+      const languageValue = {
+        ...this.i18nValue,
+        [id]: v
+      };
+      this.$emit("change-language-config", languageValue);
+    },
+    openContextMenu(e) {
+      this.lastEditRange = window.getSelection().getRangeAt(0);
+      e.stopPropagation();
+      this.showContentMenu = true;
+      const inputRect = this.$refs.configInput.getBoundingClientRect();
+      this.variablePos = {
+        x: 0,
+        y: inputRect.height + 20 + "px"
+      };
+    },
+    selectionChange() {
+      const selection = window.getSelection();
+      if (selection.rangeCount === 0) {
+        return;
+      }
+      const range = selection.getRangeAt(0);
+      if (this.$refs.input.contains(range.startContainer)) {
+        this.range = range;
+        if (selection.focusNode.className !== "epx-visual-config-input__variable" && selection.focusNode.parentNode && selection.focusNode.parentNode.className !== "epx-visual-config-input__variable") {
+          document.querySelectorAll(".epx-visual-config-input__variable").forEach((span) => {
+            span.contentEditable = "false";
+          });
+        }
+      }
+    }
+  },
+  mounted() {
+    if (this.value === null || this.value === void 0) {
+      this.setInputContent(this.defaultValue);
+    } else {
+      this.setInputContent(this.value);
+    }
+    this.initValue = true;
+    this._onWindowClick = () => {
+      this.showContentMenu = false;
+    };
+    window.addEventListener("click", this._onWindowClick);
+    document.addEventListener("selectionchange", this.selectionChange);
+    this.$refs.input.addEventListener("keydown", (e) => {
+      if (e.keyCode === 13) {
+        if (this.range && this.range.startContainer) {
+          let variableSpan = null;
+          if (this.range.startContainer.className === "epx-visual-config-input__variable") {
+            variableSpan = this.range.startContainer;
+          } else if (this.range.startContainer.parentNode.className === "epx-visual-config-input__variable") {
+            variableSpan = this.range.startContainer.parentNode;
+          }
+          if (variableSpan) {
+            e.preventDefault();
+            variableSpan.contentEditable = false;
+            const nextNode = variableSpan.nextSibling;
+            let textNode = null;
+            if (!nextNode || nextNode.nodeType !== 3) {
+              textNode = document.createTextNode();
+              if (!nextNode) {
+                variableSpan.parentNode.appendChild(textNode);
+              } else {
+                variableSpan.parentNode.insertBefore(textNode, nextNode);
+              }
+            } else {
+              textNode = nextNode;
+            }
+            const selection = window.getSelection();
+            const range = selection.getRangeAt(0);
+            range.setStart(textNode, 0);
+            selection.removeAllRanges();
+            selection.addRange(range);
+          }
+        }
+      } else if (e.keyCode === 8) {
+        const startContainer = this.range.startContainer;
+        setTimeout(() => {
+          if (!this.$refs.input.contains(startContainer)) {
+            const selection = window.getSelection();
+            const range = selection.getRangeAt(0);
+            selection.removeAllRanges();
+            selection.addRange(range);
+          }
+        }, 0);
+      }
+    });
+  },
+  unmounted() {
+    window.removeEventListener("click", this._onWindowClick);
+    document.removeEventListener("selectionchange", this.selectionChange);
+  }
+};
+export {
+  _sfc_main as default
+};

package/dist/src/visual/config/LazyDialog.js

@@ -0,0 +1,41 @@
+import '../../../style.css';
+import { h, resolveComponent } from "vue";
+const WARM_TAGS = ["el-dialog", "el-tree"];
+const _sfc_main = {
+  name: "epx-visual-config-lazy-dialog",
+  inheritAttrs: false,
+  data() {
+    return {
+      opened: false
+    };
+  },
+  computed: {
+    visible() {
+      const attrs = this.$attrs;
+      return !!(attrs.modelValue !== void 0 ? attrs.modelValue : attrs["model-value"]);
+    }
+  },
+  watch: {
+    visible: {
+      handler(v) {
+        if (v) this.opened = true;
+      },
+      immediate: true
+    }
+  },
+  created() {
+    const components = this.$.appContext.components;
+    for (const tag of WARM_TAGS) {
+      const comp = components[tag];
+      if (comp && typeof comp.__asyncLoader === "function") comp.__asyncLoader().catch(() => {
+      });
+    }
+  },
+  render() {
+    if (!this.opened) return null;
+    return h(resolveComponent("el-dialog"), this.$attrs, this.$slots);
+  }
+};
+export {
+  _sfc_main as default
+};