hy-dispatch-ui-v3 0.1.5 → 0.2.0

package/lib/static/protocolcheck.js

@@ -0,0 +1,249 @@
+'use strict';
+
+(function (f) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') {
+    module.exports = f();
+  } else if (typeof define === 'function' && define.amd) {
+    define([], f);
+  } else {
+    var g;
+    if (typeof window !== 'undefined') {
+      g = window;
+    } else if (typeof global !== 'undefined') {
+      g = global;
+    } else if (typeof self !== 'undefined') {
+      g = self;
+    } else {
+      g = this;
+    }
+    g.protocolCheck = f();
+  }
+})(function () {
+  return (function e(t, n, r) {
+    function s(o, u) {
+      if (!n[o]) {
+        if (!t[o]) {
+          var a = typeof require == 'function' && require;
+          if (!u && a) return a(o, true)
+          if (i) return i(o, true)
+          var f = new Error("Cannot find module '" + o + "'");
+          throw ((f.code = 'MODULE_NOT_FOUND'), f)
+        }
+        var l = (n[o] = { exports: {} });
+        t[o][0].call(
+          l.exports,
+          function (e) {
+            var n = t[o][1][e];
+            return s(n ? n : e)
+          },
+          l,
+          l.exports,
+          e,
+          t,
+          n,
+          r
+        );
+      }
+      return n[o].exports
+    }
+    var i = typeof require == 'function' && require;
+    for (var o = 0; o < r.length; o++) s(r[o]);
+    return s
+  })(
+    {
+      1: [
+        function (require, module, exports$1) {
+          function _registerEvent(target, eventType, cb) {
+            if (target.addEventListener) {
+              target.addEventListener(eventType, cb);
+              return {
+                remove: function () {
+                  target.removeEventListener(eventType, cb);
+                },
+              }
+            } else {
+              target.attachEvent(eventType, cb);
+              return {
+                remove: function () {
+                  target.detachEvent(eventType, cb);
+                },
+              }
+            }
+          }
+
+          function _createHiddenIframe(target, uri) {
+            var iframe = document.createElement('iframe');
+            iframe.src = uri;
+            iframe.id = 'hiddenIframe';
+            iframe.style.display = 'none';
+            target.appendChild(iframe);
+
+            return iframe
+          }
+
+          function openUriWithHiddenFrame(uri, failCb, successCb) {
+            var timeout = setTimeout(function () {
+              failCb();
+              handler.remove();
+            }, 1000);
+
+            var iframe = document.querySelector('#hiddenIframe');
+            if (!iframe) {
+              iframe = _createHiddenIframe(document.body, 'about:blank');
+            }
+
+            var handler = _registerEvent(window, 'blur', onBlur);
+
+            function onBlur() {
+              clearTimeout(timeout);
+              handler.remove();
+              successCb();
+            }
+
+            iframe.contentWindow.location.href = uri;
+          }
+
+          function openUriUsingFirefox(uri, failCb, successCb) {
+            var iframe = document.querySelector('#hiddenIframe');
+
+            if (!iframe) {
+              iframe = _createHiddenIframe(document.body, 'about:blank');
+            }
+
+            try {
+              iframe.contentWindow.location.href = uri;
+              successCb();
+            } catch (e) {
+              if (e.name == 'NS_ERROR_UNKNOWN_PROTOCOL') {
+                failCb();
+              }
+            }
+          }
+
+          function openUriUsingIEInOlderWindows(uri, failCb, successCb) {
+            if (getInternetExplorerVersion() === 10) {
+              openUriUsingIE10InWindows7(uri, failCb, successCb);
+            } else if (
+              getInternetExplorerVersion() === 9 ||
+              getInternetExplorerVersion() === 11
+            ) {
+              openUriWithHiddenFrame(uri, failCb, successCb);
+            } else {
+              openUriInNewWindowHack(uri, failCb, successCb);
+            }
+          }
+
+          function openUriUsingIE10InWindows7(uri, failCb, successCb) {
+            var timeout = setTimeout(failCb, 1000);
+            window.addEventListener('blur', function () {
+              clearTimeout(timeout);
+              successCb();
+            });
+
+            var iframe = document.querySelector('#hiddenIframe');
+            if (!iframe) {
+              iframe = _createHiddenIframe(document.body, 'about:blank');
+            }
+            try {
+              iframe.contentWindow.location.href = uri;
+            } catch (e) {
+              failCb();
+              clearTimeout(timeout);
+            }
+          }
+
+          function openUriInNewWindowHack(uri, failCb, successCb) {
+            var myWindow = window.open('', '', 'width=0,height=0');
+
+            myWindow.document.write("<iframe src='" + uri + "'></iframe>");
+
+            setTimeout(function () {
+              try {
+                myWindow.location.href;
+                myWindow.setTimeout('window.close()', 1000);
+                successCb();
+              } catch (e) {
+                myWindow.close();
+                failCb();
+              }
+            }, 1000);
+          }
+
+          function openUriWithMsLaunchUri(uri, failCb, successCb) {
+            navigator.msLaunchUri(uri, successCb, failCb);
+          }
+
+          function checkBrowser() {
+            var isOpera =
+              !!window.opera || navigator.userAgent.indexOf(' OPR/') >= 0;
+            var ua = navigator.userAgent.toLowerCase();
+            return {
+              isOpera: isOpera,
+              isFirefox: typeof InstallTrigger !== 'undefined',
+              isSafari:
+                (~ua.indexOf('safari') && !~ua.indexOf('chrome')) ||
+                Object.prototype.toString
+                  .call(window.HTMLElement)
+                  .indexOf('Constructor') > 0,
+              isIOS:
+                /iPad|iPhone|iPod/.test(navigator.userAgent) &&
+                !window.MSStream,
+              isChrome: !!window.chrome && !isOpera,
+              isIE: /*@cc_on!@*/ !!document.documentMode, // At least IE6
+            }
+          }
+
+          function getInternetExplorerVersion() {
+            var rv = -1;
+            if (navigator.appName === 'Microsoft Internet Explorer') {
+              var ua = navigator.userAgent;
+              var re = new RegExp('MSIE ([0-9]{1,}[\.0-9]{0,})');
+              if (re.exec(ua) != null) rv = parseFloat(RegExp.$1);
+            } else if (navigator.appName === 'Netscape') {
+              var ua = navigator.userAgent;
+              var re = new RegExp('Trident/.*rv:([0-9]{1,}[\.0-9]{0,})');
+              if (re.exec(ua) != null) {
+                rv = parseFloat(RegExp.$1);
+              }
+            }
+            return rv
+          }
+
+          module.exports = function (uri, failCb, successCb, unsupportedCb) {
+            function failCallback() {
+              failCb && failCb();
+            }
+
+            function successCallback() {
+              successCb && successCb();
+            }
+
+            if (navigator.msLaunchUri) {
+              //for IE and Edge in Win 8 and Win 10
+              openUriWithMsLaunchUri(uri, failCb, successCb);
+            } else {
+              var browser = checkBrowser();
+
+              if (browser.isFirefox) {
+                openUriUsingFirefox(uri, failCallback, successCallback);
+              } else if (browser.isChrome || browser.isIOS) {
+                // openUriWithTimeoutHack(uri, failCallback, successCallback);
+                openUriWithHiddenFrame(uri, failCallback, successCallback);
+              } else if (browser.isIE) {
+                openUriUsingIEInOlderWindows(uri, failCallback, successCallback);
+              } else if (browser.isSafari) {
+                openUriWithHiddenFrame(uri, failCallback, successCallback);
+              } else {
+                unsupportedCb();
+                //not supported, implement please
+              }
+            }
+          };
+        },
+        {},
+      ],
+    },
+    {},
+    [1]
+  )(1)
+});

