@fmdevui/fm-dev 1.0.75 → 1.0.77

package/lib/packages/core/ui/components/querycondition/moreChoose.vue2.js

@@ -0,0 +1,241 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var svg = require('@element-plus/icons-vue');
+
+const _hoisted_1 = { class: "inside_box" };
+const _hoisted_2 = { class: "inside_box_title" };
+const _hoisted_3 = { class: "check-box" };
+const _hoisted_4 = { class: "more_dropdown_icon" };
+const _hoisted_5 = { class: "out_box" };
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "MoreChoose"
+  },
+  __name: "moreChoose",
+  props: {
+    // 以下拉方式展示更多条件---数据源
+    moreCheckList: {
+      type: Array,
+      default: () => []
+    },
+    popoverAttrsBind: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ["getCheckList"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const checkList = vue.ref([]);
+    const isCheckList = vue.ref([]);
+    const allcheckList = vue.ref(props.moreCheckList);
+    const emit = __emit;
+    vue.watch(
+      () => props.moreCheckList,
+      (list) => {
+        allcheckList.value = list;
+      },
+      { deep: true }
+    );
+    vue.watch(
+      () => checkList,
+      (nval, oval) => {
+        let list = [];
+        oval.value.forEach((ele) => {
+          if (!nval.value.some((val) => val == ele)) {
+            list.push(ele);
+          }
+        });
+        isCheckList.value.forEach((ele, j) => {
+          if (list.filter((val) => val == ele.label)[0]) {
+            delete isCheckList.value[j];
+          }
+        });
+      },
+      { deep: true }
+    );
+    const handlecheckAll = () => {
+      const allList = JSON.parse(JSON.stringify(allcheckList.value));
+      checkList.value = allList.map((item) => item.label);
+      isCheckList.value = allList;
+      const checkObj = analysisObj(isCheckList.value);
+      emit("getCheckList", checkObj);
+    };
+    const handleReverseCheck = () => {
+      const deepCheckList = JSON.parse(JSON.stringify(checkList.value));
+      checkList.value = [];
+      isCheckList.value = [];
+      allcheckList.value.forEach((ele) => {
+        if (!deepCheckList.filter((item1) => item1 == ele.label)[0]) {
+          checkList.value.push(ele.label);
+          isCheckList.value.push(ele);
+        }
+      });
+      const checkObj = analysisObj(isCheckList.value);
+      emit("getCheckList", checkObj);
+    };
+    const handleReset = () => {
+      checkList.value = [];
+      isCheckList.value = [];
+      emit("getCheckList", {});
+    };
+    const getcheck = (val) => {
+      isCheckList.value = [];
+      allcheckList.value.forEach((ele, j) => {
+        if (val.filter((item1) => item1 == ele.label)[0]) {
+          isCheckList.value.push(ele);
+        }
+      });
+      const checkObj = analysisObj(isCheckList.value);
+      emit("getCheckList", checkObj);
+    };
+    const analysisObj = (val) => {
+      return val.reduce((obj, item) => {
+        obj[item.prop] = {
+          label: item?.label,
+          comp: item.comp,
+          bind: item?.bind,
+          list: item?.list,
+          eventHandle: item?.eventHandle,
+          changeEvent: item?.changeEvent,
+          listTypeInfo: item?.listTypeInfo,
+          arrLabel: item?.arrLabel,
+          arrKey: item?.arrKey,
+          slotName: item?.slotName,
+          span: item?.span,
+          type: item?.type,
+          isSelfCom: item && item.isSelfCom || false,
+          defaultVal: item?.defaultVal,
+          placeholder: item?.placeholder,
+          event: item?.event
+        };
+        return obj;
+      }, {});
+    };
+    return (_ctx, _cache) => {
+      const _component_el_button = vue.resolveComponent("el-button");
+      const _component_el_checkbox = vue.resolveComponent("el-checkbox");
+      const _component_el_checkbox_group = vue.resolveComponent("el-checkbox-group");
+      const _component_el_icon = vue.resolveComponent("el-icon");
+      const _component_el_popover = vue.resolveComponent("el-popover");
+      return allcheckList.value.length > 0 ? (vue.openBlock(), vue.createBlock(_component_el_popover, {
+        key: 0,
+        "popper-class": "fm_query_condition_more",
+        bind: __props.popoverAttrsBind,
+        trigger: "click",
+        width: "auto",
+        ref: "popover"
+      }, {
+        reference: vue.withCtx(() => [
+          vue.createElementVNode("div", _hoisted_4, [
+            vue.createElementVNode(
+              "span",
+              _hoisted_5,
+              vue.toDisplayString(__props.popoverAttrsBind.showTxt || "\u66F4\u591A"),
+              1
+              /* TEXT */
+            ),
+            vue.createVNode(_component_el_icon, null, {
+              default: vue.withCtx(() => [
+                vue.createVNode(vue.unref(svg.ArrowDown))
+              ]),
+              _: 1
+              /* STABLE */
+            })
+          ])
+        ]),
+        default: vue.withCtx(() => [
+          vue.createElementVNode("div", _hoisted_1, [
+            vue.createElementVNode("div", _hoisted_2, [
+              vue.createElementVNode(
+                "div",
+                null,
+                vue.toDisplayString(__props.popoverAttrsBind.title || "\u6240\u6709\u6761\u4EF6"),
+                1
+                /* TEXT */
+              ),
+              vue.createElementVNode("div", _hoisted_3, [
+                vue.createVNode(_component_el_button, {
+                  size: "small",
+                  link: "",
+                  onClick: handlecheckAll
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(
+                      vue.toDisplayString(__props.popoverAttrsBind.allTxt || "\u5168\u9009"),
+                      1
+                      /* TEXT */
+                    )
+                  ]),
+                  _: 1
+                  /* STABLE */
+                }),
+                vue.createVNode(_component_el_button, {
+                  size: "small",
+                  link: "",
+                  onClick: handleReset
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(
+                      vue.toDisplayString(__props.popoverAttrsBind.clearTxt || "\u6E05\u7A7A"),
+                      1
+                      /* TEXT */
+                    )
+                  ]),
+                  _: 1
+                  /* STABLE */
+                }),
+                vue.createVNode(_component_el_button, {
+                  size: "small",
+                  link: "",
+                  onClick: handleReverseCheck
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(
+                      vue.toDisplayString(__props.popoverAttrsBind.reverseTxt || "\u53CD\u9009"),
+                      1
+                      /* TEXT */
+                    )
+                  ]),
+                  _: 1
+                  /* STABLE */
+                })
+              ])
+            ]),
+            vue.createVNode(_component_el_checkbox_group, {
+              modelValue: checkList.value,
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => checkList.value = $event),
+              class: "inside_box_main",
+              onChange: getcheck
+            }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(true), vue.createElementBlock(
+                  vue.Fragment,
+                  null,
+                  vue.renderList(allcheckList.value, (item, index) => {
+                    return vue.openBlock(), vue.createBlock(_component_el_checkbox, {
+                      key: index,
+                      label: item.label,
+                      value: item.label
+                    }, null, 8, ["label", "value"]);
+                  }),
+                  128
+                  /* KEYED_FRAGMENT */
+                ))
+              ]),
+              _: 1
+              /* STABLE */
+            }, 8, ["modelValue"])
+          ])
+        ]),
+        _: 1
+        /* STABLE */
+      }, 8, ["bind"])) : vue.createCommentVNode("v-if", true);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/core/ui/components/querycondition/renderComp.vue.js

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

