@jeecg/online 1.0.1

package/index3.js

@@ -0,0 +1,799 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { defineComponent, resolveComponent, openBlock, createElementBlock, createVNode, unref, withCtx, createBlock, createCommentVNode, createTextVNode } from "vue";
+import { BasicTable, TableAction } from "/@/components/Table";
+import { useListPage } from "/@/hooks/system/useListPage";
+import { l as list, c as columns, s as searchFormSchema, _ as _sfc_main$1, d as deleteOne, b as batchDelete, g as getReportParam } from "./CgreportModal.js";
+import { useModal } from "/@/components/Modal";
+import { useRouter } from "vue-router";
+import "/@/components/Form/index";
+import "/@/hooks/system/useJvxeMethods.ts";
+import "/@/components/jeecg/JVxeTable/types";
+import "/@/views/system/user/user.api";
+import "/@/utils/http/axios";
+import "ant-design-vue";
+import "/@/hooks/web/useMessage";
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var clipboard = { exports: {} };
+/*!
+ * clipboard.js v2.0.11
+ * https://clipboardjs.com/
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+(function(module, exports) {
+  (function webpackUniversalModuleDefinition(root, factory) {
+    module.exports = factory();
+  })(commonjsGlobal, function() {
+    return function() {
+      var __webpack_modules__ = {
+        686: function(__unused_webpack_module, __webpack_exports__, __webpack_require__2) {
+          __webpack_require__2.d(__webpack_exports__, {
+            "default": function() {
+              return clipboard2;
+            }
+          });
+          var tiny_emitter = __webpack_require__2(279);
+          var tiny_emitter_default = /* @__PURE__ */ __webpack_require__2.n(tiny_emitter);
+          var listen = __webpack_require__2(370);
+          var listen_default = /* @__PURE__ */ __webpack_require__2.n(listen);
+          var src_select = __webpack_require__2(817);
+          var select_default = /* @__PURE__ */ __webpack_require__2.n(src_select);
+          function command(type) {
+            try {
+              return document.execCommand(type);
+            } catch (err) {
+              return false;
+            }
+          }
+          var ClipboardActionCut = function ClipboardActionCut2(target) {
+            var selectedText = select_default()(target);
+            command("cut");
+            return selectedText;
+          };
+          var actions_cut = ClipboardActionCut;
+          function createFakeElement(value) {
+            var isRTL = document.documentElement.getAttribute("dir") === "rtl";
+            var fakeElement = document.createElement("textarea");
+            fakeElement.style.fontSize = "12pt";
+            fakeElement.style.border = "0";
+            fakeElement.style.padding = "0";
+            fakeElement.style.margin = "0";
+            fakeElement.style.position = "absolute";
+            fakeElement.style[isRTL ? "right" : "left"] = "-9999px";
+            var yPosition = window.pageYOffset || document.documentElement.scrollTop;
+            fakeElement.style.top = "".concat(yPosition, "px");
+            fakeElement.setAttribute("readonly", "");
+            fakeElement.value = value;
+            return fakeElement;
+          }
+          var fakeCopyAction = function fakeCopyAction2(value, options) {
+            var fakeElement = createFakeElement(value);
+            options.container.appendChild(fakeElement);
+            var selectedText = select_default()(fakeElement);
+            command("copy");
+            fakeElement.remove();
+            return selectedText;
+          };
+          var ClipboardActionCopy = function ClipboardActionCopy2(target) {
+            var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+              container: document.body
+            };
+            var selectedText = "";
+            if (typeof target === "string") {
+              selectedText = fakeCopyAction(target, options);
+            } else if (target instanceof HTMLInputElement && !["text", "search", "url", "tel", "password"].includes(target === null || target === void 0 ? void 0 : target.type)) {
+              selectedText = fakeCopyAction(target.value, options);
+            } else {
+              selectedText = select_default()(target);
+              command("copy");
+            }
+            return selectedText;
+          };
+          var actions_copy = ClipboardActionCopy;
+          function _typeof(obj) {
+            "@babel/helpers - typeof";
+            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+              _typeof = function _typeof2(obj2) {
+                return typeof obj2;
+              };
+            } else {
+              _typeof = function _typeof2(obj2) {
+                return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+              };
+            }
+            return _typeof(obj);
+          }
+          var ClipboardActionDefault = function ClipboardActionDefault2() {
+            var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+            var _options$action = options.action, action = _options$action === void 0 ? "copy" : _options$action, container = options.container, target = options.target, text = options.text;
+            if (action !== "copy" && action !== "cut") {
+              throw new Error('Invalid "action" value, use either "copy" or "cut"');
+            }
+            if (target !== void 0) {
+              if (target && _typeof(target) === "object" && target.nodeType === 1) {
+                if (action === "copy" && target.hasAttribute("disabled")) {
+                  throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
+                }
+                if (action === "cut" && (target.hasAttribute("readonly") || target.hasAttribute("disabled"))) {
+                  throw new Error(`Invalid "target" attribute. You can't cut text from elements with "readonly" or "disabled" attributes`);
+                }
+              } else {
+                throw new Error('Invalid "target" value, use a valid Element');
+              }
+            }
+            if (text) {
+              return actions_copy(text, {
+                container
+              });
+            }
+            if (target) {
+              return action === "cut" ? actions_cut(target) : actions_copy(target, {
+                container
+              });
+            }
+          };
+          var actions_default = ClipboardActionDefault;
+          function clipboard_typeof(obj) {
+            "@babel/helpers - typeof";
+            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+              clipboard_typeof = function _typeof2(obj2) {
+                return typeof obj2;
+              };
+            } else {
+              clipboard_typeof = function _typeof2(obj2) {
+                return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+              };
+            }
+            return clipboard_typeof(obj);
+          }
+          function _classCallCheck(instance, Constructor) {
+            if (!(instance instanceof Constructor)) {
+              throw new TypeError("Cannot call a class as a function");
+            }
+          }
+          function _defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+              var descriptor = props[i];
+              descriptor.enumerable = descriptor.enumerable || false;
+              descriptor.configurable = true;
+              if ("value" in descriptor)
+                descriptor.writable = true;
+              Object.defineProperty(target, descriptor.key, descriptor);
+            }
+          }
+          function _createClass(Constructor, protoProps, staticProps) {
+            if (protoProps)
+              _defineProperties(Constructor.prototype, protoProps);
+            if (staticProps)
+              _defineProperties(Constructor, staticProps);
+            return Constructor;
+          }
+          function _inherits(subClass, superClass) {
+            if (typeof superClass !== "function" && superClass !== null) {
+              throw new TypeError("Super expression must either be null or a function");
+            }
+            subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+            if (superClass)
+              _setPrototypeOf(subClass, superClass);
+          }
+          function _setPrototypeOf(o, p) {
+            _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+              o2.__proto__ = p2;
+              return o2;
+            };
+            return _setPrototypeOf(o, p);
+          }
+          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 _possibleConstructorReturn(self2, call) {
+            if (call && (clipboard_typeof(call) === "object" || typeof call === "function")) {
+              return call;
+            }
+            return _assertThisInitialized(self2);
+          }
+          function _assertThisInitialized(self2) {
+            if (self2 === void 0) {
+              throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            }
+            return self2;
+          }
+          function _isNativeReflectConstruct() {
+            if (typeof Reflect === "undefined" || !Reflect.construct)
+              return false;
+            if (Reflect.construct.sham)
+              return false;
+            if (typeof Proxy === "function")
+              return true;
+            try {
+              Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+              }));
+              return true;
+            } catch (e) {
+              return false;
+            }
+          }
+          function _getPrototypeOf(o) {
+            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+              return o2.__proto__ || Object.getPrototypeOf(o2);
+            };
+            return _getPrototypeOf(o);
+          }
+          function getAttributeValue(suffix, element) {
+            var attribute = "data-clipboard-".concat(suffix);
+            if (!element.hasAttribute(attribute)) {
+              return;
+            }
+            return element.getAttribute(attribute);
+          }
+          var Clipboard2 = /* @__PURE__ */ function(_Emitter) {
+            _inherits(Clipboard3, _Emitter);
+            var _super = _createSuper(Clipboard3);
+            function Clipboard3(trigger, options) {
+              var _this;
+              _classCallCheck(this, Clipboard3);
+              _this = _super.call(this);
+              _this.resolveOptions(options);
+              _this.listenClick(trigger);
+              return _this;
+            }
+            _createClass(Clipboard3, [{
+              key: "resolveOptions",
+              value: function resolveOptions() {
+                var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+                this.action = typeof options.action === "function" ? options.action : this.defaultAction;
+                this.target = typeof options.target === "function" ? options.target : this.defaultTarget;
+                this.text = typeof options.text === "function" ? options.text : this.defaultText;
+                this.container = clipboard_typeof(options.container) === "object" ? options.container : document.body;
+              }
+            }, {
+              key: "listenClick",
+              value: function listenClick(trigger) {
+                var _this2 = this;
+                this.listener = listen_default()(trigger, "click", function(e) {
+                  return _this2.onClick(e);
+                });
+              }
+            }, {
+              key: "onClick",
+              value: function onClick(e) {
+                var trigger = e.delegateTarget || e.currentTarget;
+                var action = this.action(trigger) || "copy";
+                var text = actions_default({
+                  action,
+                  container: this.container,
+                  target: this.target(trigger),
+                  text: this.text(trigger)
+                });
+                this.emit(text ? "success" : "error", {
+                  action,
+                  text,
+                  trigger,
+                  clearSelection: function clearSelection() {
+                    if (trigger) {
+                      trigger.focus();
+                    }
+                    window.getSelection().removeAllRanges();
+                  }
+                });
+              }
+            }, {
+              key: "defaultAction",
+              value: function defaultAction(trigger) {
+                return getAttributeValue("action", trigger);
+              }
+            }, {
+              key: "defaultTarget",
+              value: function defaultTarget(trigger) {
+                var selector = getAttributeValue("target", trigger);
+                if (selector) {
+                  return document.querySelector(selector);
+                }
+              }
+            }, {
+              key: "defaultText",
+              value: function defaultText(trigger) {
+                return getAttributeValue("text", trigger);
+              }
+            }, {
+              key: "destroy",
+              value: function destroy() {
+                this.listener.destroy();
+              }
+            }], [{
+              key: "copy",
+              value: function copy(target) {
+                var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+                  container: document.body
+                };
+                return actions_copy(target, options);
+              }
+            }, {
+              key: "cut",
+              value: function cut(target) {
+                return actions_cut(target);
+              }
+            }, {
+              key: "isSupported",
+              value: function isSupported() {
+                var action = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : ["copy", "cut"];
+                var actions = typeof action === "string" ? [action] : action;
+                var support = !!document.queryCommandSupported;
+                actions.forEach(function(action2) {
+                  support = support && !!document.queryCommandSupported(action2);
+                });
+                return support;
+              }
+            }]);
+            return Clipboard3;
+          }(tiny_emitter_default());
+          var clipboard2 = Clipboard2;
+        },
+        828: function(module2) {
+          var DOCUMENT_NODE_TYPE = 9;
+          if (typeof Element !== "undefined" && !Element.prototype.matches) {
+            var proto = Element.prototype;
+            proto.matches = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector || proto.webkitMatchesSelector;
+          }
+          function closest(element, selector) {
+            while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
+              if (typeof element.matches === "function" && element.matches(selector)) {
+                return element;
+              }
+              element = element.parentNode;
+            }
+          }
+          module2.exports = closest;
+        },
+        438: function(module2, __unused_webpack_exports, __webpack_require__2) {
+          var closest = __webpack_require__2(828);
+          function _delegate(element, selector, type, callback, useCapture) {
+            var listenerFn = listener.apply(this, arguments);
+            element.addEventListener(type, listenerFn, useCapture);
+            return {
+              destroy: function() {
+                element.removeEventListener(type, listenerFn, useCapture);
+              }
+            };
+          }
+          function delegate(elements, selector, type, callback, useCapture) {
+            if (typeof elements.addEventListener === "function") {
+              return _delegate.apply(null, arguments);
+            }
+            if (typeof type === "function") {
+              return _delegate.bind(null, document).apply(null, arguments);
+            }
+            if (typeof elements === "string") {
+              elements = document.querySelectorAll(elements);
+            }
+            return Array.prototype.map.call(elements, function(element) {
+              return _delegate(element, selector, type, callback, useCapture);
+            });
+          }
+          function listener(element, selector, type, callback) {
+            return function(e) {
+              e.delegateTarget = closest(e.target, selector);
+              if (e.delegateTarget) {
+                callback.call(element, e);
+              }
+            };
+          }
+          module2.exports = delegate;
+        },
+        879: function(__unused_webpack_module, exports2) {
+          exports2.node = function(value) {
+            return value !== void 0 && value instanceof HTMLElement && value.nodeType === 1;
+          };
+          exports2.nodeList = function(value) {
+            var type = Object.prototype.toString.call(value);
+            return value !== void 0 && (type === "[object NodeList]" || type === "[object HTMLCollection]") && "length" in value && (value.length === 0 || exports2.node(value[0]));
+          };
+          exports2.string = function(value) {
+            return typeof value === "string" || value instanceof String;
+          };
+          exports2.fn = function(value) {
+            var type = Object.prototype.toString.call(value);
+            return type === "[object Function]";
+          };
+        },
+        370: function(module2, __unused_webpack_exports, __webpack_require__2) {
+          var is = __webpack_require__2(879);
+          var delegate = __webpack_require__2(438);
+          function listen(target, type, callback) {
+            if (!target && !type && !callback) {
+              throw new Error("Missing required arguments");
+            }
+            if (!is.string(type)) {
+              throw new TypeError("Second argument must be a String");
+            }
+            if (!is.fn(callback)) {
+              throw new TypeError("Third argument must be a Function");
+            }
+            if (is.node(target)) {
+              return listenNode(target, type, callback);
+            } else if (is.nodeList(target)) {
+              return listenNodeList(target, type, callback);
+            } else if (is.string(target)) {
+              return listenSelector(target, type, callback);
+            } else {
+              throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList");
+            }
+          }
+          function listenNode(node, type, callback) {
+            node.addEventListener(type, callback);
+            return {
+              destroy: function() {
+                node.removeEventListener(type, callback);
+              }
+            };
+          }
+          function listenNodeList(nodeList, type, callback) {
+            Array.prototype.forEach.call(nodeList, function(node) {
+              node.addEventListener(type, callback);
+            });
+            return {
+              destroy: function() {
+                Array.prototype.forEach.call(nodeList, function(node) {
+                  node.removeEventListener(type, callback);
+                });
+              }
+            };
+          }
+          function listenSelector(selector, type, callback) {
+            return delegate(document.body, selector, type, callback);
+          }
+          module2.exports = listen;
+        },
+        817: function(module2) {
+          function select(element) {
+            var selectedText;
+            if (element.nodeName === "SELECT") {
+              element.focus();
+              selectedText = element.value;
+            } else if (element.nodeName === "INPUT" || element.nodeName === "TEXTAREA") {
+              var isReadOnly = element.hasAttribute("readonly");
+              if (!isReadOnly) {
+                element.setAttribute("readonly", "");
+              }
+              element.select();
+              element.setSelectionRange(0, element.value.length);
+              if (!isReadOnly) {
+                element.removeAttribute("readonly");
+              }
+              selectedText = element.value;
+            } else {
+              if (element.hasAttribute("contenteditable")) {
+                element.focus();
+              }
+              var selection = window.getSelection();
+              var range = document.createRange();
+              range.selectNodeContents(element);
+              selection.removeAllRanges();
+              selection.addRange(range);
+              selectedText = selection.toString();
+            }
+            return selectedText;
+          }
+          module2.exports = select;
+        },
+        279: function(module2) {
+          function E() {
+          }
+          E.prototype = {
+            on: function(name, callback, ctx) {
+              var e = this.e || (this.e = {});
+              (e[name] || (e[name] = [])).push({
+                fn: callback,
+                ctx
+              });
+              return this;
+            },
+            once: function(name, callback, ctx) {
+              var self2 = this;
+              function listener() {
+                self2.off(name, listener);
+                callback.apply(ctx, arguments);
+              }
+              listener._ = callback;
+              return this.on(name, listener, ctx);
+            },
+            emit: function(name) {
+              var data = [].slice.call(arguments, 1);
+              var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+              var i = 0;
+              var len = evtArr.length;
+              for (i; i < len; i++) {
+                evtArr[i].fn.apply(evtArr[i].ctx, data);
+              }
+              return this;
+            },
+            off: function(name, callback) {
+              var e = this.e || (this.e = {});
+              var evts = e[name];
+              var liveEvents = [];
+              if (evts && callback) {
+                for (var i = 0, len = evts.length; i < len; i++) {
+                  if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+                    liveEvents.push(evts[i]);
+                }
+              }
+              liveEvents.length ? e[name] = liveEvents : delete e[name];
+              return this;
+            }
+          };
+          module2.exports = E;
+          module2.exports.TinyEmitter = E;
+        }
+      };
+      var __webpack_module_cache__ = {};
+      function __webpack_require__(moduleId) {
+        if (__webpack_module_cache__[moduleId]) {
+          return __webpack_module_cache__[moduleId].exports;
+        }
+        var module2 = __webpack_module_cache__[moduleId] = {
+          exports: {}
+        };
+        __webpack_modules__[moduleId](module2, module2.exports, __webpack_require__);
+        return module2.exports;
+      }
+      !function() {
+        __webpack_require__.n = function(module2) {
+          var getter = module2 && module2.__esModule ? function() {
+            return module2["default"];
+          } : function() {
+            return module2;
+          };
+          __webpack_require__.d(getter, { a: getter });
+          return getter;
+        };
+      }();
+      !function() {
+        __webpack_require__.d = function(exports2, definition) {
+          for (var key in definition) {
+            if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports2, key)) {
+              Object.defineProperty(exports2, key, { enumerable: true, get: definition[key] });
+            }
+          }
+        };
+      }();
+      !function() {
+        __webpack_require__.o = function(obj, prop) {
+          return Object.prototype.hasOwnProperty.call(obj, prop);
+        };
+      }();
+      return __webpack_require__(686);
+    }().default;
+  });
+})(clipboard);
+var Clipboard = /* @__PURE__ */ getDefaultExportFromCjs(clipboard.exports);
+const _hoisted_1 = /* @__PURE__ */ createTextVNode("\u5F55\u5165");
+const _hoisted_2 = /* @__PURE__ */ createTextVNode(" \u5220\u9664 ");
+const _hoisted_3 = /* @__PURE__ */ createTextVNode("\u6279\u91CF\u64CD\u4F5C ");
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  name: "index",
+  setup(__props) {
+    let router = useRouter();
+    const [registerModal, { openModal }] = useModal();
+    const { prefixCls, tableContext, createMessage: $message, createConfirm: $confirm } = useListPage({
+      designScope: "online-cgreport-list",
+      pagination: true,
+      tableProps: {
+        title: "Online\u62A5\u8868",
+        api: list,
+        rowKey: "id",
+        columns,
+        formConfig: {
+          autoSubmitOnEnter: true,
+          showAdvancedButton: true,
+          schemas: searchFormSchema
+        }
+      }
+    });
+    const [registerTable, { reload }, { rowSelection, selectedRowKeys }] = tableContext;
+    function handleAdd() {
+      openModal(true, {
+        isUpdate: false,
+        showFooter: true
+      });
+    }
+    function handleEdit(record) {
+      openModal(true, {
+        record,
+        isUpdate: true,
+        showFooter: true
+      });
+    }
+    function handleDelete(record) {
+      return __async(this, null, function* () {
+        yield deleteOne({ id: record.id }, reload);
+      });
+    }
+    function batchHandleDelete() {
+      return __async(this, null, function* () {
+        yield batchDelete({ ids: selectedRowKeys.value }, () => {
+          reload();
+          selectedRowKeys.value = [];
+        });
+      });
+    }
+    function handleSuccess() {
+      reload();
+    }
+    function getAction(record) {
+      return [
+        {
+          label: "\u7F16\u8F91",
+          onClick: handleEdit.bind(null, record)
+        }
+      ];
+    }
+    function getDropDownAction(record) {
+      return [
+        {
+          label: "\u529F\u80FD\u6D4B\u8BD5",
+          onClick: () => onShowList(record.id)
+        },
+        {
+          label: "\u914D\u7F6E\u5730\u5740",
+          onClick: () => onShowOnlineUrl(record)
+        },
+        {
+          label: "\u5220\u9664",
+          popConfirm: {
+            title: "\u662F\u5426\u786E\u8BA4\u5220\u9664",
+            confirm: handleDelete.bind(null, record)
+          }
+        }
+      ];
+    }
+    function onShowList(id) {
+      router.push({ path: "/online/cgreport/" + id });
+    }
+    function onShowOnlineUrl(record) {
+      let id = record.id;
+      let baseUrl = `/online/cgreport/${id}`;
+      getReportParam(id).then((arr) => {
+        let urlParam = "";
+        if (arr && arr.length > 0) {
+          for (let i of arr) {
+            urlParam += i.paramName + "=${" + i.paramName + "}&";
+          }
+        }
+        if (urlParam.length > 0) {
+          urlParam = urlParam.substring(0, urlParam.length - 1);
+          baseUrl += "?" + urlParam;
+        }
+      }).catch(() => {
+        $message.warning("\u83B7\u53D6\u53C2\u6570\u5931\u8D25!");
+      }).finally(() => {
+        $confirm({
+          iconType: "info",
+          width: 500,
+          title: `\u83DC\u5355\u94FE\u63A5\u3010${record.name}\u3011`,
+          content: baseUrl,
+          maskClosable: true,
+          okText: "\u590D\u5236",
+          okButtonProps: {
+            class: "copy-this-text",
+            "data-clipboard-text": baseUrl
+          },
+          onOk() {
+            return new Promise((resolve) => {
+              const clipboard2 = new Clipboard(".copy-this-text");
+              clipboard2.on("success", () => {
+                clipboard2.destroy();
+                $message.success("\u590D\u5236\u6210\u529F");
+                resolve();
+              });
+              clipboard2.on("error", () => {
+                $message.error("\u8BE5\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u81EA\u52A8\u590D\u5236");
+                clipboard2.destroy();
+                resolve();
+              });
+            });
+          }
+        });
+      });
+    }
+    return (_ctx, _cache) => {
+      const _component_a_button = resolveComponent("a-button");
+      const _component_Icon = resolveComponent("Icon");
+      const _component_a_menu_item = resolveComponent("a-menu-item");
+      const _component_a_menu = resolveComponent("a-menu");
+      const _component_a_dropdown = resolveComponent("a-dropdown");
+      return openBlock(), createElementBlock("div", null, [
+        createVNode(unref(BasicTable), {
+          onRegister: unref(registerTable),
+          rowSelection: unref(rowSelection)
+        }, {
+          tableTitle: withCtx(() => [
+            createVNode(_component_a_button, {
+              preIcon: "ant-design:plus-outlined",
+              type: "primary",
+              onClick: handleAdd,
+              style: { "margin-right": "5px" }
+            }, {
+              default: withCtx(() => [
+                _hoisted_1
+              ]),
+              _: 1
+            }),
+            unref(selectedRowKeys).length > 0 ? (openBlock(), createBlock(_component_a_dropdown, { key: 0 }, {
+              overlay: withCtx(() => [
+                createVNode(_component_a_menu, null, {
+                  default: withCtx(() => [
+                    createVNode(_component_a_menu_item, {
+                      key: "1",
+                      onClick: batchHandleDelete
+                    }, {
+                      default: withCtx(() => [
+                        createVNode(_component_Icon, { icon: "ant-design:delete-outlined" }),
+                        _hoisted_2
+                      ]),
+                      _: 1
+                    })
+                  ]),
+                  _: 1
+                })
+              ]),
+              default: withCtx(() => [
+                createVNode(_component_a_button, null, {
+                  default: withCtx(() => [
+                    _hoisted_3,
+                    createVNode(_component_Icon, { icon: "mdi:chevron-down" })
+                  ]),
+                  _: 1
+                })
+              ]),
+              _: 1
+            })) : createCommentVNode("", true)
+          ]),
+          action: withCtx(({ record }) => [
+            createVNode(unref(TableAction), {
+              actions: getAction(record),
+              dropDownActions: getDropDownAction(record)
+            }, null, 8, ["actions", "dropDownActions"])
+          ]),
+          _: 1
+        }, 8, ["onRegister", "rowSelection"]),
+        createVNode(_sfc_main$1, {
+          onRegister: unref(registerModal),
+          onSuccess: handleSuccess
+        }, null, 8, ["onRegister"])
+      ]);
+    };
+  }
+});
+export { _sfc_main as default };