m-eleplus-crud 0.0.3 → 0.0.4

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

@@ -2,34 +2,641 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var runtime = require('../../../utils/vue/props/runtime.js');
-var index = require('../../../hooks/use-size/index.js');
+var vue = require('vue');
+var lodashUnified = require('lodash-unified');
+var form = require('./form.js');
+var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
+var useGlobalConfig = require('../../config-provider/src/hooks/use-global-config.js');
+var error = require('../../../utils/error.js');
 
-const formProps = runtime.buildProps({
-  size: index.useSizeProp,
-  model: {
-    type: Object,
-    required: true
-  },
-  loading: {
-    type: Boolean,
-    default: false
-  },
-  permission: {
-    type: Object,
-    default: {}
-  },
-  readonly: {
-    type: Boolean,
-    default: false
-  },
-  option: {
-    type: runtime.definePropType(Object),
-    required: false
+const COMPONENT_NAME = "MForm";
+const __default__ = vue.defineComponent({
+  name: COMPONENT_NAME
+});
+const _sfc_main = vue.defineComponent({
+  ...__default__,
+  props: form.formProps,
+  emits: form.formEmits,
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const slots = vue.useSlots();
+    const globalConfig = useGlobalConfig.useGlobalConfig();
+    const formRef = vue.ref();
+    const INPUT_TYPES = [
+      "input",
+      "textarea",
+      "number",
+      "password",
+      "qrcode",
+      "barcode"
+    ];
+    const DATE_TYPES = [
+      "year",
+      "month",
+      "date",
+      "datetime",
+      "week",
+      "datetimerange",
+      "daterange",
+      "monthrange",
+      "yearrange",
+      "time",
+      "timerange"
+    ];
+    const NEED_DIC_TYPE = ["select", "checkbox", "radio", "switch"];
+    const formOption = vue.ref({
+      labelWidth: "80px",
+      column: []
+    });
+    const detailTableRows = vue.computed(() => {
+      const rows = [];
+      let currentRow = [];
+      let currentTotal = 0;
+      for (const item of formOption.value.column || []) {
+        const req = item.span || 12;
+        if (currentTotal + req > 24) {
+          rows.push(currentRow);
+          currentRow = [];
+          currentTotal = 0;
+        }
+        currentRow.push(item);
+        currentTotal += req;
+      }
+      if (currentRow.length)
+        rows.push(currentRow);
+      return rows;
+    });
+    const proxys = new Proxy(props.model, {
+      get(target, property) {
+        return lodashUnified.get(target, property);
+      },
+      set(target, property, value) {
+        lodashUnified.set(target, property, value);
+        return true;
+      }
+    });
+    const initValue = () => {
+      var _a;
+      if (formOption.value && formOption.value.column) {
+        for (let i = 0; i < ((_a = formOption.value.column) == null ? void 0 : _a.length); i++) {
+          const column = formOption.value.column[i];
+          if (column.prop && proxys[column.prop] === void 0) {
+            if (column.value) {
+              proxys[column.prop] = column.value;
+            } else {
+              const ARR_TYPES = [
+                "checkbox",
+                "datetimerange",
+                "daterange",
+                "monthrange",
+                "yearrange",
+                "timerange"
+              ];
+              if (column.type === "select" && column.multiple || ARR_TYPES.includes(column.type || "")) {
+                proxys[column.prop] = [];
+              } else {
+                proxys[column.prop] = "";
+              }
+            }
+          }
+        }
+      }
+    };
+    const getValueFormatByType = (type) => {
+      let format = "";
+      switch (type) {
+        case "yearrange":
+        case "year":
+          format = "YYYY";
+          break;
+        case "monthrange":
+        case "month":
+          format = "YYYY-MM";
+          break;
+        case "daterange":
+        case "week":
+        case "date":
+          format = "YYYY-MM-DD";
+          break;
+        case "datetimerange":
+        case "datetime":
+          format = "YYYY-MM-DD HH:mm:ss";
+          break;
+        case "time":
+          format = "HH:mm:ss";
+          break;
+      }
+      return format;
+    };
+    const getAllRemoteDics = () => {
+      var _a, _b, _c, _d;
+      const hasDicUrl = (_b = (_a = formOption.value) == null ? void 0 : _a.column) == null ? void 0 : _b.some((column) => column.dicUrl);
+      if (hasDicUrl && !((_c = globalConfig.value) == null ? void 0 : _c.httpGet)) {
+        error.debugWarn("MForm", "global config httpGet is null");
+        return;
+      }
+      const updateRemoteDic = (column) => {
+        return new Promise((resolve) => {
+          let isSuccess = false;
+          globalConfig.value.httpGet(column.dicUrl, column.dicQuery, column.dicHeaders).then((e) => {
+            const { list, label, value } = column.dicFormatter(e);
+            if (list && Array.isArray(list)) {
+              column["dicData"] = list.map((item) => {
+                const lastLabel = label.replace(/\{(\w+)\}/g, (match, key) => {
+                  return item[key] || match;
+                });
+                return {
+                  label: lastLabel,
+                  value: item[value]
+                };
+              });
+              isSuccess = true;
+            }
+          }).finally(() => {
+            if (!isSuccess) {
+              column["dicData"] = [];
+            }
+            resolve(null);
+          });
+        });
+      };
+      for (let i = 0; i < (((_d = formOption.value) == null ? void 0 : _d.column) || []).length; i++) {
+        const column = formOption.value.column[i];
+        if (column.dicUrl) {
+          if (!column.dicFormatter) {
+            error.debugWarn("MForm", "dicUrl and dicFormatter must be used together");
+            continue;
+          }
+          updateRemoteDic(column);
+        }
+      }
+    };
+    const getFormItemEventBind = (column) => {
+      const result = {};
+      for (const key in column) {
+        if (key.startsWith("event")) {
+          let funName = key.replace("event", "");
+          funName = funName.charAt(0).toLowerCase() + funName.slice(1);
+          result[funName] = column[key];
+        }
+      }
+      return result;
+    };
+    const formatDicValue = (row, column) => {
+      let dictLabel = "";
+      const findLabelByValue = (dicData, value) => {
+        const dictItem = (dicData || []).find((dict) => dict.value === value);
+        if (dictItem === void 0) {
+          return dictLabel;
+        }
+        return dictItem.label;
+      };
+      if (column.type === "select" && column.multiple || column.type === "checkbox") {
+        let values = [];
+        if (row[column.prop || ""] != null && row[column.prop || ""] != void 0 && row[column.prop || ""] !== "") {
+          if (Array.isArray(row[column.prop || ""])) {
+            values = row[column.prop || ""];
+          } else if (typeof row[column.prop || ""] === "string") {
+            values = row[column.prop || ""].split(",");
+          } else {
+            values = [row[column.prop || ""]];
+          }
+        }
+        const result = [];
+        for (const value of values) {
+          dictLabel = findLabelByValue(column.dicData || [], value);
+          if (dictLabel === void 0) {
+            break;
+          }
+          result.push(dictLabel);
+        }
+        return result.join(",");
+      }
+      dictLabel = findLabelByValue(column.dicData || [], row[column.prop || ""]);
+      return dictLabel;
+    };
+    const getDetailPic = (row, column) => {
+      if (!row || !row[column.prop || ""]) {
+        return [];
+      }
+      const pics = row[column.prop || ""].split(column.imgSuffix || ";").map((pic) => (column.imgPrefix || "") + pic);
+      return pics;
+    };
+    const getValueColspan = (item, rows, index) => {
+      const getRemaining = (row) => {
+        const used = row.reduce((acc, item2) => acc + (item2.span || 12), 0);
+        return 24 - used;
+      };
+      if (index === rows.length - 1) {
+        return (item.span || 12) + getRemaining(rows) - 1;
+      }
+      return (item.span || 12) - 1;
+    };
+    const validForm = () => {
+      return new Promise((resolve) => {
+        formRef.value.validate((valid) => {
+          resolve(valid);
+        });
+      });
+    };
+    const clear = () => {
+      var _a, _b;
+      (_a = formRef.value) == null ? void 0 : _a.clearValidate();
+      (_b = formRef.value) == null ? void 0 : _b.resetFields();
+    };
+    vue.watch(
+      () => props.option,
+      (newVal) => {
+        if (newVal) {
+          formOption.value = Object.assign({}, formOption.value, newVal);
+          if (newVal.column) {
+            formOption.value.column = lodashUnified.cloneDeep(
+              newVal.column.filter(
+                (column) => !(props.permission[column.prop || ""] === false)
+              ).sort((a, b) => (b.order || 0) - (a.order || 0))
+            );
+            getAllRemoteDics();
+            if (!props.readonly) {
+              initValue();
+            }
+          }
+        }
+      },
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+    __expose({
+      validForm,
+      clear
+    });
+    return (_ctx, _cache) => {
+      const _component_el_input = vue.resolveComponent("el-input");
+      const _component_el_option = vue.resolveComponent("el-option");
+      const _component_el_select = vue.resolveComponent("el-select");
+      const _component_el_radio = vue.resolveComponent("el-radio");
+      const _component_el_radio_group = vue.resolveComponent("el-radio-group");
+      const _component_el_checkbox = vue.resolveComponent("el-checkbox");
+      const _component_el_checkbox_group = vue.resolveComponent("el-checkbox-group");
+      const _component_el_switch = vue.resolveComponent("el-switch");
+      const _component_el_date_picker = vue.resolveComponent("el-date-picker");
+      const _component_el_time_picker = vue.resolveComponent("el-time-picker");
+      const _component_el_form_item = vue.resolveComponent("el-form-item");
+      const _component_el_col = vue.resolveComponent("el-col");
+      const _component_el_row = vue.resolveComponent("el-row");
+      const _component_el_form = vue.resolveComponent("el-form");
+      const _component_MPicture = vue.resolveComponent("MPicture");
+      const _component_MQrcode = vue.resolveComponent("MQrcode");
+      const _component_MBarcode = vue.resolveComponent("MBarcode");
+      return vue.openBlock(), vue.createElementBlock("div", { class: "m-form" }, [
+        vue.createCommentVNode("\u7F16\u8F91\u6A21\u5F0F"),
+        !_ctx.readonly ? (vue.openBlock(), vue.createBlock(_component_el_form, {
+          key: 0,
+          ref_key: "formRef",
+          ref: formRef,
+          model: vue.unref(proxys),
+          disabled: _ctx.loading,
+          size: _ctx.size || vue.unref(globalConfig).size,
+          "label-width": formOption.value.labelWidth,
+          style: { "width": "100%" },
+          onSubmit: vue.withModifiers(() => {
+          }, ["prevent"])
+        }, {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_el_row, { gutter: 0 }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(true), vue.createElementBlock(
+                  vue.Fragment,
+                  null,
+                  vue.renderList(formOption.value.column, (column, columnIndex) => {
+                    return vue.openBlock(), vue.createBlock(_component_el_col, {
+                      key: columnIndex,
+                      span: column.span || 12
+                    }, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(_component_el_form_item, {
+                          style: { "width": "100%" },
+                          label: column.label + ":",
+                          prop: column.prop,
+                          rules: column.rules,
+                          "label-width": column.labelWidth || formOption.value.labelWidth
+                        }, {
+                          default: vue.withCtx(() => [
+                            vue.createCommentVNode("\u63D2\u69FD\u4FE1\u606F"),
+                            vue.unref(slots)[column.prop || ""] ? vue.renderSlot(_ctx.$slots, column.prop, vue.mergeProps({
+                              key: 0,
+                              ref_for: true
+                            }, { size: _ctx.size || vue.unref(globalConfig).size, loading: _ctx.loading })) : !column.type || INPUT_TYPES.includes(column.type) ? (vue.openBlock(), vue.createElementBlock(
+                              vue.Fragment,
+                              { key: 1 },
+                              [
+                                vue.createCommentVNode(""),
+                                vue.createCommentVNode("\u8F93\u5165\u6846"),
+                                vue.createVNode(_component_el_input, vue.mergeProps({
+                                  modelValue: vue.unref(proxys)[column.prop || ""],
+                                  "onUpdate:modelValue": ($event) => vue.unref(proxys)[column.prop || ""] = $event,
+                                  modelModifiers: { trim: true },
+                                  style: { "width": "100%" },
+                                  placeholder: column.placeholder,
+                                  maxlength: column.maxlength,
+                                  "show-word-limit": column.showWordLimit,
+                                  "show-password": column.showPassword,
+                                  type: !column.type || column.type === "input" ? "text" : column.type
+                                }, vue.toHandlers(getFormItemEventBind(column))), null, 16, ["modelValue", "onUpdate:modelValue", "placeholder", "maxlength", "show-word-limit", "show-password", "type"])
+                              ],
+                              2112
+                            )) : column.type === "select" ? (vue.openBlock(), vue.createElementBlock(
+                              vue.Fragment,
+                              { key: 2 },
+                              [
+                                vue.createCommentVNode(""),
+                                vue.createCommentVNode("\u4E0B\u62C9\u6846"),
+                                vue.createVNode(_component_el_select, vue.mergeProps({
+                                  modelValue: vue.unref(proxys)[column.prop || ""],
+                                  "onUpdate:modelValue": ($event) => vue.unref(proxys)[column.prop || ""] = $event,
+                                  modelModifiers: { trim: true },
+                                  style: { "width": "100%" },
+                                  placeholder: column.placeholder,
+                                  multiple: column.multiple,
+                                  clearable: column.clearable,
+                                  filterable: column.filterable,
+                                  "filter-method": column.filterMethod,
+                                  remote: column.remote,
+                                  "remote-method": column.remoteMethod,
+                                  loading: column.loading
+                                }, vue.toHandlers(getFormItemEventBind(column))), {
+                                  default: vue.withCtx(() => [
+                                    (vue.openBlock(true), vue.createElementBlock(
+                                      vue.Fragment,
+                                      null,
+                                      vue.renderList(column.dicData || [], (dicItem, dicIndex) => {
+                                        return vue.openBlock(), vue.createBlock(_component_el_option, {
+                                          key: dicIndex,
+                                          label: dicItem.label,
+                                          value: dicItem.value
+                                        }, null, 8, ["label", "value"]);
+                                      }),
+                                      128
+                                    ))
+                                  ]),
+                                  _: 2
+                                }, 1040, ["modelValue", "onUpdate:modelValue", "placeholder", "multiple", "clearable", "filterable", "filter-method", "remote", "remote-method", "loading"])
+                              ],
+                              2112
+                            )) : column.type === "radio" ? (vue.openBlock(), vue.createElementBlock(
+                              vue.Fragment,
+                              { key: 3 },
+                              [
+                                vue.createCommentVNode(""),
+                                vue.createCommentVNode("radio"),
+                                vue.createVNode(_component_el_radio_group, vue.mergeProps({
+                                  modelValue: vue.unref(proxys)[column.prop || ""],
+                                  "onUpdate:modelValue": ($event) => vue.unref(proxys)[column.prop || ""] = $event,
+                                  style: { "width": "100%" }
+                                }, vue.toHandlers(getFormItemEventBind(column))), {
+                                  default: vue.withCtx(() => [
+                                    (vue.openBlock(true), vue.createElementBlock(
+                                      vue.Fragment,
+                                      null,
+                                      vue.renderList(column.dicData || [], (dicItem, dicIndex) => {
+                                        return vue.openBlock(), vue.createBlock(_component_el_radio, {
+                                          key: dicIndex,
+                                          value: dicItem.value,
+                                          label: dicItem.value
+                                        }, {
+                                          default: vue.withCtx(() => [
+                                            vue.createTextVNode(
+                                              vue.toDisplayString(dicItem.label),
+                                              1
+                                            )
+                                          ]),
+                                          _: 2
+                                        }, 1032, ["value", "label"]);
+                                      }),
+                                      128
+                                    ))
+                                  ]),
+                                  _: 2
+                                }, 1040, ["modelValue", "onUpdate:modelValue"])
+                              ],
+                              2112
+                            )) : column.type === "checkbox" ? (vue.openBlock(), vue.createElementBlock(
+                              vue.Fragment,
+                              { key: 4 },
+                              [
+                                vue.createCommentVNode(""),
+                                vue.createCommentVNode("checkbox"),
+                                vue.createVNode(_component_el_checkbox_group, vue.mergeProps({
+                                  modelValue: vue.unref(proxys)[column.prop || ""],
+                                  "onUpdate:modelValue": ($event) => vue.unref(proxys)[column.prop || ""] = $event,
+                                  style: { "width": "100%" }
+                                }, vue.toHandlers(getFormItemEventBind(column))), {
+                                  default: vue.withCtx(() => [
+                                    (vue.openBlock(true), vue.createElementBlock(
+                                      vue.Fragment,
+                                      null,
+                                      vue.renderList(column.dicData || [], (dicItem, dicIndex) => {
+                                        return vue.openBlock(), vue.createBlock(_component_el_checkbox, {
+                                          key: dicIndex,
+                                          label: dicItem.label,
+                                          value: dicItem.value
+                                        }, null, 8, ["label", "value"]);
+                                      }),
+                                      128
+                                    ))
+                                  ]),
+                                  _: 2
+                                }, 1040, ["modelValue", "onUpdate:modelValue"])
+                              ],
+                              2112
+                            )) : column.type === "switch" ? (vue.openBlock(), vue.createElementBlock(
+                              vue.Fragment,
+                              { key: 5 },
+                              [
+                                vue.createCommentVNode(""),
+                                vue.createCommentVNode("switch"),
+                                !column.dicData || column.dicData.length != 2 ? (vue.openBlock(), vue.createElementBlock("span", {
+                                  key: 0,
+                                  style: { "color": "var(--el-text-color-placeholder)", "line-height": "32px", "height": "32px" }
+                                }, '"dicData/dicUrl\u7684\u7ED3\u679C"\u672A\u8BBE\u7F6E\u6216\u957F\u5EA6\u4E0D\u7B49\u4E8E2')) : (vue.openBlock(), vue.createElementBlock(
+                                  vue.Fragment,
+                                  { key: 1 },
+                                  [
+                                    vue.createVNode(_component_el_switch, vue.mergeProps({
+                                      modelValue: vue.unref(proxys)[column.prop || ""],
+                                      "onUpdate:modelValue": ($event) => vue.unref(proxys)[column.prop || ""] = $event,
+                                      "active-value": column.dicData[0].value,
+                                      "inactive-value": column.dicData[1].value
+                                    }, vue.toHandlers(getFormItemEventBind(column))), null, 16, ["modelValue", "onUpdate:modelValue", "active-value", "inactive-value"]),
+                                    vue.createElementVNode(
+                                      "span",
+                                      { style: { "font-size": "var(--el-font-size-base)", "color": "var(--el-text-color-regular)", "margin-left": "6px" } },
+                                      vue.toDisplayString(vue.unref(proxys)[column.prop || ""] === column.dicData[0].value ? column.dicData[0].label : column.dicData[1].label),
+                                      1
+                                    )
+                                  ],
+                                  64
+                                ))
+                              ],
+                              64
+                            )) : DATE_TYPES.includes(column.type) ? (vue.openBlock(), vue.createElementBlock(
+                              vue.Fragment,
+                              { key: 6 },
+                              [
+                                vue.createCommentVNode(""),
+                                vue.createCommentVNode("\u65F6\u95F4"),
+                                column.type !== "time" && column.type !== "timerange" ? (vue.openBlock(), vue.createBlock(_component_el_date_picker, vue.mergeProps({
+                                  key: 0,
+                                  modelValue: vue.unref(proxys)[column.prop || ""],
+                                  "onUpdate:modelValue": ($event) => vue.unref(proxys)[column.prop || ""] = $event,
+                                  type: column.type,
+                                  clearable: column.clearable,
+                                  "start-placeholder": column.startPlaceholder,
+                                  "end-placeholder": column.endPlaceholder,
+                                  format: column.format,
+                                  "value-format": column.valueFormat || getValueFormatByType(column.type)
+                                }, vue.toHandlers(getFormItemEventBind(column))), null, 16, ["modelValue", "onUpdate:modelValue", "type", "clearable", "start-placeholder", "end-placeholder", "format", "value-format"])) : (vue.openBlock(), vue.createBlock(_component_el_time_picker, vue.mergeProps({
+                                  key: 1,
+                                  modelValue: vue.unref(proxys)[column.prop || ""],
+                                  "onUpdate:modelValue": ($event) => vue.unref(proxys)[column.prop || ""] = $event,
+                                  "is-range": column.type === "timerange",
+                                  clearable: column.clearable,
+                                  "start-placeholder": column.startPlaceholder,
+                                  "end-placeholder": column.endPlaceholder,
+                                  "value-format": column.valueFormat || getValueFormatByType(column.type)
+                                }, vue.toHandlers(getFormItemEventBind(column))), null, 16, ["modelValue", "onUpdate:modelValue", "is-range", "clearable", "start-placeholder", "end-placeholder", "value-format"]))
+                              ],
+                              64
+                            )) : column.type === "picture" ? (vue.openBlock(), vue.createElementBlock(
+                              vue.Fragment,
+                              { key: 7 },
+                              [
+                                vue.createCommentVNode(""),
+                                vue.createCommentVNode("picture"),
+                                vue.createElementVNode("span", { style: { "color": "var(--el-text-color-regular)", "line-height": "32px", "height": "32px" } }, " \u6682\u4E0D\u652F\u6301picture\uFF0C\u8BF7\u4F7F\u7528\u63D2\u69FD\u81EA\u884C\u5B9E\u73B0 ")
+                              ],
+                              2112
+                            )) : vue.createCommentVNode("v-if", true),
+                            vue.createCommentVNode("")
+                          ]),
+                          _: 2
+                        }, 1032, ["label", "prop", "rules", "label-width"])
+                      ]),
+                      _: 2
+                    }, 1032, ["span"]);
+                  }),
+                  128
+                ))
+              ]),
+              _: 3
+            })
+          ]),
+          _: 3
+        }, 8, ["model", "disabled", "size", "label-width", "onSubmit"])) : (vue.openBlock(), vue.createElementBlock(
+          vue.Fragment,
+          { key: 1 },
+          [
+            vue.createCommentVNode(""),
+            vue.createCommentVNode("\u8BE6\u60C5\u6A21\u5F0F"),
+            vue.createElementVNode("table", { class: "detail-desc" }, [
+              vue.createElementVNode("tbody", null, [
+                (vue.openBlock(true), vue.createElementBlock(
+                  vue.Fragment,
+                  null,
+                  vue.renderList(detailTableRows.value, (row, rowIndex) => {
+                    return vue.openBlock(), vue.createElementBlock("tr", { key: rowIndex }, [
+                      (vue.openBlock(true), vue.createElementBlock(
+                        vue.Fragment,
+                        null,
+                        vue.renderList(row, (column, index) => {
+                          return vue.openBlock(), vue.createElementBlock(
+                            vue.Fragment,
+                            { key: index },
+                            [
+                              vue.createElementVNode(
+                                "td",
+                                {
+                                  style: vue.normalizeStyle({ width: column.labelWidth || formOption.value.labelWidth }),
+                                  colspan: "1",
+                                  class: "label"
+                                },
+                                vue.toDisplayString(column.label),
+                                5
+                              ),
+                              vue.createElementVNode("td", {
+                                colspan: getValueColspan(column, row, index)
+                              }, [
+                                column.type === "picture" ? (vue.openBlock(), vue.createBlock(_component_MPicture, {
+                                  key: 0,
+                                  src: getDetailPic(vue.unref(proxys), column)[0],
+                                  "preview-src-list": getDetailPic(vue.unref(proxys), column)[0],
+                                  "img-width": "100px",
+                                  "img-height": "100px"
+                                }, null, 8, ["src", "preview-src-list"])) : NEED_DIC_TYPE.includes(column.type || "") ? (vue.openBlock(), vue.createElementBlock(
+                                  vue.Fragment,
+                                  { key: 1 },
+                                  [
+                                    vue.createTextVNode(
+                                      vue.toDisplayString(formatDicValue(vue.unref(proxys), column)),
+                                      1
+                                    )
+                                  ],
+                                  64
+                                )) : column.type === "qrcode" ? (vue.openBlock(), vue.createElementBlock(
+                                  vue.Fragment,
+                                  { key: 2 },
+                                  [
+                                    vue.unref(proxys)[column.prop || ""] ? (vue.openBlock(), vue.createBlock(_component_MQrcode, {
+                                      key: 0,
+                                      text: vue.unref(proxys)[column.prop || ""],
+                                      align: "center"
+                                    }, null, 8, ["text"])) : vue.createCommentVNode("v-if", true)
+                                  ],
+                                  64
+                                )) : column.type === "barcode" ? (vue.openBlock(), vue.createElementBlock(
+                                  vue.Fragment,
+                                  { key: 3 },
+                                  [
+                                    vue.unref(proxys)[column.prop || ""] ? (vue.openBlock(), vue.createBlock(_component_MBarcode, {
+                                      key: 0,
+                                      text: vue.unref(proxys)[column.prop || ""],
+                                      align: "center"
+                                    }, null, 8, ["text"])) : vue.createCommentVNode("v-if", true)
+                                  ],
+                                  64
+                                )) : (vue.openBlock(), vue.createElementBlock(
+                                  vue.Fragment,
+                                  { key: 4 },
+                                  [
+                                    vue.createTextVNode(
+                                      vue.toDisplayString(vue.unref(proxys)[column.prop || ""]),
+                                      1
+                                    )
+                                  ],
+                                  64
+                                ))
+                              ], 8, ["colspan"])
+                            ],
+                            64
+                          );
+                        }),
+                        128
+                      ))
+                    ]);
+                  }),
+                  128
+                ))
+              ])
+            ])
+          ],
+          64
+        ))
+      ]);
+    };
   }
 });
-const formEmits = {};
+var Form = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "form.vue"]]);
 
-exports.formEmits = formEmits;
-exports.formProps = formProps;
+exports["default"] = Form;
 //# sourceMappingURL=form2.js.map