package/lib/style/element/element.scss

@@ -16311,3 +16311,12 @@
   overflow: auto;
   scrollbar-width: thin;
 }
+
+// 虚拟表格
+.hy-el-table-v2 {
+  color: rgba(var(--hy-main));
+}
+.hy-el-table-v2__header-cell,
+.hy-el-table-v2__row-cell {
+  padding: 0 12px;
+}

package/lib/style/element/index.scss

@@ -39,7 +39,6 @@
   --hy-el-table-index: var(--hy-el-index-normal);
   position: relative;
   overflow: hidden;
-  box-sizing: border-box;
   height: -moz-fit-content;
   height: fit-content;
   width: 100%;
@@ -175,13 +174,12 @@
   --hy-el-input-clear-hover-color: var(--hy-el-text-color-secondary);
   --hy-el-input-focus-border-color: rgb(var(--hy-theme));
   --hy-el-input-width: 100%;
-  --hy-el-input-height: var(--hy-el-component-size);
+  // --hy-el-input-height: var(--hy-el-component-size);
   position: relative;
   font-size: var(--hy-el-font-size-base);
   display: inline-flex;
   width: var(--hy-el-input-width);
   line-height: var(--hy-el-input-height);
-  box-sizing: border-box;
   vertical-align: middle;
 }
 