package/lib/packages/core/ui/components/querycondition/renderComp.vue2.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "RenderComp"
+  },
+  __name: "renderComp",
+  props: {
+    render: Function,
+    form: Object
+  },
+  setup(__props) {
+    const props = __props;
+    const renderComponent = () => {
+      return props.render(props?.form);
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderComponent));
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/core/ui/components/querycondition/style/css.js

@@ -0,0 +1,4 @@
+'use strict';
+
+require('fm-dev/theme-chalk/query-condition.css');
+

package/lib/packages/core/ui/components/querycondition/style/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+require('fm-dev/theme-chalk/src/query-condition.scss');
+

package/lib/packages/core/ui/components/querycondition/type.js

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

package/lib/packages/core/ui/components/querycondition/useComputed.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var vue = require('vue');
+
+function useComputed() {
+  const compChildName = vue.computed(() => {
+    return (opt) => {
+      switch (opt.type) {
+        case "checkbox":
+          return "el-checkbox";
+        case "radio":
+          return "el-radio";
+        case "select-arr":
+        case "select-obj":
+          return "el-option";
+      }
+    };
+  });
+  const selectListType = vue.computed(() => {
+    return (opt) => {
+      if (opt.listTypeInfo) {
+        return opt.listTypeInfo[opt.list];
+      } else {
+        return [];
+      }
+    };
+  });
+  const compChildLabel = vue.computed(() => {
+    return (opt, value) => {
+      switch (opt.type) {
+        case "radio":
+        case "checkbox":
+          return value[opt.arrLabel || "label"];
+        case "el-select-multiple":
+        case "select-arr":
+          return value[opt.arrLabel || "label"];
+        case "select-obj":
+          return value;
+      }
+    };
+  });
+  const compChildValue = vue.computed(() => {
+    return (opt, value, key) => {
+      switch (opt.type) {
+        case "radio":
+        case "checkbox":
+          return value[opt.arrKey || "key"];
+        case "el-select-multiple":
+        case "select-arr":
+          return value[opt.arrKey || "key"];
+        case "select-obj":
+          return key;
+      }
+    };
+  });
+  const compChildShowLabel = vue.computed(() => {
+    return (opt, value) => {
+      switch (opt.type) {
+        case "radio":
+        case "checkbox":
+          return value[opt.arrLabel || "label"];
+        case "el-select-multiple":
+        case "select-arr":
+          return value[opt.arrLabel || "label"];
+        case "select-obj":
+          return value;
+      }
+    };
+  });
+  const getPlaceholder = (row) => {
+    let placeholder;
+    if (row.comp && typeof row.comp == "string") {
+      if (row.comp.includes("input")) {
+        placeholder = "\u8BF7\u8F93\u5165" + row.label;
+      } else if (row.comp.includes("select") || row.comp.includes("date")) {
+        placeholder = "\u8BF7\u9009\u62E9" + row.label;
+      } else {
+        placeholder = row.label;
+      }
+    }
+    return placeholder;
+  };
+  const getColLength = () => {
+    const width = window.innerWidth;
+    let colLength = 4;
+    if (width > 1e3 && width < 1280) {
+      colLength = 3;
+    } else if (width > 768 && width <= 1e3) {
+      colLength = 2;
+    } else if (width <= 768) {
+      colLength = 1;
+    }
+    return colLength;
+  };
+  return {
+    compChildName,
+    selectListType,
+    compChildLabel,
+    compChildValue,
+    compChildShowLabel,
+    getPlaceholder,
+    getColLength
+  };
+}
+
+exports.useComputed = useComputed;

