@fmdeui/fmui 1.0.1

package/lib/packages/components/select-table/src/renderCol.vue.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var renderCol_vue_vue_type_script_setup_true_lang = require('./renderCol.vue2.js');
+
+
+
+exports.default = renderCol_vue_vue_type_script_setup_true_lang.default;

package/lib/packages/components/select-table/src/renderCol.vue2.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "RenderCol"
+  },
+  __name: "renderCol",
+  props: {
+    row: Object,
+    render: Function,
+    index: Number,
+    column: {
+      type: Object,
+      default: null
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const renderComponent = () => {
+      var _a;
+      return props.render(props == null ? void 0 : props.row[(_a = props == null ? void 0 : props.column) == null ? void 0 : _a.prop], props.row, props.index);
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderComponent));
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/components/select-table/src/type.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/lib/packages/components/select-table/src/useVirtualized.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var vue = require('vue');
+
+function useVirtualized() {
+  const actualHeightContainerEl = vue.ref(null);
+  const translateContainerEl = vue.ref(null);
+  const scrollContainerEl = vue.ref(null);
+  const isMultiple = vue.ref(false);
+  const saveDATA = vue.ref([]);
+  const RenderedItemsCache = {};
+  const getDom = (props) => {
+    const getElements = (className) => {
+      actualHeightContainerEl.value = document.querySelector(`${className} .el-scrollbar__view`);
+      translateContainerEl.value = document.querySelector(`${className} .el-table__body`);
+      scrollContainerEl.value = document.querySelector(`${className} .el-scrollbar__wrap`);
+    };
+    isMultiple.value = props.multiple;
+    if (props.multiple) {
+      getElements(".f_select_table_multiple");
+    } else {
+      getElements(".f_select_table_radio");
+    }
+  };
+  const getItemHeightFromCache = (index) => {
+    const val = RenderedItemsCache[index];
+    return val === void 0 ? 50 : val;
+  };
+  const updateActualHeight = () => {
+    let actualHeight = 0;
+    saveDATA.value.forEach((_, i) => {
+      actualHeight += getItemHeightFromCache(i);
+    });
+    actualHeightContainerEl.value.style.height = actualHeight + "px";
+  };
+  const updateOffset = (offset) => {
+    if (translateContainerEl.value && translateContainerEl.value.style) {
+      translateContainerEl.value.style.transform = `translateY(${offset}px)`;
+    }
+  };
+  const updateRenderedItemCache = (index) => {
+    const shouldUpdate = Object.keys(RenderedItemsCache).length < saveDATA.value.length;
+    if (!shouldUpdate) return;
+    vue.nextTick(() => {
+      const Items = Array.from(
+        document.querySelectorAll(
+          `${isMultiple.value ? `.f_select_table_multiple` : `.f_select_table_radio`} .el-table__row`
+        )
+      );
+      Items.forEach((el) => {
+        if (!RenderedItemsCache[index]) {
+          RenderedItemsCache[index] = el.offsetHeight;
+        }
+        index++;
+      });
+      updateActualHeight();
+    });
+  };
+  return {
+    scrollContainerEl,
+    updateRenderedItemCache,
+    updateOffset,
+    getDom,
+    getItemHeightFromCache,
+    saveDATA
+  };
+}
+
+exports.useVirtualized = useVirtualized;

package/lib/packages/components/select-table/style/css.js

@@ -0,0 +1,4 @@
+'use strict';
+
+require('@fmdeui/theme-chalk/f-select-table.css');
+

package/lib/packages/components/select-table/style/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+require('../../../theme-chalk/src/select-table.scss.js');
+

package/lib/packages/components/svgIcon/index.vue.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index_vue_vue_type_script_setup_true_name_svgIcon_lang = require('./index.vue2.js');
+
+
+
+exports.default = index_vue_vue_type_script_setup_true_name_svgIcon_lang.default;

package/lib/packages/components/svgIcon/index.vue2.js

@@ -0,0 +1,95 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const _hoisted_1 = ["src"];
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    // svg 图标组件名字
+    name: {
+      type: String
+    },
+    // svg 大小
+    size: {
+      type: Number,
+      default: () => 14
+    },
+    // svg 颜色
+    color: {
+      type: String
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const linesString = ["https", "http", "/src", "/assets", "data:image", window.__env__.VITE_PUBLIC_PATH];
+    const getIconName = vue.computed(() => {
+      return props == null ? void 0 : props.name;
+    });
+    const isShowIconSvg = vue.computed(() => {
+      var _a;
+      return (_a = props == null ? void 0 : props.name) == null ? void 0 : _a.startsWith("ele-");
+    });
+    const isShowIconImg = vue.computed(() => {
+      return linesString.find((str) => {
+        var _a;
+        return (_a = props.name) == null ? void 0 : _a.startsWith(str);
+      });
+    });
+    const setIconSvgStyle = vue.computed(() => {
+      return `font-size: ${props.size}px;color: ${props.color};`;
+    });
+    const setIconImgOutStyle = vue.computed(() => {
+      return `width: ${props.size}px;height: ${props.size}px;display: inline-block;overflow: hidden;`;
+    });
+    const setIconSvgInsStyle = vue.computed(() => {
+      const filterStyle = [];
+      const compatibles = ["-webkit", "-ms", "-o", "-moz"];
+      compatibles.forEach((j) => filterStyle.push(`${j}-filter: drop-shadow(${props.color} ${props.size}px 0);`));
+      return `width: ${props.size}px;height: ${props.size}px;position: relative;left: -${props.size}px;${filterStyle.join("")}`;
+    });
+    return (_ctx, _cache) => {
+      return isShowIconSvg.value ? (vue.openBlock(), vue.createElementBlock(
+        "i",
+        {
+          key: 0,
+          class: "el-icon",
+          style: vue.normalizeStyle(setIconSvgStyle.value)
+        },
+        [
+          (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(getIconName.value)))
+        ],
+        4
+        /* STYLE */
+      )) : isShowIconImg.value ? (vue.openBlock(), vue.createElementBlock(
+        "div",
+        {
+          key: 1,
+          style: vue.normalizeStyle(setIconImgOutStyle.value)
+        },
+        [
+          vue.createElementVNode("img", {
+            src: getIconName.value,
+            style: vue.normalizeStyle(setIconSvgInsStyle.value)
+          }, null, 12, _hoisted_1)
+        ],
+        4
+        /* STYLE */
+      )) : (vue.openBlock(), vue.createElementBlock(
+        "i",
+        {
+          key: 2,
+          class: vue.normalizeClass(getIconName.value),
+          style: vue.normalizeStyle(setIconSvgStyle.value)
+        },
+        null,
+        6
+        /* CLASS, STYLE */
+      ));
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/components/utils/index.js

@@ -0,0 +1,101 @@
+'use strict';
+
+function debounce(func, delay = 500, immediate, resultCallback) {
+  let timer = null;
+  let isInvoke = false;
+  const _debounce = function(...args) {
+    return new Promise((resolve, reject) => {
+      if (timer) clearTimeout(timer);
+      if (immediate && !isInvoke) {
+        try {
+          const result = func.apply(this, args);
+          if (resultCallback) resultCallback(result);
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        }
+        isInvoke = true;
+      } else {
+        timer = setTimeout(() => {
+          try {
+            const result = func.apply(this, args);
+            if (resultCallback) resultCallback(result);
+            resolve(result);
+          } catch (e) {
+            reject(e);
+          }
+          isInvoke = false;
+          timer = null;
+        }, delay);
+      }
+    });
+  };
+  _debounce.cancel = function() {
+    if (timer) clearTimeout(timer);
+    isInvoke = false;
+    timer = null;
+  };
+  return _debounce;
+}
+function throttle(func, interval, options = { leading: false, trailing: true }) {
+  let timer = null;
+  let lastTime = 0;
+  const { leading, trailing } = options;
+  const _throttle = function(...args) {
+    const nowTime = Date.now();
+    if (!lastTime && !leading) lastTime = nowTime;
+    const remainTime = interval - (nowTime - lastTime);
+    if (remainTime <= 0) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      lastTime = nowTime;
+      func.apply(this, args);
+    }
+    if (trailing && !timer) {
+      timer = setTimeout(() => {
+        lastTime = !leading ? 0 : Date.now();
+        timer = null;
+        func.apply(this, args);
+      }, remainTime);
+    }
+  };
+  _throttle.cancel = function() {
+    if (timer) clearTimeout(timer);
+    timer = null;
+    lastTime = 0;
+  };
+  return _throttle;
+}
+function toLine(name) {
+  return name.replace(/([A-Z])/g, "_$1").toLowerCase();
+}
+function formatNumber(value, precision = 2, separator = ",", decimal = ".", prefix = "", suffix = "") {
+  if (Number(value) === 0) {
+    return Number(value).toFixed(precision);
+  }
+  if (!value) {
+    return "";
+  }
+  value = Number(value).toFixed(precision);
+  value += "";
+  const nums = value.split(".");
+  let integer = nums[0];
+  const decimals = nums.length > 1 ? decimal + nums[1] : "";
+  const reg = /(\d+)(\d{3})/;
+  function isNumber(value2) {
+    return Object.prototype.toString.call(value2) === "[object Number]";
+  }
+  if (separator && !isNumber(separator)) {
+    while (reg.test(integer)) {
+      integer = integer.replace(reg, "$1" + separator + "$2");
+    }
+  }
+  return prefix + integer + decimals + suffix;
+}
+
+exports.debounce = debounce;
+exports.formatNumber = formatNumber;
+exports.throttle = throttle;
+exports.toLine = toLine;

package/lib/packages/components/utils/install.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const withInstall = (main, extra) => {
+  ;
+  main.install = (app) => {
+    for (const comp of [main, ...Object.values(extra != null ? extra : {})]) {
+      app.component(comp.name, comp);
+    }
+  };
+  if (extra) {
+    for (const [key, comp] of Object.entries(extra)) {
+      ;
+      main[key] = comp;
+    }
+  }
+  return main;
+};
+
+exports.withInstall = withInstall;

package/lib/packages/directive/authDirective.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var userInfo = require('../stores/userInfo.js');
+var arrayOperation = require('../utils/arrayOperation.js');
+
+function authDirective(app) {
+  app.directive("auth", {
+    mounted(el, binding) {
+      const stores = userInfo.useUserInfo();
+      if (!stores.userInfos.authApiList.some((v) => v === binding.value)) el.parentNode.removeChild(el);
+    }
+  });
+  app.directive("auths", {
+    mounted(el, binding) {
+      let flag = false;
+      const stores = userInfo.useUserInfo();
+      stores.userInfos.authApiList.map((val) => {
+        binding.value.map((v) => {
+          if (val === v) flag = true;
+        });
+      });
+      if (!flag) el.parentNode.removeChild(el);
+    }
+  });
+  app.directive("auth-all", {
+    mounted(el, binding) {
+      const stores = userInfo.useUserInfo();
+      const flag = arrayOperation.judgementSameArr(binding.value, stores.userInfos.authApiList);
+      if (!flag) el.parentNode.removeChild(el);
+    }
+  });
+}
+
+exports.authDirective = authDirective;

package/lib/packages/directive/customDirective.js

@@ -0,0 +1,156 @@
+'use strict';
+
+function wavesDirective(app) {
+  app.directive("waves", {
+    mounted(el, binding) {
+      el.classList.add("waves-effect");
+      binding.value && el.classList.add(`waves-${binding.value}`);
+      function setConvertStyle(obj) {
+        let style = "";
+        for (let i in obj) {
+          if (obj.hasOwnProperty(i)) style += `${i}:${obj[i]};`;
+        }
+        return style;
+      }
+      function onCurrentClick(e) {
+        let elDiv = document.createElement("div");
+        elDiv.classList.add("waves-ripple");
+        el.appendChild(elDiv);
+        let styles = {
+          left: `${e.layerX}px`,
+          top: `${e.layerY}px`,
+          opacity: 1,
+          transform: `scale(${el.clientWidth / 100 * 10})`,
+          "transition-duration": `750ms`,
+          "transition-timing-function": `cubic-bezier(0.250, 0.460, 0.450, 0.940)`
+        };
+        elDiv.setAttribute("style", setConvertStyle(styles));
+        setTimeout(() => {
+          elDiv.setAttribute(
+            "style",
+            setConvertStyle({
+              opacity: 0,
+              transform: styles.transform,
+              left: styles.left,
+              top: styles.top
+            })
+          );
+          setTimeout(() => {
+            elDiv && el.removeChild(elDiv);
+          }, 750);
+        }, 450);
+      }
+      el.addEventListener("mousedown", onCurrentClick, false);
+    },
+    unmounted(el) {
+      el.addEventListener("mousedown", () => {
+      });
+    }
+  });
+}
+function dragDirective(app) {
+  app.directive("drag", {
+    mounted(el, binding) {
+      if (!binding.value) return false;
+      const dragDom = document.querySelector(binding.value[0]);
+      const dragHeader = document.querySelector(binding.value[1]);
+      dragHeader.onmouseover = () => dragHeader.style.cursor = `move`;
+      function down(e, type) {
+        const disX = type === "pc" ? e.clientX - dragHeader.offsetLeft : e.touches[0].clientX - dragHeader.offsetLeft;
+        const disY = type === "pc" ? e.clientY - dragHeader.offsetTop : e.touches[0].clientY - dragHeader.offsetTop;
+        const screenWidth = document.body.clientWidth;
+        const screenHeight = document.documentElement.clientHeight;
+        const dragDomWidth = dragDom.offsetWidth;
+        const dragDomheight = dragDom.offsetHeight;
+        const minDragDomLeft = dragDom.offsetLeft;
+        const maxDragDomLeft = screenWidth - dragDom.offsetLeft - dragDomWidth;
+        const minDragDomTop = dragDom.offsetTop;
+        const maxDragDomTop = screenHeight - dragDom.offsetTop - dragDomheight;
+        let styL = getComputedStyle(dragDom).left;
+        let styT = getComputedStyle(dragDom).top;
+        if (styL.includes("%")) {
+          styL = +document.body.clientWidth * (+styL.replace(/\%/g, "") / 100);
+          styT = +document.body.clientHeight * (+styT.replace(/\%/g, "") / 100);
+        } else {
+          styL = +styL.replace(/\px/g, "");
+          styT = +styT.replace(/\px/g, "");
+        }
+        return {
+          disX,
+          disY,
+          minDragDomLeft,
+          maxDragDomLeft,
+          minDragDomTop,
+          maxDragDomTop,
+          styL,
+          styT
+        };
+      }
+      function move(e, type, obj) {
+        let { disX, disY, minDragDomLeft, maxDragDomLeft, minDragDomTop, maxDragDomTop, styL, styT } = obj;
+        let left = type === "pc" ? e.clientX - disX : e.touches[0].clientX - disX;
+        let top = type === "pc" ? e.clientY - disY : e.touches[0].clientY - disY;
+        if (-left > minDragDomLeft) {
+          left = -minDragDomLeft;
+        } else if (left > maxDragDomLeft) {
+          left = maxDragDomLeft;
+        }
+        if (-top > minDragDomTop) {
+          top = -minDragDomTop;
+        } else if (top > maxDragDomTop) {
+          top = maxDragDomTop;
+        }
+        dragDom.style.cssText += `;left:${left + styL}px;top:${top + styT}px;`;
+      }
+      dragHeader.onmousedown = (e) => {
+        const obj = down(e, "pc");
+        document.onmousemove = (e2) => {
+          move(e2, "pc", obj);
+        };
+        document.onmouseup = () => {
+          document.onmousemove = null;
+          document.onmouseup = null;
+        };
+      };
+      dragHeader.ontouchstart = (e) => {
+        const obj = down(e, "app");
+        document.ontouchmove = (e2) => {
+          move(e2, "app", obj);
+        };
+        document.ontouchend = () => {
+          document.ontouchmove = null;
+          document.ontouchend = null;
+        };
+      };
+    }
+  });
+}
+function reclickDirective(app) {
+  let opacity = "";
+  app.directive("reclick", {
+    mounted(el, time) {
+      el.addEventListener("click", () => {
+        if (!el.disabled) {
+          el.disabled = true;
+          opacity = el.style.opacity;
+          el.style.opacity = "0.2";
+          setTimeout(
+            () => {
+              el.disabled = false;
+              el.style.opacity = opacity;
+            },
+            time.value === void 0 ? 800 : time.value
+          );
+        }
+      });
+    },
+    unmounted(el) {
+      el.disabled = false;
+      el.style.opacity = opacity;
+    }
+  });
+}
+
+exports.dragDirective = dragDirective;
+exports.reclickDirective = reclickDirective;
+exports.wavesDirective = wavesDirective;

package/lib/packages/directive/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var authDirective = require('./authDirective.js');
+var customDirective = require('./customDirective.js');
+
+function directive(app) {
+  authDirective.authDirective(app);
+  customDirective.wavesDirective(app);
+  customDirective.reclickDirective(app);
+}
+
+exports.directive = directive;

package/lib/packages/hooks/authFunction.js

@@ -0,0 +1,41 @@
+'use strict';
+
+require('../stores/index.js');
+var arrayOperation = require('../utils/arrayOperation.js');
+var vue = require('vue');
+var userInfo = require('../stores/userInfo.js');
+
+function auth(value) {
+  const stores = userInfo.useUserInfo();
+  return stores.userInfos.authApiList.some((v) => v === value);
+}
+function auths(value) {
+  let flag = false;
+  const stores = userInfo.useUserInfo();
+  stores.userInfos.authApiList.map((val) => {
+    value.map((v) => {
+      if (val === v) flag = true;
+    });
+  });
+  return flag;
+}
+function authAll(value) {
+  const stores = userInfo.useUserInfo();
+  return arrayOperation.judgementSameArr(value, stores.userInfos.authApiList);
+}
+function hAuth(el, value) {
+  return vue.withDirectives(el, [[vue.resolveDirective("auth"), value]]);
+}
+function hAuths(el, value) {
+  return vue.withDirectives(el, [[vue.resolveDirective("auths"), value]]);
+}
+function hAuthAll(el, value) {
+  return vue.withDirectives(el, [[vue.resolveDirective("auth-all"), value]]);
+}
+
+exports.auth = auth;
+exports.authAll = authAll;
+exports.auths = auths;
+exports.hAuth = hAuth;
+exports.hAuthAll = hAuthAll;
+exports.hAuths = hAuths;

package/lib/packages/hooks/dateTimeShortCust.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const useDateTimeShortCust = () => {
+  return [
+    { text: "\u4ECA\u5929", value: /* @__PURE__ */ new Date() },
+    {
+      text: "\u6628\u5929",
+      value: () => {
+        const date = /* @__PURE__ */ new Date();
+        date.setTime(date.getTime() - 3600 * 1e3 * 24);
+        return date;
+      }
+    },
+    {
+      text: "\u4E0A\u5468",
+      value: () => {
+        const date = /* @__PURE__ */ new Date();
+        date.setTime(date.getTime() - 3600 * 1e3 * 24 * 7);
+        return date;
+      }
+    }
+  ];
+};
+
+exports.useDateTimeShortCust = useDateTimeShortCust;