@fmdeui/fmui 1.0.1

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

@@ -0,0 +1,468 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+require('./renderComp.vue.js');
+require('./renderBtn.vue.js');
+require('../../../hooks/index.js');
+var useLocale = require('../../../hooks/useLocale.js');
+var renderComp_vue_vue_type_script_setup_true_lang = require('./renderComp.vue2.js');
+var renderBtn_vue_vue_type_script_setup_true_lang = require('./renderBtn.vue2.js');
+
+const _hoisted_1 = {
+  key: 1,
+  class: "text_show"
+};
+const _hoisted_2 = { class: "footer_btn flex-box flex-ver f-margin-top-5" };
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "FForm"
+  },
+  __name: "index",
+  props: {
+    className: { default: "" },
+    formOpts: { default: () => ({}) },
+    widthSize: { default: 2 },
+    labelPosition: { default: "right" },
+    isTrim: { type: Boolean, default: true }
+  },
+  emits: ["update:modelValue", "handleEvent", "getRefs"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const cEvent = vue.computed(() => {
+      return (item, type = "") => {
+        let event = { ...item.eventHandle };
+        let changeEvent = {};
+        Object.keys(event).forEach((v) => {
+          changeEvent[v] = (e, ids) => {
+            if (type === "f-select-table") {
+              event[v] && event[v](e, ids);
+            } else {
+              event[v] && event[v](e, props.formOpts);
+            }
+          };
+        });
+        return { ...changeEvent };
+      };
+    });
+    const selectListType = vue.computed(() => {
+      return (item) => {
+        if (props.formOpts.listTypeInfo) {
+          return props.formOpts.listTypeInfo[item.list];
+        } else {
+          return [];
+        }
+      };
+    });
+    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 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 colSize = vue.ref(props.widthSize);
+    const fform = vue.ref(null);
+    const { t } = useLocale.useLocale();
+    const instance = vue.getCurrentInstance();
+    const emits = __emit;
+    vue.watch(
+      () => props.formOpts.formData,
+      () => {
+        emits("update:modelValue", fform.value);
+      },
+      { deep: true }
+    );
+    vue.watch(
+      () => props.widthSize,
+      (val) => {
+        if (val > 6) {
+          colSize.value = 6;
+        } else {
+          colSize.value = val;
+        }
+      },
+      { deep: true }
+    );
+    vue.onMounted(() => {
+      var _a;
+      const entries = Object.entries(fform.value.$.exposed);
+      for (const [key, value] of entries) {
+        instance.exposed[key] = value;
+      }
+      let event = null;
+      let item = null;
+      props.formOpts.formData && Object.keys((_a = props == null ? void 0 : props.formOpts) == null ? void 0 : _a.formData).forEach((key) => {
+        if (props.formOpts.formData[key]) {
+          props.formOpts.fieldList.map((val) => {
+            if (val.value == key) {
+              event = val.event;
+              item = val;
+            }
+          });
+          handleEvent(event, props.formOpts.formData[key], item, false);
+        }
+      });
+      emits("update:modelValue", fform.value);
+    });
+    const getChildWidth = (item) => {
+      if (props.formOpts.labelPosition === "top") {
+        return `flex: 0 1 calc((${100 / (item.widthSize || colSize.value)}% - 10px));margin-right:10px;`;
+      } else {
+        return `flex: 0 1 ${100 / (item.widthSize || colSize.value)}%;`;
+      }
+    };
+    const getPlaceholder = (row) => {
+      let placeholder;
+      if (row.comp && typeof row.comp == "string") {
+        if (row.comp.includes("input")) {
+          placeholder = t("plus.form.pleaseEnter") + row.label;
+        } else if (row.comp.includes("select") || row.comp.includes("date")) {
+          placeholder = t("plus.form.pleaseSelect") + row.label;
+        } else {
+          placeholder = row.label;
+        }
+      }
+      return placeholder;
+    };
+    const handleEvent = (type, val, item, flag = true) => {
+      var _a;
+      if (flag && props.isTrim && !item.isTrim && item.comp.includes("el-input") && ((_a = item == null ? void 0 : item.bind) == null ? void 0 : _a.type) !== "number" && item.type !== "password" && item.type !== "inputNumber") {
+        props.formOpts.formData[item.value] = props.formOpts.formData[item.value].trim();
+      }
+      emits("handleEvent", type, val);
+    };
+    const selfValidate = () => {
+      return new Promise((resolve, reject) => {
+        fform.value.validate((valid) => {
+          if (valid) {
+            resolve({
+              valid,
+              formData: props.formOpts.formData
+            });
+          } else {
+            reject({
+              valid,
+              formData: null
+            });
+          }
+        });
+      });
+    };
+    const getRefs = (el, item, index) => {
+      emits("getRefs", el, item, index);
+    };
+    const tselecttableref = vue.ref({});
+    const handleRef = (el, item, key) => {
+      emits("getRefs", el, item, key);
+      if (el) {
+        tselecttableref.value[`tselecttableref-${key}`] = el;
+      }
+    };
+    const selfResetFields = () => {
+      resetTselectTable();
+      fform.value.resetFields();
+    };
+    const resetTselectTable = () => {
+      const refList = Object.keys(tselecttableref.value).filter(
+        (item) => item.includes("tselecttableref")
+      );
+      if (refList.length > 0 && tselecttableref.value) {
+        refList.map((val) => {
+          tselecttableref.value[val].clear();
+        });
+      }
+    };
+    __expose({ ...instance.exposed, selfValidate, selfResetFields, resetTselectTable });
+    return (_ctx, _cache) => {
+      const _component_el_form_item = vue.resolveComponent("el-form-item");
+      const _component_el_button = vue.resolveComponent("el-button");
+      const _component_el_form = vue.resolveComponent("el-form");
+      return vue.openBlock(), vue.createBlock(_component_el_form, vue.mergeProps({
+        class: ["f-form", __props.className],
+        ref_key: "fform",
+        ref: fform,
+        model: __props.formOpts.formData,
+        rules: __props.formOpts.rules,
+        "label-width": __props.formOpts.labelWidth || "120px",
+        "label-position": __props.formOpts.labelPosition || __props.labelPosition || "right"
+      }, _ctx.$attrs), {
+        default: vue.withCtx(() => [
+          (vue.openBlock(true), vue.createElementBlock(
+            vue.Fragment,
+            null,
+            vue.renderList(__props.formOpts.fieldList, (item, index) => {
+              return vue.openBlock(), vue.createElementBlock(
+                vue.Fragment,
+                null,
+                [
+                  (typeof item.isHideItem == "function" ? item.isHideItem(__props.formOpts.formData) : !item.isHideItem) ? (vue.openBlock(), vue.createBlock(_component_el_form_item, vue.mergeProps({
+                    key: index,
+                    prop: item.value,
+                    label: item.label,
+                    class: [
+                      item.className,
+                      { render_label: item.labelRender },
+                      { slot_label: item.slotName },
+                      { render_laber_position_left: __props.formOpts.labelPosition === "left" }
+                    ],
+                    rules: item.rules,
+                    "label-width": item.labelWidth,
+                    style: getChildWidth(item)
+                  }, { ref_for: true }, _ctx.$attrs), vue.createSlots({
+                    default: vue.withCtx(() => [
+                      item.slotName ? vue.renderSlot(_ctx.$slots, item.slotName, {
+                        key: 0,
+                        scope: __props.formOpts.formData
+                      }) : vue.createCommentVNode("v-if", true),
+                      item.textShow ? (vue.openBlock(), vue.createElementBlock(
+                        "span",
+                        _hoisted_1,
+                        vue.toDisplayString(item.textValue || __props.formOpts.formData[item.value]),
+                        1
+                        /* TEXT */
+                      )) : vue.createCommentVNode("v-if", true),
+                      item.isSelfCom ? (vue.openBlock(), vue.createElementBlock(
+                        vue.Fragment,
+                        { key: 2 },
+                        [
+                          item.comp === "f-select-table" ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(item.comp), vue.mergeProps(
+                            {
+                              key: 0,
+                              ref_for: true,
+                              ref: (el) => handleRef(el, item, index),
+                              placeholder: item.placeholder || getPlaceholder(item)
+                            },
+                            { ref_for: true },
+                            typeof item.bind == "function" ? item.bind(__props.formOpts.formData) : { clearable: true, filterable: true, ...item.bind },
+                            {
+                              style: { width: item.width || "100%" }
+                            },
+                            vue.toHandlers(cEvent.value(item, "f-select-table"))
+                          ), null, 16, ["placeholder", "style"])) : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(item.comp), vue.mergeProps(
+                            {
+                              key: 1,
+                              modelValue: __props.formOpts.formData[item.value],
+                              "onUpdate:modelValue": ($event) => __props.formOpts.formData[item.value] = $event,
+                              placeholder: item.placeholder || getPlaceholder(item),
+                              ref_for: true,
+                              ref: (el) => getRefs(el, item, index)
+                            },
+                            { ref_for: true },
+                            typeof item.bind == "function" ? item.bind(__props.formOpts.formData) : { clearable: true, filterable: true, ...item.bind },
+                            {
+                              style: { width: item.width || "100%" }
+                            },
+                            vue.toHandlers(cEvent.value(item))
+                          ), null, 16, ["modelValue", "onUpdate:modelValue", "placeholder", "style"]))
+                        ],
+                        64
+                        /* STABLE_FRAGMENT */
+                      )) : vue.createCommentVNode("v-if", true),
+                      !item.slotName && !item.textShow && !item.isSelfCom ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(item.comp), vue.mergeProps(
+                        {
+                          key: 3,
+                          modelValue: __props.formOpts.formData[item.value],
+                          "onUpdate:modelValue": ($event) => __props.formOpts.formData[item.value] = $event,
+                          type: item.type,
+                          placeholder: item.placeholder || getPlaceholder(item),
+                          onChange: ($event) => handleEvent(item.event, __props.formOpts.formData[item.value], item),
+                          ref_for: true,
+                          ref: (el) => getRefs(el, item, index)
+                        },
+                        { ref_for: true },
+                        typeof item.bind == "function" ? item.bind(__props.formOpts.formData) : { clearable: true, filterable: true, ...item.bind },
+                        {
+                          style: { width: item.width || "100%" }
+                        },
+                        vue.toHandlers(cEvent.value(item))
+                      ), vue.createSlots({
+                        default: vue.withCtx(() => [
+                          item.childSlotName ? vue.renderSlot(_ctx.$slots, item.childSlotName, { key: 0 }) : vue.createCommentVNode("v-if", true),
+                          (vue.openBlock(true), vue.createElementBlock(
+                            vue.Fragment,
+                            null,
+                            vue.renderList(selectListType.value(item), (value, key) => {
+                              return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(compChildName.value(item)), {
+                                key: index,
+                                disabled: value.disabled,
+                                label: compChildLabel.value(item, value),
+                                value: compChildValue.value(item, value, key)
+                              }, {
+                                default: vue.withCtx(() => [
+                                  vue.createTextVNode(
+                                    vue.toDisplayString(compChildShowLabel.value(item, value)),
+                                    1
+                                    /* TEXT */
+                                  )
+                                ]),
+                                _: 2
+                                /* DYNAMIC */
+                              }, 1032, ["disabled", "label", "value"]);
+                            }),
+                            128
+                            /* KEYED_FRAGMENT */
+                          ))
+                        ]),
+                        _: 2
+                        /* DYNAMIC */
+                      }, [
+                        item.prepend ? {
+                          name: "prepend",
+                          fn: vue.withCtx(() => [
+                            vue.createTextVNode(
+                              vue.toDisplayString(item.prepend),
+                              1
+                              /* TEXT */
+                            )
+                          ]),
+                          key: "0"
+                        } : void 0,
+                        item.append ? {
+                          name: "append",
+                          fn: vue.withCtx(() => [
+                            vue.createTextVNode(
+                              vue.toDisplayString(item.append),
+                              1
+                              /* TEXT */
+                            )
+                          ]),
+                          key: "1"
+                        } : void 0
+                      ]), 1040, ["modelValue", "onUpdate:modelValue", "type", "placeholder", "onChange", "style"])) : vue.createCommentVNode("v-if", true)
+                    ]),
+                    _: 2
+                    /* DYNAMIC */
+                  }, [
+                    item.labelSlotName || item.labelRender ? {
+                      name: "label",
+                      fn: vue.withCtx(() => [
+                        item.labelRender ? (vue.openBlock(), vue.createBlock(renderComp_vue_vue_type_script_setup_true_lang.default, {
+                          key: 0,
+                          render: item.labelRender,
+                          item
+                        }, null, 8, ["render", "item"])) : vue.createCommentVNode("v-if", true),
+                        item.labelSlotName ? vue.renderSlot(_ctx.$slots, item.labelSlotName, {
+                          key: 1,
+                          scope: item
+                        }) : vue.createCommentVNode("v-if", true)
+                      ]),
+                      key: "0"
+                    } : void 0
+                  ]), 1040, ["prop", "label", "class", "rules", "label-width", "style"])) : vue.createCommentVNode("v-if", true)
+                ],
+                64
+                /* STABLE_FRAGMENT */
+              );
+            }),
+            256
+            /* UNKEYED_FRAGMENT */
+          )),
+          vue.createCommentVNode(" \u6309\u94AE "),
+          vue.createElementVNode("div", _hoisted_2, [
+            __props.formOpts.btnSlotName ? vue.renderSlot(_ctx.$slots, __props.formOpts.btnSlotName, { key: 0 }) : vue.createCommentVNode("v-if", true),
+            !__props.formOpts.btnSlotName && __props.formOpts.operatorList && __props.formOpts.operatorList.length > 0 ? (vue.openBlock(true), vue.createElementBlock(
+              vue.Fragment,
+              { key: 1 },
+              vue.renderList(__props.formOpts.operatorList, (val, index) => {
+                return vue.openBlock(), vue.createElementBlock(
+                  vue.Fragment,
+                  null,
+                  [
+                    val.render ? (vue.openBlock(), vue.createBlock(renderBtn_vue_vue_type_script_setup_true_lang.default, {
+                      key: index,
+                      item: val,
+                      render: val.render
+                    }, null, 8, ["item", "render"])) : (vue.openBlock(), vue.createElementBlock(
+                      vue.Fragment,
+                      { key: 1 },
+                      [
+                        !val.isHideBtn ? (vue.openBlock(), vue.createBlock(_component_el_button, vue.mergeProps({
+                          key: index,
+                          onClick: ($event) => val.fun(val)
+                        }, { ref_for: true }, {
+                          type: "primary",
+                          size: "small",
+                          ...val.bind
+                        }), {
+                          default: vue.withCtx(() => [
+                            vue.createTextVNode(
+                              vue.toDisplayString(val.label),
+                              1
+                              /* TEXT */
+                            )
+                          ]),
+                          _: 2
+                          /* DYNAMIC */
+                        }, 1040, ["onClick"])) : vue.createCommentVNode("v-if", true)
+                      ],
+                      64
+                      /* STABLE_FRAGMENT */
+                    ))
+                  ],
+                  64
+                  /* STABLE_FRAGMENT */
+                );
+              }),
+              256
+              /* UNKEYED_FRAGMENT */
+            )) : vue.createCommentVNode("v-if", true)
+          ])
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 16, ["class", "model", "rules", "label-width", "label-position"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/components/form/src/renderBtn.vue.js

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

package/lib/packages/components/form/src/renderBtn.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: "RenderBtn"
+  },
+  __name: "renderBtn",
+  props: {
+    render: Function,
+    item: Object
+  },
+  setup(__props) {
+    const props = __props;
+    const renderComponent = () => {
+      return props.render(props == null ? void 0 : props.item);
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderComponent));
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/components/form/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/form/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,
+    item: Object
+  },
+  setup(__props) {
+    const props = __props;
+    const renderComponent = () => {
+      return props.render(props == null ? void 0 : props.item);
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderComponent));
+    };
+  }
+});
+
+exports.default = _sfc_main;

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

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

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

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

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

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

package/lib/packages/components/index.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var index = require('./button/index.js');
+var index$3 = require('./input/index.js');
+var index$4 = require('./layout-page/index.js');
+var index$5 = require('./layout-page-item/index.js');
+var index$1 = require('./chart/index.js');
+var index$7 = require('./select/index.js');
+var index$8 = require('./select-table/index.js');
+var index$6 = require('./query-condition/index.js');
+var index$2 = require('./form/index.js');
+
+
+
+exports.FButton = index.FButton;
+exports.FInput = index$3.FInput;
+exports.FLayoutPage = index$4.FLayoutPage;
+exports.FLayoutPageItem = index$5.FLayoutPageItem;
+exports.FChart = index$1.FChart;
+exports.FSelect = index$7.FSelect;
+exports.FSelectTable = index$8.FSelectTable;
+exports.FQueryCondition = index$6.FQueryCondition;
+exports.FForm = index$2.FForm;

package/lib/packages/components/input/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 FInput = index_vue_vue_type_script_setup_true_lang.default;
+
+exports.FInput = FInput;

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