@jeecg/online 3.4.3 → 3.4.4-beta2

package/_baseClone.js

@@ -1,5 +1,5 @@
 import { g as getNative, c as isObject, h as baseAssignValue, d as assignValue, i as isLength, j as isFunction, b as isArguments, a as isIndex, L as ListCache, k as Map, M as MapCache, f as arrayPush, t as toSource } from "./_arrayPush.js";
-import { r as root, a as isObjectLike, b as baseGetTag, f as freeGlobal, i as isArray, S as Symbol$1 } from "./isArray.js";
+import { r as root, i as isObjectLike, b as baseGetTag, f as freeGlobal, a as isArray, S as Symbol$1 } from "./isArray.js";
 var WeakMap = getNative(root, "WeakMap");
 var WeakMap$1 = WeakMap;
 var objectCreate = Object.create;

package/_flatRest.js

@@ -1,4 +1,4 @@
-import { i as isArray, S as Symbol$1 } from "./isArray.js";
+import { a as isArray, S as Symbol$1 } from "./isArray.js";
 import { i as isSymbol, t as toString } from "./toString.js";
 import { e as defineProperty, M as MapCache, b as isArguments, f as arrayPush } from "./_arrayPush.js";
 function identity(value) {

package/cgform.data.js

@@ -104,7 +104,7 @@ function useInitialData() {
       isShowList: "0",
       isReadOnly: "1",
       fieldShowType: "text",
-      fieldLength: "120",
+      fieldLength: "200",
       queryMode: "single",
       dbIsSync: "1"
     },
@@ -120,7 +120,7 @@ function useInitialData() {
       isShowForm: "0",
       isShowList: "0",
       fieldShowType: "text",
-      fieldLength: "120",
+      fieldLength: "200",
       queryMode: "single",
       dbIsSync: "1"
     },
@@ -136,7 +136,7 @@ function useInitialData() {
       isShowForm: "0",
       isShowList: "0",
       fieldShowType: "datetime",
-      fieldLength: "120",
+      fieldLength: "200",
       queryMode: "single",
       dbIsSync: "1"
     },
@@ -152,7 +152,7 @@ function useInitialData() {
       isShowForm: "0",
       isShowList: "0",
       fieldShowType: "text",
-      fieldLength: "120",
+      fieldLength: "200",
       queryMode: "single",
       dbIsSync: "1"
     },
@@ -168,7 +168,7 @@ function useInitialData() {
       isShowForm: "0",
       isShowList: "0",
       fieldShowType: "datetime",
-      fieldLength: "120",
+      fieldLength: "200",
       queryMode: "single",
       dbIsSync: "1"
     },
@@ -184,7 +184,7 @@ function useInitialData() {
       isShowForm: "0",
       isShowList: "0",
       fieldShowType: "text",
-      fieldLength: "120",
+      fieldLength: "200",
       queryMode: "single",
       dbIsSync: "1"
     }
@@ -210,7 +210,7 @@ function useTreeNeedFields() {
       isShowForm: "1",
       isShowList: "0",
       fieldShowType: "text",
-      fieldLength: "120",
+      fieldLength: "200",
       queryMode: "single",
       dbIsSync: "1"
     },
@@ -226,7 +226,7 @@ function useTreeNeedFields() {
       isShowForm: "0",
       isShowList: "0",
       fieldShowType: "list",
-      fieldLength: "120",
+      fieldLength: "200",
       queryMode: "single",
       dictField: "yn",
       dbIsSync: "1"

package/clipboard.js

@@ -0,0 +1,565 @@
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from "./_commonjsHelpers.js";
+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(self, call) {
+            if (call && (clipboard_typeof(call) === "object" || typeof call === "function")) {
+              return call;
+            }
+            return _assertThisInitialized(self);
+          }
+          function _assertThisInitialized(self) {
+            if (self === void 0) {
+              throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            }
+            return self;
+          }
+          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 self = this;
+              function listener() {
+                self.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);
+export { Clipboard as C };