package/lib/packages/core/ui/components/selecttable/ClickOutside.js

@@ -0,0 +1,73 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@vueuse/core');
+
+const nodeList = /* @__PURE__ */ new Map();
+let startClick;
+if (core.isClient) {
+  document.addEventListener("mousedown", (e) => startClick = e);
+  document.addEventListener("mouseup", (e) => {
+    for (const handlers of nodeList.values()) {
+      for (const { documentHandler } of handlers) {
+        documentHandler(e, startClick);
+      }
+    }
+  });
+}
+function createDocumentHandler(el, binding) {
+  let excludes = [];
+  if (Array.isArray(binding.arg)) {
+    excludes = binding.arg;
+  } else if (binding.arg instanceof HTMLElement) {
+    excludes.push(binding.arg);
+  }
+  return function(mouseup, mousedown) {
+    const popperRef = binding.instance.popperRef;
+    const mouseUpTarget = mouseup.target;
+    const mouseDownTarget = mousedown?.target;
+    const isBound = !binding || !binding.instance;
+    const isTargetExists = !mouseUpTarget || !mouseDownTarget;
+    const isContainedByEl = el.contains(mouseUpTarget) || el.contains(mouseDownTarget);
+    const isSelf = el === mouseUpTarget;
+    const isTargetExcluded = excludes.length && excludes.some((item) => item?.contains(mouseUpTarget)) || excludes.length && excludes.includes(mouseDownTarget);
+    const isContainedByPopper = popperRef && (popperRef.contains(mouseUpTarget) || popperRef.contains(mouseDownTarget));
+    if (isBound || isTargetExists || isContainedByEl || isSelf || isTargetExcluded || isContainedByPopper) {
+      return;
+    }
+    binding.value(mouseup, mousedown);
+  };
+}
+const ClickOutside = {
+  beforeMount(el, binding) {
+    if (!nodeList.has(el)) {
+      nodeList.set(el, []);
+    }
+    nodeList.get(el).push({
+      documentHandler: createDocumentHandler(el, binding),
+      bindingFn: binding.value
+    });
+  },
+  updated(el, binding) {
+    if (!nodeList.has(el)) {
+      nodeList.set(el, []);
+    }
+    const handlers = nodeList.get(el);
+    const oldHandlerIndex = handlers.findIndex((item) => item.bindingFn === binding.oldValue);
+    const newHandler = {
+      documentHandler: createDocumentHandler(el, binding),
+      bindingFn: binding.value
+    };
+    if (oldHandlerIndex >= 0) {
+      handlers.splice(oldHandlerIndex, 1, newHandler);
+    } else {
+      handlers.push(newHandler);
+    }
+  },
+  unmounted(el) {
+    nodeList.delete(el);
+  }
+};
+
+exports.default = ClickOutside;

package/lib/packages/core/ui/components/selecttable/index.vue.js

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