@@ -591,6 +589,7 @@
 // 下拉框
 .hy-el-dropdown__popper.hy-el-popper {
   --hy-el-border-color-light: rgb(var(--hy-border));
+  --hy-el-dropdown-menuItem-hover-fill: rgb(var(--hy-background-3));
 }
 
 .hy-el-dropdown-menu {
@@ -930,3 +929,7 @@
 .hy-el-switch__core .hy-el-switch__inner-wrapper {
   color: rgb(var(--hy-auxiliary));
 }
+
+.hy-el-slider {
+  --hy-el-slider-runway-bg-color: rgba(var(--hy-background));
+}

package/lib/style/index.scss

@@ -3,6 +3,7 @@
 * {
   margin: 0;
   padding: 0;
+  box-sizing: border-box;
 }
 html,
 body,
@@ -79,3 +80,13 @@ video {
   -webkit-box-orient: vertical;
   word-break: break-all;
 }
+
+/*禁止选中文本*/
+.user-select-none {
+  -webkit-touch-callout: none; /*系统默认菜单被禁用*/
+  -webkit-user-select: none; /*webkit浏览器*/
+  -khtml-user-select: none; /*早期浏览器*/
+  -moz-user-select: none; /*火狐*/
+  -ms-user-select: none; /*IE10*/
+  user-select: none;
+}

package/lib/style/theme.scss

@@ -19,3 +19,76 @@
   --hy-background-4: 16, 38, 59; // 斑马纹备用色
   --hy-border: 54, 93, 132;
 }
