@fmdeui/fmui 1.0.1

package/lib/packages/components/query-condition/src/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 == null ? void 0 : item.label,
+          comp: item.comp,
+          bind: item == null ? void 0 : item.bind,
+          list: item == null ? void 0 : item.list,
+          eventHandle: item == null ? void 0 : item.eventHandle,
+          changeEvent: item == null ? void 0 : item.changeEvent,
+          listTypeInfo: item == null ? void 0 : item.listTypeInfo,
+          arrLabel: item == null ? void 0 : item.arrLabel,
+          arrKey: item == null ? void 0 : item.arrKey,
+          slotName: item == null ? void 0 : item.slotName,
+          span: item == null ? void 0 : item.span,
+          type: item == null ? void 0 : item.type,
+          isSelfCom: item && item.isSelfCom || false,
+          defaultVal: item == null ? void 0 : item.defaultVal,
+          placeholder: item == null ? void 0 : item.placeholder,
+          event: item == null ? void 0 : 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": "f_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),
+              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),
+                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),
+                      1
+                      /* TEXT */
+                    )
+                  ]),
+                  _: 1
+                  /* STABLE */
+                }),
+                vue.createVNode(_component_el_button, {
+                  size: "small",
+                  link: "",
+                  onClick: handleReset
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(
+                      vue.toDisplayString(__props.popoverAttrsBind.clearTxt),
+                      1
+                      /* TEXT */
+                    )
+                  ]),
+                  _: 1
+                  /* STABLE */
+                }),
+                vue.createVNode(_component_el_button, {
+                  size: "small",
+                  link: "",
+                  onClick: handleReverseCheck
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(
+                      vue.toDisplayString(__props.popoverAttrsBind.reverseTxt),
+                      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/components/query-condition/src/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/components/query-condition/src/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 == null ? void 0 : props.form);
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderComponent));
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/components/query-condition/src/type.js

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

package/lib/packages/components/query-condition/src/useComputed.js

@@ -0,0 +1,92 @@
+'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 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,
+    getColLength
+  };
+}
+
+exports.useComputed = useComputed;

package/lib/packages/components/query-condition/style/css.js

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

package/lib/packages/components/query-condition/style/index.js

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

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

@@ -0,0 +1,9 @@
+'use strict';
+
+require('./src/index.vue.js');
+require('./src/type.js');
+var index_vue_vue_type_script_setup_true_lang = require('./src/index.vue2.js');
+
+const FSelect = index_vue_vue_type_script_setup_true_lang.default;
+
+exports.FSelect = FSelect;

package/lib/packages/components/select/src/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;

package/lib/packages/components/select/src/index.vue2.js

