@gx-design-vue/pro-utils 0.1.1 → 0.1.2

package/dist/pro-utils.es.js

@@ -0,0 +1,1044 @@
+import { defineComponent, ref, computed, createVNode, isVNode, Fragment } from "vue";
+import { createTypes } from "vue-types";
+import { CloseOutlined, DownOutlined, InfoCircleOutlined } from "@ant-design/icons-vue";
+import { cloneDeep } from "lodash-es";
+import { Tooltip } from "ant-design-vue";
+var config = "";
+var antDesignTheme = "";
+var antDesignVue = "";
+var index$2 = "";
+var proUtils = "";
+var style = "";
+var isServer = typeof window === "undefined";
+const cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+const camelizeRE = /-(\w)/g;
+const camelize = cacheStringFunction((str) => {
+  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+const getStyle = function(element, styleName) {
+  var _a;
+  if (isServer)
+    return "";
+  if (!element || !styleName)
+    return "";
+  styleName = camelize(styleName);
+  if (styleName === "float") {
+    styleName = "cssFloat";
+  }
+  try {
+    const style2 = element.style[styleName];
+    if (style2)
+      return style2;
+    const computed2 = (_a = document == null ? void 0 : document.defaultView) == null ? void 0 : _a.getComputedStyle(element, "");
+    return computed2 ? computed2[styleName] : "";
+  } catch (e) {
+    return element.style[styleName];
+  }
+};
+const isScroll = (el, isVertical) => {
+  if (isServer)
+    return;
+  const determinedDirection = isVertical === null || isVertical === void 0;
+  const overflow = determinedDirection ? getStyle(el, "overflow") : isVertical ? getStyle(el, "overflow-y") : getStyle(el, "overflow-x");
+  return overflow.match(/(scroll|auto|overlay)/);
+};
+const getScrollContainer = (el, isVertical) => {
+  if (isServer)
+    return;
+  let parent = el;
+  while (parent) {
+    if ([window, document, document.documentElement].includes(parent)) {
+      return window;
+    }
+    if (isScroll(parent, isVertical)) {
+      return parent;
+    }
+    parent = parent.parentNode;
+  }
+  return parent;
+};
+const isInContainer = (el, container) => {
+  if (isServer || !el || !container)
+    return false;
+  const elRect = el.getBoundingClientRect();
+  let containerRect;
+  if ([window, document, document.documentElement, null, void 0].includes(container)) {
+    containerRect = {
+      top: 0,
+      right: window.innerWidth,
+      bottom: window.innerHeight,
+      left: 0
+    };
+  } else {
+    containerRect = container.getBoundingClientRect();
+  }
+  return elRect.top < containerRect.bottom && elRect.bottom > containerRect.top && elRect.right > containerRect.left && elRect.left < containerRect.right;
+};
+const toString = Object.prototype.toString;
+function is(val, type) {
+  return toString.call(val) === `[object ${type}]`;
+}
+function isBoolean(val) {
+  return is(val, "Boolean");
+}
+function isNumber(val) {
+  return typeof val === "number";
+}
+function isArray(arg) {
+  if (typeof Array.isArray === "undefined") {
+    return Object.prototype.toString.call(arg) === "[object Array]";
+  }
+  return Array.isArray(arg);
+}
+function isObject(val) {
+  return val !== null && is(val, "Object");
+}
+function isString(value) {
+  return typeof value === "string" || value instanceof String;
+}
+function isFunction(func) {
+  return typeof func === "function" || Object.prototype.toString.call(func) === "[object Function]";
+}
+function classNames(...args) {
+  const classes = [];
+  for (let i = 0; i < args.length; i++) {
+    const value = args[i];
+    if (!value)
+      continue;
+    if (isString(value)) {
+      classes.push(value);
+    } else if (isArray(value)) {
+      for (let i2 = 0; i2 < value.length; i2++) {
+        const inner = classNames(value[i2]);
+        if (inner) {
+          classes.push(inner);
+        }
+      }
+    } else if (isObject(value)) {
+      for (const name in value) {
+        if (value[name]) {
+          classes.push(name);
+        }
+      }
+    }
+  }
+  return classes.filter((el) => el).join(" ");
+}
+let id = 0;
+const ids = {};
+function wrapperRaf(callback, delayFrames = 1) {
+  const myId = id++;
+  let restFrames = delayFrames;
+  function internalCallback() {
+    restFrames -= 1;
+    if (restFrames <= 0) {
+      callback();
+      delete ids[myId];
+    } else {
+      ids[myId] = requestAnimationFrame(internalCallback);
+    }
+  }
+  ids[myId] = requestAnimationFrame(internalCallback);
+  return myId;
+}
+wrapperRaf.cancel = function cancel(pid) {
+  if (pid === void 0)
+    return;
+  cancelAnimationFrame(ids[pid]);
+  delete ids[pid];
+};
+wrapperRaf.ids = ids;
+function isWindow(obj) {
+  return obj !== null && obj !== void 0 && obj === obj.window;
+}
+function getScroll(target, top) {
+  var _a;
+  if (typeof window === "undefined") {
+    return 0;
+  }
+  const method = top ? "scrollTop" : "scrollLeft";
+  let result = 0;
+  if (isWindow(target)) {
+    result = target[top ? "pageYOffset" : "pageXOffset"];
+  } else if (target instanceof Document) {
+    result = target.documentElement[method];
+  } else if (target) {
+    result = target[method];
+  }
+  if (target && !isWindow(target) && typeof result !== "number") {
+    result = (_a = (target.ownerDocument || target).documentElement) == null ? void 0 : _a[method];
+  }
+  return result;
+}
+function easeInOutCubic(t, b, c, d) {
+  const cc = c - b;
+  t /= d / 2;
+  if (t < 1) {
+    return cc / 2 * t * t * t + b;
+  }
+  return cc / 2 * ((t -= 2) * t * t + 2) + b;
+}
+function scrollTo(y, options = {}) {
+  const { getContainer = () => window, callback, duration = 450 } = options;
+  const container = getContainer();
+  const scrollTop = getScroll(container, true);
+  const startTime = Date.now();
+  const frameFunc = () => {
+    const timestamp = Date.now();
+    const time = timestamp - startTime;
+    const nextScrollTop = easeInOutCubic(time > duration ? duration : time, scrollTop, y, duration);
+    if (isWindow(container)) {
+      container.scrollTo(window.pageXOffset, nextScrollTop);
+    } else if (container instanceof HTMLDocument || container.constructor.name === "HTMLDocument") {
+      container.documentElement.scrollTop = nextScrollTop;
+    } else {
+      container.scrollTop = nextScrollTop;
+    }
+    if (time < duration) {
+      wrapperRaf(frameFunc);
+    } else if (typeof callback === "function") {
+      callback();
+    }
+  };
+  wrapperRaf(frameFunc);
+}
+function throttleByAnimationFrame(fn) {
+  let requestId;
+  const later = (args) => () => {
+    requestId = null;
+    fn(...args);
+  };
+  const throttled = (...args) => {
+    if (requestId == null) {
+      requestId = requestAnimationFrame(later(args));
+    }
+  };
+  throttled.cancel = () => cancelAnimationFrame(requestId);
+  return throttled;
+}
+var PropTypes = createTypes({
+  func: void 0,
+  bool: void 0,
+  string: void 0,
+  number: void 0,
+  array: void 0,
+  object: void 0,
+  integer: void 0
+});
+PropTypes.extend([{
+  name: "looseBool",
+  getter: true,
+  type: Boolean,
+  default: void 0
+}, {
+  name: "style",
+  getter: true,
+  type: [String, Object],
+  default: void 0
+}, {
+  name: "VueNode",
+  getter: true,
+  type: null
+}]);
+var PropTypes$1 = PropTypes;
+var global = {
+  videoAllowType: [
+    "mp4",
+    "webm",
+    "ogg"
+  ],
+  audioAllowType: ["mp3"],
+  imageType: ["bmp", "png", "gif", "jpg", "jpeg", "psd", "tif"],
+  videoType: [
+    "mp4",
+    "swf",
+    "rmvb",
+    "avi",
+    "flv",
+    "mpg",
+    "rm",
+    "mov",
+    "asf",
+    "3gp",
+    "mkv",
+    "ts",
+    "f4v",
+    "webm",
+    "m4v",
+    "3g2",
+    "m3u8"
+  ],
+  audioType: ["mp3", "mpeg", "aac", "wav", "wma", "mp2", "flac", "midi", "ra", "ape", "aac", "cda"]
+};
+const getPrefixCls = ({ suffixCls, customizePrefixCls, isPor, className }) => {
+  const prefixCls = className || (isPor ? "gx-pro" : "gx");
+  if (customizePrefixCls)
+    return customizePrefixCls;
+  return suffixCls ? `${prefixCls}-${suffixCls}` : prefixCls;
+};
+const genColumnKey = (key, index2) => {
+  if (key)
+    return Array.isArray(key) ? key.join("-") : key.toString();
+  return `${index2}`;
+};
+function handleShowIndex(columns, { align, showIndex }) {
+  const columnsList = cloneDeep(columns);
+  if (showIndex && columns.length && columns.every((column) => column.dataIndex !== "sortIndex")) {
+    const firstColumsItem = columns[0];
+    columnsList.unshift({
+      title: "\u5E8F\u53F7",
+      align,
+      fixed: firstColumsItem.fixed,
+      width: 60,
+      uuid: getRandomNumber().uuid(15),
+      dataIndex: "sortIndex",
+      key: "sortIndex"
+    });
+  } else {
+    columnsList.filter((item) => item.dataIndex !== "sortIndex");
+  }
+  return columnsList;
+}
+function runFunction(valueEnum, ...rest) {
+  if (typeof valueEnum === "function") {
+    return valueEnum(...rest);
+  }
+  return valueEnum;
+}
+function deepCopy(data) {
+  return JSON.parse(JSON.stringify(data));
+}
+function handleCurrentPage(pageConfig, currentPage) {
+  if (isObject(pageConfig)) {
+    const { pageSize = 10, total = 0 } = pageConfig;
+    let { current = 1 } = pageConfig;
+    if (total - currentPage <= pageSize * (current - 1)) {
+      current = current - 1;
+    }
+    return current === 0 ? 1 : current;
+  }
+  return 1;
+}
+function getSortIndex(data = [], pageConfig, childrenKey = "children") {
+  function getChildSortIndex(parentSort, data2) {
+    return data2.map((item, index2) => {
+      const sortIndex = `${parentSort}-${index2 + 1}`;
+      if (item[childrenKey])
+        item[childrenKey] = getChildSortIndex(sortIndex, item[childrenKey]);
+      item.sortIndex = sortIndex;
+      return item;
+    });
+  }
+  return deepCopy(data).map((item, key) => {
+    let sortIndex = key;
+    const current = isObject(pageConfig) ? pageConfig.current || 1 : 1;
+    const pageSize = isObject(pageConfig) ? pageConfig.pageSize || 10 : 10;
+    sortIndex = current ? (current - 1) * pageSize + (key + 1) : key + 1;
+    if (item[childrenKey])
+      item[childrenKey] = getChildSortIndex(`${sortIndex}`, item[childrenKey]);
+    item.sortIndex = sortIndex;
+    return item;
+  });
+}
+function compareArray(obj1, obj2, key, sort) {
+  const val1 = obj1[key];
+  const val2 = obj2[key];
+  let result = 0;
+  if (val1 < val2) {
+    result = sort === 0 ? -1 : 0;
+  } else if (val1 > val2) {
+    result = sort === 0 ? 0 : -1;
+  }
+  return result;
+}
+function arrayRepeat(data) {
+  let array = deepCopy(data);
+  const set = new Set(array);
+  array = Array.from(set);
+  return array;
+}
+function hanndleField(str, customize) {
+  const stringNull = ["null", "undefined"];
+  let success = true;
+  if (str === 0) {
+    success = true;
+  } else if (stringNull.includes(str)) {
+    success = false;
+  } else if (!str) {
+    success = false;
+  }
+  if (success) {
+    return {
+      value: str,
+      success
+    };
+  }
+  return {
+    value: customize === "" ? customize : customize || "-",
+    success
+  };
+}
+function formatDuraton(time) {
+  let newTime = "";
+  if (time > -1) {
+    const hour = Math.floor(time / 3600);
+    const min = Math.floor(time / 60) % 60;
+    const sec = parseInt(String(time % 60));
+    if (hour < 10) {
+      newTime = "0" + hour + ":";
+    } else {
+      newTime = hour + ":";
+    }
+    if (min < 10) {
+      newTime += "0";
+    }
+    newTime += min + ":";
+    if (sec < 10) {
+      newTime += "0";
+    }
+    newTime += sec;
+  }
+  return newTime.split(":")[0] === "00" ? `${newTime.split(":")[1]}:${newTime.split(":")[2]}` : newTime;
+}
+function getRandomNumber() {
+  const CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");
+  return {
+    uuid(len, rad) {
+      const chars = CHARS;
+      const uuid = [];
+      const radix = rad || chars.length;
+      let i;
+      let r;
+      if (len) {
+        for (i = 0; i < len; i += 1) {
+          uuid[i] = chars[parseInt(String(Math.random() * radix))];
+        }
+      } else {
+        uuid[8] = "-";
+        uuid[13] = "-";
+        uuid[18] = "-";
+        uuid[23] = "-";
+        uuid[14] = "4";
+        for (i = 0; i < 36; i += 1) {
+          if (!uuid[i]) {
+            r = Math.random() * 16;
+            uuid[i] = chars[i === 19 ? r && 3 || 8 : r];
+          }
+        }
+      }
+      return uuid.join("");
+    },
+    uuidFast() {
+      const chars = CHARS;
+      const uuid = new Array(36);
+      let rnd = 0;
+      let r;
+      let i;
+      for (i = 0; i < 36; i += 1) {
+        if (i === 8 || i === 13 || i === 18 || i === 23) {
+          uuid[i] = "-";
+        } else if (i === 14) {
+          uuid[i] = "4";
+        } else {
+          if (rnd <= 2) {
+            rnd = 33554432 + Math.random() * 16777216 || 0;
+          }
+          r = rnd && 15;
+          rnd = rnd > 4;
+          uuid[i] = chars[i === 19 ? r && 3 || 8 : r];
+        }
+      }
+      return uuid.join("");
+    },
+    uuidString() {
+      const str = this.uuidFast().replace(new RegExp("-", "g"), "");
+      return str;
+    },
+    uuidCompact() {
+      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 || 0;
+        const v = c === "x" ? r : r && 3 || 8;
+        return v.toString(16);
+      });
+    }
+  };
+}
+function getMaxFloor(treeData2 = []) {
+  let max = 0;
+  function each(data = [], floor) {
+    data.forEach((e) => {
+      e.floor = floor;
+      if (floor > max) {
+        max = floor;
+      }
+      if (e.children && e.children.length > 0) {
+        each(e.children, floor + 1);
+      }
+    });
+  }
+  each(treeData2, 1);
+  return max;
+}
+function getLevelData(data, filed = "children") {
+  let newData = [];
+  data.forEach((item) => {
+    newData.push(item);
+    if (item[filed] && item[filed].length > 0) {
+      newData = newData.concat(getLevelData(item[filed]));
+    }
+  });
+  return newData;
+}
+function treeData(source, id2, parentId, children, rootId) {
+  id2 = id2 || "id";
+  parentId = parentId || "parentId";
+  children = children || "children";
+  rootId = rootId || 0;
+  const cloneData = JSON.parse(JSON.stringify(source));
+  return cloneData.filter((father) => {
+    const branchArr = cloneData.filter((child) => father[id2] === child[parentId || "parentId"]);
+    branchArr.length > 0 ? father[children || "children"] = branchArr : delete father[children || "children"];
+    return father[parentId || "parentId"] === rootId;
+  });
+}
+function getBlobUrl(blob) {
+  return URL.createObjectURL(blob);
+}
+function getBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = (error) => reject(error);
+  });
+}
+function dataURLtoBlob(dataurl) {
+  const arr = dataurl.split(",");
+  const mime = arr[0].match(/:(.*?);/)[1];
+  const bstr = atob(arr[1]);
+  let n = bstr.length;
+  const u8arr = new Uint8Array(n);
+  while (n--) {
+    u8arr[n] = bstr.charCodeAt(n);
+  }
+  return new Blob([u8arr], { type: mime });
+}
+function dataURLtoFile(dataurl, filename) {
+  const arr = dataurl.split(",");
+  const mime = arr[0].match(/:(.*?);/)[1];
+  const bstr = atob(arr[1]);
+  let n = bstr.length;
+  const u8arr = new Uint8Array(n);
+  while (n--) {
+    u8arr[n] = bstr.charCodeAt(n);
+  }
+  return new File([u8arr], filename, { type: mime });
+}
+function blobToDataURL(blob, fileName, fileType) {
+  return new window.File([blob], fileName, { type: fileType });
+}
+function getVideoFileUrl(url = "") {
+  const index2 = url.indexOf("?");
+  return index2 > 0 ? `${url.substring(0, index2)}` : url;
+}
+function getFileSuffix(url = "") {
+  url = getVideoFileUrl(url);
+  const index2 = url.lastIndexOf(".");
+  return index2 > 0 ? `${url.substring(index2).split("?")[0]}`.split(".")[1] : "";
+}
+function checkFileType(url, type) {
+  if (type)
+    return type;
+  if (!url)
+    return "4";
+  if (url === "data:")
+    return "4";
+  let fileType = "4";
+  if (isBase64(url)) {
+    if (url.includes("data:image/")) {
+      fileType = "png";
+    } else if (url.includes("data:video/")) {
+      fileType = "mp4";
+    } else if (url.includes("data:audio/")) {
+      fileType = "mp3";
+    }
+  } else if (url instanceof Blob) {
+    url = String(url);
+    if (url.includes("image")) {
+      fileType = "png";
+    } else if (url.includes("video")) {
+      fileType = "mp4";
+    } else if (url.includes("audio")) {
+      fileType = "mp3";
+    }
+  } else {
+    fileType = getFileSuffix(url).toLowerCase();
+  }
+  if (global.imageType.includes(fileType))
+    return "1";
+  if (global.videoType.includes(fileType))
+    return "3";
+  if (global.audioType.includes(fileType))
+    return "2";
+  return "4";
+}
+function getMediaInfos(mediaInfo) {
+  const { url = "", fileType = "1" } = mediaInfo;
+  let mediaUrl = "";
+  if (url instanceof File) {
+    mediaUrl = URL.createObjectURL(url);
+  } else if (isBase64(url)) {
+    mediaUrl = url;
+  } else if (url instanceof Blob) {
+    mediaUrl = URL.createObjectURL(url);
+  } else if (url.includes("https") || url.includes("http")) {
+    mediaUrl = fileType === "1" ? url : url;
+  }
+  return new Promise(function(resolve) {
+    let elememt;
+    if (fileType === "1") {
+      elememt = document.createElement("img");
+      elememt.src = mediaUrl;
+    } else if (fileType === "2") {
+      elememt = document.createElement("audio");
+      elememt.src = mediaUrl;
+    } else if (fileType === "3") {
+      elememt = document.createElement("video");
+      elememt.src = mediaUrl;
+    }
+    if (fileType === "1") {
+      elememt.onload = function() {
+        resolve({
+          play: true,
+          width: elememt.width || 0,
+          height: elememt.height || 0
+        });
+        elememt = null;
+      };
+    } else {
+      elememt.oncanplay = function() {
+        resolve({
+          play: true,
+          duration: elememt.duration,
+          width: (elememt == null ? void 0 : elememt.videoWidth) || 0,
+          height: (elememt == null ? void 0 : elememt.videoHeight) || 0
+        });
+        elememt = null;
+      };
+    }
+    elememt.onerror = function() {
+      resolve({
+        play: false
+      });
+      elememt = null;
+    };
+  });
+}
+async function getVideoCoverPicture(videoInfo) {
+  const { url = "", currentTime, videoSuffix = "", vidoeAllowPlay = false } = videoInfo;
+  let videoUrl = "";
+  let fileSuffix = videoSuffix;
+  let fileType = "1";
+  let videoPlayInfo;
+  if (url instanceof File) {
+    videoUrl = URL.createObjectURL(url);
+    fileSuffix = getFileSuffix(url.name);
+    fileType = checkFileType(url.name);
+  } else if (url instanceof Blob) {
+    videoUrl = URL.createObjectURL(url);
+    fileType = checkFileType(url);
+  } else if (isBase64(url)) {
+    videoUrl = url;
+    fileType = checkFileType(url);
+  } else if (url.includes("https") || url.includes("http")) {
+    videoUrl = url;
+    fileSuffix = getFileSuffix(url);
+    fileType = checkFileType(url);
+  }
+  const videoExplan = fileSuffix ? global.videoAllowType.includes(fileSuffix.toLowerCase()) : false;
+  if (videoExplan) {
+    if (vidoeAllowPlay) {
+      return generateVidoePicture(videoUrl, currentTime);
+    } else {
+      videoPlayInfo = await getMediaInfos({
+        url: videoUrl,
+        fileType
+      });
+      if (videoPlayInfo.play) {
+        return generateVidoePicture(videoUrl, currentTime);
+      } else {
+        return new Promise(function(resolve) {
+          resolve("");
+        });
+      }
+    }
+  } else {
+    return new Promise(function(resolve) {
+      resolve("");
+    });
+  }
+}
+async function generateVidoePicture(videoUrl, currentTime) {
+  let video = document.createElement("video");
+  video.style.display = "none";
+  video.controls = true;
+  video.muted = true;
+  if (currentTime) {
+    video.currentTime = currentTime;
+  }
+  video.setAttribute("src", videoUrl);
+  video.setAttribute("muted", String(true));
+  video.setAttribute("crossorigin", "anonymous");
+  video.setAttribute("autoplay", String(true));
+  const canvas = document.createElement("canvas");
+  const scale = 0.8;
+  const delay = 100;
+  const ctx = canvas.getContext("2d");
+  return new Promise(function(resolve) {
+    if (video) {
+      video.addEventListener("canplay", function() {
+        setTimeout(function() {
+          const w = (video == null ? void 0 : video.videoWidth) || 0 * scale;
+          const h = (video == null ? void 0 : video.videoHeight) || 0 * scale;
+          const space = 0;
+          canvas.width = (video == null ? void 0 : video.videoWidth) || 0 * scale;
+          canvas.height = (video == null ? void 0 : video.videoHeight) || 0 * scale;
+          ctx.drawImage(video, 0, 0, w + space, h + space);
+          video = null;
+          resolve(w === 0 || h === 0 ? "" : canvas.toDataURL("image/png", 1));
+        }, delay);
+      }, false);
+    }
+  });
+}
+function isBase64(str = "") {
+  const fileDataBase = [
+    "data:image/",
+    "data:video/",
+    "data:audio/"
+  ];
+  if (str && fileDataBase.find((item) => str.includes(item))) {
+    return true;
+  }
+  return false;
+}
+function on(element, event, handler, useCapture = false) {
+  if (element && event && handler) {
+    element.addEventListener(event, handler, useCapture);
+  }
+}
+function off(element, event, handler, useCapture = false) {
+  if (element && event && handler) {
+    element.removeEventListener(event, handler, useCapture);
+  }
+}
+var index$1 = "";
+const FieldLabel = defineComponent({
+  props: {
+    id: PropTypes$1.string,
+    style: PropTypes$1.style,
+    size: {
+      type: String,
+      default: "middle"
+    },
+    label: Object,
+    placeholder: [Object, String],
+    class: String,
+    ellipsis: Boolean,
+    allowClear: {
+      type: Boolean,
+      default: true
+    },
+    bordered: Boolean,
+    expanded: Boolean,
+    disabled: Boolean,
+    onClear: Function,
+    onLabelClick: Function,
+    formatter: Function,
+    value: PropTypes$1.any
+  },
+  setup(props, {
+    expose
+  }) {
+    const prefixCls = getPrefixCls({
+      suffixCls: "core-field-label",
+      isPor: true
+    });
+    const labelRef = ref();
+    const clearRef = ref();
+    const allowClear = computed(() => props.allowClear || true);
+    expose({
+      labelRef,
+      clearRef
+    });
+    const formatterText = (aValue) => {
+      if (props.formatter) {
+        return props.formatter(aValue);
+      }
+      return Array.isArray(aValue) ? aValue.join(",") : String(aValue);
+    };
+    const getTextByValue = (aLabel, aValue) => {
+      var _a, _b;
+      if (aValue !== void 0 && aValue !== null && aValue !== "" && (!Array.isArray(aValue) || aValue.length)) {
+        const isValueNode = isVNode(aValue);
+        const prefix = aLabel ? createVNode("span", {
+          "onClick": props.onLabelClick,
+          "class": `${prefixCls}-text`
+        }, [aLabel, ": "]) : "";
+        const str = isValueNode ? "" : formatterText(aValue);
+        if (!props.ellipsis) {
+          return createVNode("span", {
+            "style": {
+              display: "inline-flex",
+              alignItems: "center"
+            }
+          }, [prefix, isValueNode ? aValue : formatterText(aValue)]);
+        }
+        const VALUE_MAX_LENGTH = 41;
+        const getText = () => {
+          const isArrayValue = Array.isArray(aValue) && aValue.length > 1;
+          const unitText = "\u9879";
+          if (typeof str === "string" && str.length > VALUE_MAX_LENGTH && isArrayValue) {
+            return `...${aValue.length}${unitText}`;
+          }
+          return "";
+        };
+        const tail = getText();
+        return createVNode("span", {
+          "title": isValueNode ? "" : str,
+          "style": {
+            display: "inline-flex",
+            alignItems: "center"
+          }
+        }, [prefix, createVNode("span", {
+          "style": {
+            paddingInlineStart: 4
+          }
+        }, [typeof str === "string" ? (_b = (_a = str == null ? void 0 : str.toString()) == null ? void 0 : _a.substr) == null ? void 0 : _b.call(_a, 0, VALUE_MAX_LENGTH) : aValue]), tail]);
+      }
+      return aLabel || props.placeholder;
+    };
+    return () => createVNode("span", {
+      "class": {
+        [`${prefixCls}`]: true,
+        [`${prefixCls}-${props.size}`]: props.size,
+        [`${prefixCls}-active`]: !!props.value || props.value === 0,
+        [`${prefixCls}-disabled`]: props.disabled,
+        [`${prefixCls}-bordered`]: props.bordered,
+        [`${prefixCls}-allow-clear`]: allowClear.value,
+        [`${props.class}`]: props.class
+      },
+      "style": props.style,
+      "ref": labelRef
+    }, [getTextByValue(props.label, props.value), (props.value || props.value === 0) && allowClear.value && createVNode(CloseOutlined, {
+      "role": "button",
+      "title": "\u6E05\u9664",
+      "class": [`${prefixCls}-icon`, `${prefixCls}-close`],
+      "onClick": (e) => {
+        if (props.onClear && !props.disabled) {
+          props.onClear();
+        }
+        e.stopPropagation();
+      },
+      "ref": clearRef
+    }, null), createVNode(DownOutlined, {
+      "class": [`${prefixCls}-icon`, `${prefixCls}-arrow`]
+    }, null)]);
+  }
+});
+var index = "";
+const LabelIconTip = (props) => {
+  if (!props.tooltip && !props.subTitle) {
+    return createVNode(Fragment, null, [props.label]);
+  }
+  const className = getPrefixCls({
+    suffixCls: "core-label-tip",
+    isPor: true
+  });
+  const tooltipProps = typeof props.tooltip === "string" ? {
+    title: props.tooltip
+  } : props.tooltip;
+  const icon = (tooltipProps == null ? void 0 : tooltipProps.icon) || createVNode(InfoCircleOutlined, null, null);
+  return createVNode("div", {
+    "class": className,
+    "onMousedown": (e) => e.stopPropagation(),
+    "onMouseleave": (e) => e.stopPropagation(),
+    "onMousemove": (e) => e.stopPropagation()
+  }, [createVNode("div", {
+    "class": {
+      [`${className}-title`]: true,
+      [`${className}-title-ellipsis`]: props.ellipsis
+    }
+  }, [props.label]), props.subTitle && createVNode("div", {
+    "class": `${className}-subtitle`
+  }, [props.subTitle]), props.tooltip && createVNode(Tooltip, tooltipProps, {
+    default: () => [createVNode("span", {
+      "class": `${className}-icon`
+    }, [icon])]
+  })]);
+};
+const merge = (...rest) => {
+  const obj = {};
+  const il = rest.length;
+  let key;
+  let i = 0;
+  for (; i < il; i += 1) {
+    for (key in rest[i]) {
+      if (rest[i].hasOwnProperty(key)) {
+        if (typeof obj[key] === "object" && typeof rest[i][key] === "object" && obj[key] !== void 0 && obj[key] !== null && !Array.isArray(obj[key]) && !Array.isArray(rest[i][key])) {
+          obj[key] = {
+            ...obj[key],
+            ...rest[i][key]
+          };
+        } else {
+          obj[key] = rest[i][key];
+        }
+      }
+    }
+  }
+  return obj;
+};
+function isDeepEqualReact(a, b, ignoreKeys, debug) {
+  if (a === b)
+    return true;
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    if (a.constructor !== b.constructor)
+      return false;
+    let length;
+    let i;
+    let keys;
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length; i-- !== 0; ) {
+        if (!isDeepEqualReact(a[i], b[i], ignoreKeys, debug))
+          return false;
+      }
+      return true;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size)
+        return false;
+      for (i of a.entries()) {
+        if (!b.has(i[0]))
+          return false;
+      }
+      for (i of a.entries()) {
+        if (!isDeepEqualReact(i[1], b.get(i[0]), ignoreKeys, debug))
+          return false;
+      }
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size)
+        return false;
+      for (i of a.entries()) {
+        if (!b.has(i[0]))
+          return false;
+      }
+      return true;
+    }
+    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length; i-- !== 0; ) {
+        if (a[i] !== b[i])
+          return false;
+      }
+      return true;
+    }
+    if (a.constructor === RegExp)
+      return a.source === b.source && a.flags === b.flags;
+    if (a.valueOf !== Object.prototype.valueOf && a.valueOf)
+      return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString && a.toString)
+      return a.toString() === b.toString();
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length)
+      return false;
+    for (i = length; i-- !== 0; ) {
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+        return false;
+    }
+    for (i = length; i-- !== 0; ) {
+      const key = keys[i];
+      if (ignoreKeys == null ? void 0 : ignoreKeys.includes(key))
+        continue;
+      if (key === "_owner" && a.$$typeof) {
+        continue;
+      }
+      if (!isDeepEqualReact(a[key], b[key], ignoreKeys, debug)) {
+        if (debug) {
+          console.log(key);
+        }
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+const isBrowser = () => {
+  return typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.matchMedia !== "undefined" && !isNode;
+};
+const omitBoolean = (obj) => {
+  if (obj && obj !== true) {
+    return obj;
+  }
+  return void 0;
+};
+const omitUndefined = (obj) => {
+  const newObj = {};
+  Object.keys(obj || {}).forEach((key) => {
+    if (obj[key] !== void 0) {
+      newObj[key] = obj[key];
+    }
+  });
+  if (Object.keys(newObj).length < 1) {
+    return void 0;
+  }
+  return newObj;
+};
+const isSlotFragment = (slots) => {
+  return slots.length === 1 && (String(slots[0].type) === String(Symbol("Comment")) || String(slots[0].type) === String(Symbol("Fragment")) || String(slots[0].type) === String(Symbol()));
+};
+function getRealVNode(vnode) {
+  if (isSlotFragment(vnode))
+    return isVNode(vnode[0].children) ? vnode[0].children : vnode;
+  return vnode;
+}
+function getSlot(slots, props, prop = "default") {
+  if (props[prop] === false) {
+    return false;
+  }
+  if (isBoolean(props[prop]) && props[prop])
+    return (slots == null ? void 0 : slots[prop]) || props[prop];
+  return props[prop] || slots[prop];
+}
+function getSlotVNode(slots, props, prop = "default") {
+  var _a, _b;
+  if (props[prop] === false) {
+    return false;
+  }
+  if (isBoolean(props[prop]) && props[prop])
+    return ((_a = slots == null ? void 0 : slots[prop]) == null ? void 0 : _a.call(slots)) || props[prop];
+  return props[prop] || ((_b = slots[prop]) == null ? void 0 : _b.call(slots));
+}
+function getSlotsProps(data, slots, props) {
+  const renderSlotsAndProps = {};
+  data.forEach((name) => {
+    renderSlotsAndProps[name] = getSlotVNode(slots, props, name);
+  });
+  return renderSlotsAndProps;
+}
+export { FieldLabel, LabelIconTip, arrayRepeat, blobToDataURL, checkFileType, classNames, compareArray, dataURLtoBlob, dataURLtoFile, deepCopy, formatDuraton, genColumnKey, generateVidoePicture, getBase64, getBlobUrl, getFileSuffix, getLevelData, getMaxFloor, getMediaInfos, getPrefixCls, getRandomNumber, getRealVNode, getScroll, getScrollContainer, getSlot, getSlotVNode, getSlotsProps, getSortIndex, getVideoCoverPicture, getVideoFileUrl, global as globalConfig, handleCurrentPage, handleShowIndex, hanndleField, is, isArray, isBase64, isBoolean, isBrowser, isDeepEqualReact, isFunction, isInContainer, isNumber, isObject, isScroll, isServer, isSlotFragment, isString, merge, off, omitBoolean, omitUndefined, on, runFunction, scrollTo, throttleByAnimationFrame, treeData };