+
+.search_lightColor {
+  min-width: 254px;
+  line-height: 32px;
+  background: rgba(var(--hy-background), 1);
+  border-radius: 8px;
+  padding: 4px;
+  display: flex;
+  border: 1px solid rgba(var(--hy-border), 1);
+  transition: 0.3s;
+  position: relative;
+  z-index: 1;
+}
+
+.search_lightColor:focus,
+.search_lightColor:hover {
+  border-color: rgba(var(--hy-theme), 1);
+}
+
+.search_lightColor .hy-el-input .hy-el-input__wrapper {
+  background: rgba(var(--hy-background), 1);
+  border-color: rgba(var(--hy-background), 1);
+  box-shadow: none;
+  padding: 0 26px 0 10px;
+  font-size: 12px;
+  color: rgba(var(--hy-main), 1);
+}
+
+.search_lightColor .hy-el-input .hy-el-input__wrapper:focus,
+.search_lightColor .hy-el-input .hy-el-input__wrapper:hover {
+  border-color: rgba(var(--hy-background), 1);
+  box-shadow: none;
+}
+
+.search_lightColor .searchBox:active {
+  opacity: 0.6;
+}
+
+.search_lightColor .searchBox {
+  width: 42px;
+  height: 32px;
+  background: rgba(var(--hy-background-3), 1);
+  border-radius: 8px;
+  line-height: 30px;
+  text-align: center;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+}
+
+.search_lightColor .searchBox .svgBox {
+  width: 18px;
+  height: 18px;
+  vertical-align: middle;
+}
+
+.deviceType-sos {
+  font-size: 14px;
+  font-weight: bold;
+  color: rgba(var(--hy-danger), 1);
+  position: relative;
+  top: 2px;
+}
+
+.deviceType {
+  font-size: 12px;
+  font-weight: bold;
+  color: rgba(var(--hy-main), 1);
+  background: linear-gradient(270deg, #27acff 0%, #2ddbf4 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+}

package/lib/utils/date.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var is = require('./is.js');
+
 function getDefaultValueFormatByType(type = "date") {
   switch (type) {
     case "year":
@@ -22,5 +24,28 @@ function getDefaultValueFormatByType(type = "date") {
       return "YYYY-MM-DD";
   }
 }
+function formatDuration(duration, isSecond = false) {
+  if (!duration || !is.isNumber(duration)) return;
+  duration = isSecond ? duration * 1e3 : duration;
+  const list = [];
+  if (duration > 60 * 60 * 1e3) {
+    list.push(Math.floor(duration / (60 * 60 * 1e3)));
+    duration = duration % (60 * 60 * 1e3);
+  }
+  if (duration > 60 * 1e3) {
+    list.push(Math.floor(duration / (60 * 1e3)));
+    duration = duration % (60 * 1e3);
+  } else if (!list.length) {
+    list.push(0);
+  }
+  if (duration > 1e3) {
+    list.push(Math.floor(duration / 1e3));
+  } else {
+    list.push(0);
+  }
+  if (!list.length) return;
+  return list.map((val) => val >= 10 ? val : `0${val}`).join(":");
+}
 
+exports.formatDuration = formatDuration;
 exports.getDefaultValueFormatByType = getDefaultValueFormatByType;

package/lib/utils/file.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var vue = require('vue');
+var handler = require('./handler.js');
+var useApi = require('../hooks/useApi.js');
+
+function blobToDataURL(bolb) {
+  return new Promise((resolve) => {
+    const a = new FileReader();
+    a.onload = function(e) {
+      resolve(e.target.result);
+    };
+    a.readAsDataURL(bolb);
+  });
+}
+async function presignedUrl(file) {
+  const { api } = useApi.useApi();
+  const fileList = file.name.split(".");
+  const res = await vue.unref(api).post("file/presignedUrl", {
+    fileName: `${handler.createUniqueId(1)}.${fileList[fileList.length - 1]}`
+  });
+  if (res.code === 200) {
+    return res;
+  } else {
+    return Promise.reject(res);
+  }
+}
+async function fileJsonUplaod(file) {
+  const { api } = useApi.useApi();
+  const result = await presignedUrl(file);
+  await vue.unref(api).put(result.data.url, file, {
+    otherUrl: true,
+    xAmzAcl: true
+  });
+  return result;
+}
+async function fileFormUpload(file) {
+  const { api } = useApi.useApi();
+  try {
+    const formData = new FormData();
+    formData.append("file", file);
+    const res = await vue.unref(api).post("/file/upload", formData, {
+      otherUrl: true,
+      xAmzAcl: false
+    });
+    return res;
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function fileUpload(file, directTransmission = true) {
+  if (directTransmission) {
+    return await fileJsonUplaod(file);
+  } else {
+    return await fileFormUpload(file);
+  }
+}
+async function sizeToTextHandler(size) {
+  if (size < Math.pow(1024, 1)) {
+    return `${Math.floor(size / Math.pow(1024, 1) / 100) * 100}KB`;
+  }
+  if (size < Math.pow(1024, 2)) {
+    return `${Math.floor(size / Math.pow(1024, 2) / 100) * 100}MB`;
+  }
+  if (size < Math.pow(1024, 3)) {
+    return `${Math.floor(size / Math.pow(1024, 3) / 100) * 100}GB`;
+  }
+  return `${Math.floor(size / Math.pow(1024, 4) / 100) * 100}TB`;
+}
+
+exports.blobToDataURL = blobToDataURL;
+exports.fileFormUpload = fileFormUpload;
+exports.fileJsonUplaod = fileJsonUplaod;
+exports.fileUpload = fileUpload;
+exports.presignedUrl = presignedUrl;
+exports.sizeToTextHandler = sizeToTextHandler;

package/lib/utils/form.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var is = require('./is.js');
+
+function getValueByProp(model, prop) {
+  if (is.isString(prop)) {
+    prop = prop.split(".").filter(Boolean);
+  }
+  if (!is.isArray(prop) || !prop?.length) return;
+  return prop.reduce((o, k) => o?.[k], model);
+}
+function setValueByProp(model, prop, value) {
+  let keys = [];
+  if (is.isString(prop)) {
+    keys = prop.split(".").filter(Boolean);
+  }
+  if (!is.isArray(keys) || !keys?.length) return;
+  const lastKey = keys.pop();
+  const parent = keys.reduce((o, k) => o?.[k], model);
+  if (parent) {
+    parent[lastKey] = value;
+  }
+}
+function genValueByProp(model = {}, prop, value) {
+  let keys = [];
+  if (is.isString(prop)) {
+    keys = prop.split(".").filter(Boolean);
+  }
+  if (!is.isArray(keys) || !keys?.length) return;
+  const lastKey = keys.pop();
+  const parent = keys.reduce((o, k) => {
+    if (!o?.[k]) {
+      o[k] = {};
+    }
+    return o[k];
+  }, model);
+  parent[lastKey] = value;
+  return model;
+}
+function clearSpace(value, type = "between") {
+  if (!is.isString(value)) return value;
+  if (type === "between") {
+    value = value.replace(/(^ *)|( *$)/g, "");
+  } else if (type === "before") {
+    value = value.replace(/^ */g, "");
+  } else if (type === "after") {
+    value = value.replace(/ *$/g, "");
+  } else if (type === "all") {
+    value = value.replace(/ /g, "");
+  }
+  return value;
+}
+
+exports.clearSpace = clearSpace;
+exports.genValueByProp = genValueByProp;
+exports.getValueByProp = getValueByProp;
+exports.setValueByProp = setValueByProp;

package/lib/utils/handler.js

@@ -6,7 +6,7 @@ function funRunHandler(target, ...args) {
   if (is.isFunction(target)) {
     return target(...args);
   }
-  return target;
+  return cloneDeep(target);
 }
 const cloneDeep = (target) => {
   if (is.isVueProxy(target)) {
@@ -80,8 +80,29 @@ const withInstall = (comp) => {
   };
   return comp;
 };
+async function copyText(text) {
+  if (navigator.clipboard) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return;
+    } catch {
+    }
+  }
+  try {
+    const input = document.createElement("textarea");
+    input.value = text;
+    document.body.appendChild(input);
+    input.select();
+    document.execCommand("copy");
+    document.body.removeChild(input);
+  } catch (err) {
+    console.error(err);
+    return Promise.reject();
+  }
+}
 
 exports.cloneDeep = cloneDeep;
+exports.copyText = copyText;
 exports.createUniqueId = createUniqueId;
 exports.funRunHandler = funRunHandler;
 exports.mergeDeep = mergeDeep;

package/lib/utils/index.js

@@ -6,6 +6,9 @@ var crypto = require('./crypto.js');
 var is = require('./is.js');
 var handler = require('./handler.js');
 var date = require('./date.js');
+var file = require('./file.js');
+var form = require('./form.js');
+var loadScript = require('./loadScript.js');
 
 
 
@@ -20,18 +23,34 @@ exports.generateRandomCode = crypto.generateRandomCode;
 exports.isArray = is.isArray;
 exports.isBoolean = is.isBoolean;
 exports.isEmpty = is.isEmpty;
+exports.isFile = is.isFile;
 exports.isFunction = is.isFunction;
 exports.isNull = is.isNull;
 exports.isNumber = is.isNumber;
 exports.isObject = is.isObject;
 exports.isOverflowing = is.isOverflowing;
 exports.isString = is.isString;
+exports.isSupportH265 = is.isSupportH265;
 exports.isSymbol = is.isSymbol;
 exports.isUndefined = is.isUndefined;
 exports.isVueProxy = is.isVueProxy;
 exports.cloneDeep = handler.cloneDeep;
+exports.copyText = handler.copyText;
 exports.createUniqueId = handler.createUniqueId;
 exports.funRunHandler = handler.funRunHandler;
 exports.mergeDeep = handler.mergeDeep;
 exports.withInstall = handler.withInstall;
+exports.formatDuration = date.formatDuration;
 exports.getDefaultValueFormatByType = date.getDefaultValueFormatByType;
+exports.blobToDataURL = file.blobToDataURL;
+exports.fileFormUpload = file.fileFormUpload;
+exports.fileJsonUplaod = file.fileJsonUplaod;
+exports.fileUpload = file.fileUpload;
+exports.presignedUrl = file.presignedUrl;
+exports.sizeToTextHandler = file.sizeToTextHandler;
+exports.clearSpace = form.clearSpace;
+exports.genValueByProp = form.genValueByProp;
+exports.getValueByProp = form.getValueByProp;
+exports.setValueByProp = form.setValueByProp;
+exports.protocolcheckLoad = loadScript.protocolcheckLoad;
+exports.svgIconLoad = loadScript.svgIconLoad;

package/lib/utils/is.js

@@ -11,21 +11,47 @@ const isBoolean = (e) => typeof e === "boolean";
 const isUndefined = (e) => e === void 0;
 const isNull = (e) => e === null;
 const isSymbol = (e) => typeof e === "symbol";
-const isEmpty = (e) => isUndefined(e) || isNull(e) || !isNumber(e) && !e;
+const isEmpty = (e) => !isBoolean(e) && (isUndefined(e) || isNull(e) || !isNumber(e) && !e);
 const isOverflowing = (e) => e.clientWidth < e.scrollWidth || e.clientHeight < e.scrollHeight;
 const isVueProxy = (e) => {
   return vue.isRef(e) || vue.isReactive(e) || vue.isReadonly(e) || vue.isProxy(e);
 };
+const isFile = (e) => {
+  return e instanceof File;
+};
+function isSupportH265() {
+  const ua = navigator.userAgent.toLocaleLowerCase();
+  let isSupport = true;
+  let isVersionLow = false;
+  const chromeMatch = ua.match(/chrome\/(\d+)/) || ua.match(/chromium\/(\d+)/);
+  if (ua.match(/edge\/(\d+)/)) {
+    isSupport = false;
+  } else if (ua.match(/edg\/(\d+)/)) {
+    isSupport = false;
+  } else if (chromeMatch) {
+    const version2 = parseInt(chromeMatch[1], 10);
+    isSupport = true;
+    isVersionLow = !version2 || version2 < 104;
+  } else if (ua.match(/firefox\/(\d+)/)) {
+    isSupport = false;
+  } else if (ua.match(/version\/(\d+)/) && ua.indexOf("safari") > -1) {
+    version = parseInt(RegExp.$1, 10);
+    isSupport = true;
+  }
+  return { isSupport, isVersionLow };
+}
 
 exports.isArray = isArray;
 exports.isBoolean = isBoolean;
 exports.isEmpty = isEmpty;
+exports.isFile = isFile;
 exports.isFunction = isFunction;
 exports.isNull = isNull;
 exports.isNumber = isNumber;
 exports.isObject = isObject;
 exports.isOverflowing = isOverflowing;
 exports.isString = isString;
+exports.isSupportH265 = isSupportH265;
 exports.isSymbol = isSymbol;
 exports.isUndefined = isUndefined;
 exports.isVueProxy = isVueProxy;