@@ -0,0 +1,264 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+require('../../../hooks/index.js');
+var useLocale = require('../../../hooks/useLocale.js');
+
+const _hoisted_1 = {
+  key: 1,
+  class: "f_select__pagination"
+};
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "FSelect"
+  },
+  __name: "index",
+  props: {
+    modelValue: { default: void 0 },
+    multiple: { type: Boolean, default: false },
+    width: {},
+    valueCustom: { default: "key" },
+    labelCustom: { default: "label" },
+    customLabel: { default: "" },
+    optionSource: { default: () => [] },
+    filterable: { type: Boolean, default: true },
+    isShowPagination: { type: Boolean, default: false },
+    paginationOption: { default: () => ({
+      pageSize: 6,
+      currentPage: 1,
+      pagerCount: 5,
+      total: 0
+    }) },
+    useVirtual: { type: Boolean, default: false },
+    returnObject: { type: Boolean, default: false },
+    isCached: { type: Boolean, default: true },
+    isRadioEchoLabel: { type: Boolean, default: true },
+    radioSelectValLabel: { default: "" },
+    selectAllTxt: { default: "" }
+  },
+  emits: ["update:modelValue", "change", "input", "select-input"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const { t } = useLocale.useLocale();
+    const props = __props;
+    const fselectRef = vue.ref();
+    const filteredOptionsCount = vue.ref(1);
+    const slots = vue.useSlots();
+    const selectAllTxtText = vue.computed(() => props.selectAllTxt || t("plus.select.selectAllTxt"));
+    const emits = __emit;
+    const childSelectedValue = vue.computed({
+      get() {
+        return props.modelValue;
+      },
+      set(val) {
+        emits("update:modelValue", val);
+      }
+    });
+    const currentOptions = vue.ref(props.optionSource);
+    const cachedOptions = vue.ref(/* @__PURE__ */ new Map());
+    const mergedOptions = vue.computed(() => {
+      const currentValues = currentOptions.value.length > 0 && currentOptions.value.map((item) => item[props.valueCustom]) || [];
+      const cached = Array.from(cachedOptions.value.values()).filter(
+        (item) => !currentValues.includes(item[props.valueCustom])
+      );
+      return props.isShowPagination && props.isCached ? [...currentOptions.value, ...cached] : [...currentOptions.value];
+    });
+    vue.watch(
+      () => props.optionSource,
+      (newVal) => {
+        currentOptions.value = newVal || [];
+        newVal.length > 0 && newVal.forEach((item) => {
+          const isObject = typeof childSelectedValue.value === "object";
+          const condition = isObject ? Array.isArray(childSelectedValue.value) && childSelectedValue.value.includes(item[props.valueCustom]) : childSelectedValue.value === item[props.valueCustom];
+          if (condition) {
+            cachedOptions.value.set(item[props.valueCustom], item);
+          }
+        });
+      }
+    );
+    vue.watch(
+      () => props.radioSelectValLabel,
+      (val) => {
+        if (val && props.isRadioEchoLabel && !props.multiple && props.isShowPagination) {
+          childSelectedValue.value = val;
+        }
+      },
+      { deep: true }
+    );
+    vue.onMounted(() => {
+      currentOptions.value.forEach((item) => {
+        const isObject = typeof childSelectedValue.value === "object";
+        const condition = isObject ? Array.isArray(childSelectedValue.value) && childSelectedValue.value.includes(item[props.valueCustom]) : childSelectedValue.value === item[props.valueCustom];
+        if (condition) {
+          cachedOptions.value.set(item[props.valueCustom], item);
+        }
+      });
+      if (props.radioSelectValLabel && props.isRadioEchoLabel && !props.multiple && props.isShowPagination) {
+        childSelectedValue.value = props.radioSelectValLabel;
+      }
+    });
+    const handlesSelectInput = (e) => {
+      if (props.filterable) {
+        filteredOptionsCount.value = fselectRef.value.filteredOptionsCount;
+      }
+      emits("select-input", e.target.value);
+    };
+    const handlesChange = (value) => {
+      if (Array.isArray(value)) {
+        const newCache = /* @__PURE__ */ new Map();
+        value.forEach((val) => {
+          const item = mergedOptions.value.find((opt) => opt[props.valueCustom] === val);
+          if (item) newCache.set(val, item);
+        });
+        cachedOptions.value = newCache;
+      } else {
+        const item = mergedOptions.value.find((opt) => opt[props.valueCustom] === value);
+        cachedOptions.value = item ? /* @__PURE__ */ new Map([[value, item]]) : /* @__PURE__ */ new Map();
+      }
+      emits("change", value);
+    };
+    const selectChecked = vue.computed({
+      get() {
+        const _deval = props.modelValue;
+        const list = props.optionSource.filter((item) => {
+          return !item.disabled;
+        });
+        return (_deval == null ? void 0 : _deval.length) === list.length;
+      },
+      set(val) {
+        const list = props.optionSource.filter((item) => {
+          return !item.disabled;
+        });
+        return (val == null ? void 0 : val.length) === list.length;
+      }
+    });
+    const selectAll = (val) => {
+      let options = JSON.parse(JSON.stringify(props.optionSource));
+      options = options.filter((item) => {
+        return !item.disabled;
+      });
+      if (val) {
+        const selectedAllValue = options.map((item) => {
+          return item[props.valueCustom];
+        });
+        emits("update:modelValue", selectedAllValue);
+      } else {
+        emits("update:modelValue", null);
+      }
+    };
+    const customLabelHandler = (_item) => {
+      let fun = new Function("_item", "return " + props.customLabel);
+      return fun(_item);
+    };
+    const clear = () => {
+      emits("update:modelValue", null);
+    };
+    __expose({ clear });
+    return (_ctx, _cache) => {
+      const _component_el_checkbox = vue.resolveComponent("el-checkbox");
+      const _component_el_option = vue.resolveComponent("el-option");
+      const _component_el_pagination = vue.resolveComponent("el-pagination");
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(!__props.useVirtual ? "el-select" : "el-select-v2"), vue.mergeProps({
+        "popper-class": "f_select",
+        ref_key: "fselectRef",
+        ref: fselectRef,
+        modelValue: childSelectedValue.value,
+        "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => childSelectedValue.value = $event),
+        options: !__props.useVirtual ? null : __props.optionSource,
+        style: { width: __props.width || "100%" },
+        onChange: handlesChange,
+        onInput: handlesSelectInput
+      }, {
+        clearable: true,
+        filterable: __props.filterable,
+        multiple: __props.multiple,
+        ..._ctx.$attrs
+      }), vue.createSlots({
+        default: vue.withCtx(() => [
+          !__props.useVirtual ? (vue.openBlock(), vue.createElementBlock(
+            vue.Fragment,
+            { key: 0 },
+            [
+              __props.multiple && !__props.isShowPagination ? (vue.openBlock(), vue.createBlock(_component_el_checkbox, {
+                key: 0,
+                modelValue: selectChecked.value,
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => selectChecked.value = $event),
+                onChange: selectAll,
+                class: "all_checkbox"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createTextVNode(
+                    vue.toDisplayString(selectAllTxtText.value),
+                    1
+                    /* TEXT */
+                  )
+                ]),
+                _: 1
+                /* STABLE */
+              }, 8, ["modelValue"])) : vue.createCommentVNode("v-if", true),
+              (vue.openBlock(true), vue.createElementBlock(
+                vue.Fragment,
+                null,
+                vue.renderList(mergedOptions.value, (item, index) => {
+                  return vue.openBlock(), vue.createBlock(_component_el_option, {
+                    key: index + "i",
+                    label: __props.customLabel ? customLabelHandler(item) : item[__props.labelCustom],
+                    value: __props.returnObject ? item : item[__props.valueCustom],
+                    disabled: item.disabled
+                  }, vue.createSlots({
+                    _: 2
+                    /* DYNAMIC */
+                  }, [
+                    vue.renderList(vue.unref(slots), (_index, name) => {
+                      return {
+                        name,
+                        fn: vue.withCtx((data) => [
+                          vue.renderSlot(_ctx.$slots, name, vue.mergeProps({ ref_for: true }, data))
+                        ])
+                      };
+                    })
+                  ]), 1032, ["label", "value", "disabled"]);
+                }),
+                128
+                /* KEYED_FRAGMENT */
+              )),
+              __props.isShowPagination && filteredOptionsCount.value > 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+                vue.createVNode(_component_el_pagination, vue.mergeProps({
+                  "current-page": __props.paginationOption.currentPage,
+                  "onUpdate:currentPage": _cache[1] || (_cache[1] = ($event) => __props.paginationOption.currentPage = $event),
+                  "page-size": __props.paginationOption.pageSize,
+                  "onUpdate:pageSize": _cache[2] || (_cache[2] = ($event) => __props.paginationOption.pageSize = $event),
+                  layout: __props.paginationOption.layout || "total, prev, pager, next, jumper",
+                  "pager-count": __props.paginationOption.pagerCount,
+                  total: __props.paginationOption.total,
+                  onInput: _cache[3] || (_cache[3] = vue.withModifiers((e) => emits("input", e.target.value), ["stop"]))
+                }, {
+                  size: "small",
+                  background: true,
+                  ...__props.paginationOption.bind,
+                  ..._ctx.$attrs
+                }), null, 16, ["current-page", "page-size", "layout", "pager-count", "total"])
+              ])) : vue.createCommentVNode("v-if", true)
+            ],
+            64
+            /* STABLE_FRAGMENT */
+          )) : vue.createCommentVNode("v-if", true)
+        ]),
+        _: 2
+        /* DYNAMIC */
+      }, [
+        vue.renderList(vue.unref(slots), (_index, name) => {
+          return {
+            name,
+            fn: vue.withCtx((data) => [
+              vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(data)))
+            ])
+          };
+        })
+      ]), 1040, ["modelValue", "options", "style"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

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

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

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

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

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

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