@gct-paas/excel 0.1.0

package/dist/ref-autofill-editor-BrhHeEgk.js

@@ -0,0 +1,676 @@
+import { defineComponent, computed, resolveComponent, openBlock, createElementBlock, createVNode, withCtx, toRefs, ref, reactive, onMounted, createElementVNode, createTextVNode, toDisplayString, unref, createBlock, normalizeClass, createCommentVNode, withDirectives, vShow, h, mergeProps } from "vue";
+import { _ as _export_sfc } from "./uuid-CvPXRkky.js";
+import { o as SEARCH_TYPE, F as FormItem, u as useModelFields, e as draggable, t as transformMappingField4Auto } from "./index-XHxr4hJa.js";
+import { F as FIELD_TYPE, C as CreateType, g as FieldIconMap } from "./Scrollbar-Bl_rv9eK.js";
+import { cloneDeep } from "lodash-es";
+import { api } from "@gct-paas/api";
+import { useModal } from "@gct-paas/core";
+import { SubTableType } from "@gct-paas/excel-base";
+const _hoisted_1$2 = { class: "quick-search-editor" };
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "quick-search-editor",
+  props: {
+    fieldMeta: {},
+    searchField: {},
+    disabled: { type: Boolean }
+  },
+  emits: ["update:searchField"],
+  setup(__props, { emit: __emit }) {
+    const { modelMetaMap } = useModelFields();
+    const filterFields = [
+      FIELD_TYPE.LONG_TEXT,
+      FIELD_TYPE.TEXT,
+      FIELD_TYPE.DECIMAL,
+      FIELD_TYPE.DOUBLE,
+      FIELD_TYPE.LONG,
+      FIELD_TYPE.INTEGER
+    ];
+    const filterTypes = [CreateType.USER_DEFINED, CreateType.BUILTIN];
+    const props = __props;
+    const emit = __emit;
+    const currentModelMeta = computed(() => {
+      return modelMetaMap.value[props.fieldMeta.refModelKey];
+    });
+    const fieldOptions = computed(() => {
+      return currentModelMeta.value?.fields?.filter((i) => {
+        return checkKeyByList(i.type, filterFields) && checkKeyByList(i.createType, filterTypes);
+      }).map((i) => {
+        const exp = SEARCH_TYPE[i.type]?.noRangDefaultExp;
+        return {
+          name: i.name,
+          key: exp ? i.key + "." + exp : i.key
+        };
+      });
+    });
+    const checkKeyByList = (key, filters) => {
+      return !filters || filters.indexOf(key) > -1;
+    };
+    const value = computed({
+      get() {
+        return props.searchField || [];
+      },
+      set(v) {
+        emit("update:searchField", v);
+      }
+    });
+    return (_ctx, _cache) => {
+      const _component_a_select = resolveComponent("a-select");
+      return openBlock(), createElementBlock("div", _hoisted_1$2, [
+        createVNode(FormItem, {
+          inline: false,
+          label: _ctx.$t("sys.pageDesigner.quickSearchFields")
+        }, {
+          default: withCtx(() => [
+            createVNode(_component_a_select, {
+              value: value.value,
+              "onUpdate:value": _cache[0] || (_cache[0] = ($event) => value.value = $event),
+              allowClear: "",
+              mode: "multiple",
+              maxTagCount: 5,
+              maxTagTextLength: 6,
+              fieldNames: { label: "name", value: "key" },
+              optionFilterProp: "name",
+              options: fieldOptions.value,
+              size: "small",
+              disabled: __props.disabled,
+              placeholder: _ctx.$t("sys.inputText")
+            }, null, 8, ["value", "options", "disabled", "placeholder"])
+          ]),
+          _: 1
+        }, 8, ["label"])
+      ]);
+    };
+  }
+});
+const _hoisted_1$1 = { class: "px-16px py-16px" };
+const _hoisted_2 = { class: "px24px mt20px" };
+const _hoisted_3 = { class: "text-[#8B8B8B]" };
+const _hoisted_4 = { class: "atuofill-field-icon" };
+const _hoisted_5 = { class: "form-table-label" };
+const _hoisted_6 = ["onClick"];
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "autofill-rules-modal",
+  props: {
+    fieldMeta: {},
+    rules: {}
+  },
+  emits: ["ok", "register"],
+  setup(__props, { emit: __emit }) {
+    const $t2 = window.$t;
+    const { modelMetaMap, subTableFieldModel, getFieldMeta } = useModelFields();
+    const props = __props;
+    const {
+      refModelKey,
+      model: modelKey,
+      fieldType,
+      field: currentFieldKey
+    } = toRefs(props.fieldMeta);
+    const isSubTableTrigger = computed(
+      () => !!(props.fieldMeta.subFieldKey || props.fieldMeta.subModelKey)
+    );
+    const refFieldName = computed(() => {
+      return getFieldMeta(props.fieldMeta).name;
+    });
+    const autofillForm = ref();
+    const formState = reactive({
+      rules: [
+        {
+          fromField: void 0,
+          toField: void 0
+        }
+      ]
+    });
+    const bindFiledList = ref([]);
+    const allFieldInFormWithout = ref([]);
+    const formModelName = ref("");
+    ref($t2("sys.pageDesigner.addRule"));
+    const excludeFieldType = [
+      FIELD_TYPE.IMAGE,
+      FIELD_TYPE.ATTACHMENT,
+      FIELD_TYPE.SERIAL,
+      FIELD_TYPE.MASTERSLAVE,
+      FIELD_TYPE.ENUM,
+      FIELD_TYPE.ENUM_MULTI,
+      FIELD_TYPE.REF,
+      FIELD_TYPE.REF_MULTI,
+      FIELD_TYPE.RDO_REF,
+      FIELD_TYPE.EXPRESSION,
+      FIELD_TYPE.EXPRESSION_CONDITION,
+      FIELD_TYPE.AGG,
+      FIELD_TYPE.ESOP,
+      FIELD_TYPE.TRANSACTION,
+      FIELD_TYPE.LABEL_TEMPLATE,
+      FIELD_TYPE.LABEL_TEMPLATE_REF,
+      FIELD_TYPE.DOCUMENT_TEMPLATE,
+      FIELD_TYPE.SERIALRULE,
+      FIELD_TYPE.PRINTER,
+      FIELD_TYPE.MESSAGE_TMPL,
+      FIELD_TYPE.RANGE_USER,
+      FIELD_TYPE.SIGNATURE,
+      FIELD_TYPE.ONLINE_FORM_TEMPLATE,
+      FIELD_TYPE.E_DHR_TEMPLATE,
+      FIELD_TYPE.DATA_TABLE_FORMULA,
+      FIELD_TYPE.READONLYCMP,
+      FIELD_TYPE.BOOLEAN
+    ];
+    onMounted(async () => {
+      const modelDetail = await api.apaas.modelMeta.getDetail({
+        modelKey: modelKey.value
+      });
+      allFieldInFormWithout.value = modelDetail?.fieldMetaList?.filter((d) => d.createType !== "SYSTEM") || [];
+      formModelName.value = modelDetail?.name || "";
+      props.rules && onDataReceive({ rules: props.rules });
+    });
+    const fromFieldTreeData = computed(() => {
+      const children = bindFiledList.value.filter((f) => f.key !== "id_").map((f) => ({
+        ...f,
+        value: f.key,
+        label: f.name,
+        type: f.type
+      }));
+      return [
+        {
+          value: "id_",
+          label: refFieldName.value,
+          type: fieldType.value,
+          selectable: true,
+          children
+        }
+      ];
+    });
+    const currentModelName = computed(() => {
+      return modelMetaMap.value[modelKey.value]?.meta?.name || formModelName.value || "";
+    });
+    const filterCompatibleFields = (fromField, fieldList) => {
+      if (!fromField) return [];
+      if (fromField === "id_") {
+        const sourceType = fieldType.value;
+        const fieldConfig2 = transformMappingField4Auto(sourceType) ?? transformMappingField4Auto(FIELD_TYPE.REF);
+        let list2 = fieldList.filter((v) => fieldConfig2?.filterArr?.includes(v.type));
+        if (fieldConfig2?.equal !== void 0 && fieldConfig2?.equal) {
+          list2 = list2.filter((i) => i.bindInfo === refModelKey.value);
+        }
+        return list2;
+      }
+      const record = bindFiledList.value.find((i) => i.key === fromField);
+      if (record?.modelKey === "em_product" && record?.key === "uom_id_") {
+        return fieldList.filter(
+          (e) => [FIELD_TYPE.TEXT, FIELD_TYPE.LONG_TEXT, FIELD_TYPE.REF].includes(e.type)
+        );
+      }
+      const fieldConfig = transformMappingField4Auto(record?.type);
+      let list = fieldList.filter((v) => fieldConfig?.filterArr?.includes(v.type));
+      if (fieldConfig?.equal !== void 0 && fieldConfig?.equal) {
+        list = list.filter((i) => i.bindInfo === record?.bindInfo);
+      }
+      if ([FIELD_TYPE.TEXT, FIELD_TYPE.LONG_TEXT].includes(record?.type)) {
+        list = list.filter((i) => !["ref_model_key_", "ref_field_key_"].includes(i.key));
+      }
+      return list;
+    };
+    const buildSubTableFieldValue = (fromSubTableField, fieldKey) => {
+      return `${fromSubTableField}::${fieldKey}`;
+    };
+    const parseSubTableFieldValue = (value) => {
+      const [fromSubTableField, fieldKey] = value.split("::");
+      return { fromSubTableField, fieldKey };
+    };
+    const stripSubTableRuleFields = (rules) => {
+      if (!isSubTableTrigger.value) return rules;
+      return rules.map(({ fromSubTableField: _omit, ...rest }) => rest);
+    };
+    const selrender = (item) => {
+      return () => h("span", { class: "atuofill-field-icon" }, [
+        h("i", { class: ["iconfont", FieldIconMap[item.type] || "text"] }),
+        item.name
+      ]);
+    };
+    const filterOption = (input, option) => {
+      return option.name?.includes(input?.trim());
+    };
+    const getTargetFieldOptions = (fromField) => {
+      if (!fromField) return [];
+      let fields = filterCompatibleFields(fromField, allFieldInFormWithout.value);
+      if (fromField === "id_" && currentFieldKey.value) {
+        fields = fields.filter((f) => f.key !== currentFieldKey.value);
+      }
+      return fields.map((f) => ({
+        ...f,
+        value: f.key,
+        label: selrender(f)
+      }));
+    };
+    const getTargetFieldValue = (element) => {
+      if (!element.toField) return void 0;
+      if (element.fromSubTableField) {
+        return buildSubTableFieldValue(element.fromSubTableField, element.toField);
+      }
+      return element.toField;
+    };
+    const getTargetFieldTreeData = (fromField) => {
+      if (!fromField) return [];
+      let mainFields = filterCompatibleFields(fromField, allFieldInFormWithout.value);
+      if (fromField === "id_" && currentFieldKey.value) {
+        mainFields = mainFields.filter((f) => f.key !== currentFieldKey.value);
+      }
+      const treeData = [];
+      if (mainFields.length) {
+        treeData.push({
+          value: `__main__${modelKey.value}`,
+          label: currentModelName.value,
+          selectable: false,
+          children: mainFields.map((f) => ({
+            ...f,
+            value: f.key,
+            label: f.name,
+            type: f.type
+          }))
+        });
+      }
+      subTableFieldModel.value.forEach(({ field, model }) => {
+        if (model.subModelType === SubTableType.STOCKTAKE || model.subModelType === SubTableType.ALLOCATE) {
+          return;
+        }
+        const subModelFields = modelMetaMap.value[field.bindInfo]?.fields?.filter((d) => d.createType !== "SYSTEM") || [];
+        const compatibleFields = filterCompatibleFields(fromField, subModelFields);
+        if (!compatibleFields.length) return;
+        treeData.push({
+          value: `__sub__${field.key}`,
+          label: `${model.name}（${getSubTableTypeLabel(model.subModelType)}）`,
+          selectable: false,
+          children: compatibleFields.map((f) => ({
+            ...f,
+            value: buildSubTableFieldValue(field.key, f.key),
+            label: f.name,
+            type: f.type,
+            fromSubTableField: field.key
+          }))
+        });
+      });
+      return treeData;
+    };
+    const getSubTableTypeLabel = (subModelType) => {
+      const subTypeMap = {
+        INSPECTION: "CHECK",
+        MATERIAL_CONSUME: "MATERIAL_CONSUMPTION",
+        PRODUCTION_CONTAINER_LIST_4_STERILIZATION: "STERILIZE_BATCH"
+      };
+      const subTableType = subTypeMap[subModelType || ""] || subModelType || "DEFAULT";
+      return $t2(`sys.onlineForm.subTableType.${subTableType}`);
+    };
+    const onDataReceive = async ({ rules }) => {
+      formState.rules = stripSubTableRuleFields(cloneDeep(rules));
+      if (formState.rules?.length == 0) {
+        formState.rules.push({
+          fromField: void 0,
+          toField: void 0
+        });
+      }
+      const res = await api.apaas.modelMeta.getDetail({
+        modelKey: refModelKey.value
+      });
+      bindFiledList.value = res?.fieldMetaList?.filter((d) => d.createType !== "SYSTEM")?.filter(
+        (i) => i.modelKey === "em_product" && i.key === "uom_id_" || !excludeFieldType.includes(i.type)
+      ) || [];
+    };
+    const removeRule = (index) => {
+      formState.rules.splice(index, 1);
+    };
+    const addRule = () => {
+      formState.rules.push({
+        fromField: void 0,
+        toField: void 0
+      });
+    };
+    useModal(async () => {
+      if (formState.rules.length > 1 || formState.rules[0].fromField || formState.rules[0].toField) {
+        await autofillForm.value.validate();
+        return {
+          ok: true,
+          data: stripSubTableRuleFields(formState.rules)
+        };
+      }
+    });
+    const handleFromChange = (element) => {
+      element.toField = null;
+      element.toFieldType = void 0;
+      element.fromSubTableField = void 0;
+    };
+    const handleFlatTargetChange = (val, element) => {
+      if (!val) {
+        element.toField = void 0;
+        element.toFieldType = void 0;
+        element.fromSubTableField = void 0;
+        return;
+      }
+      const record = allFieldInFormWithout.value.find((f) => f.key === val);
+      element.toField = val;
+      element.toFieldType = record?.type;
+      element.fromSubTableField = void 0;
+    };
+    const handleTargetChange = (val, extra, element) => {
+      if (!val) {
+        element.toField = void 0;
+        element.toFieldType = void 0;
+        element.fromSubTableField = void 0;
+        return;
+      }
+      if (String(val).includes("::")) {
+        const { fromSubTableField, fieldKey } = parseSubTableFieldValue(String(val));
+        const node2 = extra?.triggerNode?.props || extra?.triggerNode;
+        const nodeProps2 = node2?.dataRef || node2;
+        element.toField = fieldKey;
+        element.fromSubTableField = fromSubTableField;
+        element.toFieldType = nodeProps2?.type;
+        return;
+      }
+      const node = extra?.triggerNode?.props || extra?.triggerNode;
+      const nodeProps = node?.dataRef || node;
+      element.toField = val;
+      element.fromSubTableField = void 0;
+      element.toFieldType = nodeProps?.type;
+    };
+    return (_ctx, _cache) => {
+      const _component_a_button = resolveComponent("a-button");
+      const _component_a_col = resolveComponent("a-col");
+      const _component_a_row = resolveComponent("a-row");
+      const _component_a_tree_select = resolveComponent("a-tree-select");
+      const _component_a_form_item = resolveComponent("a-form-item");
+      const _component_a_select = resolveComponent("a-select");
+      const _component_a_form = resolveComponent("a-form");
+      return openBlock(), createElementBlock("div", _hoisted_1$1, [
+        createVNode(_component_a_button, {
+          type: "link",
+          onClick: addRule,
+          class: "mv10px pl24px mt4px"
+        }, {
+          default: withCtx(() => [
+            _cache[0] || (_cache[0] = createElementVNode("i", {
+              class: "iconfont icon-chuangjian mr8px",
+              style: { "vertical-align": "-1px" }
+            }, null, -1)),
+            createTextVNode(" " + toDisplayString(unref($t2)("sys.pageDesigner.fillRules")), 1)
+          ]),
+          _: 1
+        }),
+        createElementVNode("div", _hoisted_2, [
+          createVNode(_component_a_row, {
+            gutter: 4,
+            style: { "margin-bottom": "4px", "padding": "0 10px" },
+            class: "text-[#1A1D23]"
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_a_col, { span: 9 }, {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(unref($t2)("sys.pageDesigner.valueSource")), 1)
+                ]),
+                _: 1
+              }),
+              createVNode(_component_a_col, { span: 4 }),
+              createVNode(_component_a_col, { span: 11 }, {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(unref($t2)("sys.pageDesigner.targetField")) + " ", 1),
+                  createElementVNode("span", _hoisted_3, " （ " + toDisplayString(unref($t2)("sys.pageDesigner.onlineFormFieldInForm")) + "） ", 1)
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }),
+          createVNode(_component_a_form, {
+            ref_key: "autofillForm",
+            ref: autofillForm,
+            model: formState,
+            "wrapper-col": { span: 24 },
+            autocomplete: "off",
+            "hide-required-mark": "",
+            colon: false
+          }, {
+            default: withCtx(() => [
+              createVNode(unref(draggable), {
+                list: formState.rules,
+                handle: ".cursor-move",
+                "drag-class": "drawing-drag",
+                "item-key": "id"
+              }, {
+                item: withCtx(({ element, index }) => [
+                  (openBlock(), createBlock(_component_a_row, {
+                    gutter: 4,
+                    key: index,
+                    class: "rule-item"
+                  }, {
+                    default: withCtx(() => [
+                      createVNode(_component_a_col, { span: 9 }, {
+                        default: withCtx(() => [
+                          createVNode(_component_a_form_item, {
+                            label: "",
+                            name: ["rules", index, "fromField"],
+                            rules: [
+                              {
+                                required: true,
+                                message: unref($t2)("sys.chooseTextTip", {
+                                  name: unref($t2)("sys.field")
+                                })
+                              }
+                            ]
+                          }, {
+                            default: withCtx(() => [
+                              createVNode(_component_a_tree_select, {
+                                value: element.fromField,
+                                "onUpdate:value": ($event) => element.fromField = $event,
+                                placeholder: unref($t2)("sys.chooseText") + unref($t2)("sys.field"),
+                                "show-search": "",
+                                "tree-default-expand-all": "",
+                                "allow-clear": "",
+                                "tree-node-filter-prop": "label",
+                                "dropdown-class-name": "gct-custom-select-dropdown autofill-from-field-tree",
+                                "tree-data": fromFieldTreeData.value,
+                                onChange: ($event) => handleFromChange(element)
+                              }, {
+                                title: withCtx((data) => [
+                                  createElementVNode("span", _hoisted_4, [
+                                    data.type ? (openBlock(), createElementBlock("i", {
+                                      key: 0,
+                                      class: normalizeClass(["iconfont", unref(FieldIconMap)[data.type] || "text"])
+                                    }, null, 2)) : createCommentVNode("", true),
+                                    createTextVNode(" " + toDisplayString(data.label), 1)
+                                  ])
+                                ]),
+                                _: 1
+                              }, 8, ["value", "onUpdate:value", "placeholder", "tree-data", "onChange"])
+                            ]),
+                            _: 2
+                          }, 1032, ["name", "rules"])
+                        ]),
+                        _: 2
+                      }, 1024),
+                      createVNode(_component_a_col, { span: 4 }, {
+                        default: withCtx(() => [
+                          createElementVNode("span", _hoisted_5, toDisplayString(unref($t2)("sys.pageDesigner.valueFillTip")), 1)
+                        ]),
+                        _: 1
+                      }),
+                      createVNode(_component_a_col, { span: 10 }, {
+                        default: withCtx(() => [
+                          createVNode(_component_a_form_item, {
+                            label: "",
+                            name: ["rules", index, "toField"],
+                            rules: [
+                              {
+                                required: true,
+                                message: unref($t2)("sys.chooseTextTip", {
+                                  name: unref($t2)("sys.field")
+                                })
+                              }
+                            ]
+                          }, {
+                            default: withCtx(() => [
+                              isSubTableTrigger.value ? (openBlock(), createBlock(_component_a_select, {
+                                key: 0,
+                                value: element.toField,
+                                "onUpdate:value": ($event) => element.toField = $event,
+                                placeholder: unref($t2)("sys.chooseText") + unref($t2)("sys.field"),
+                                "show-search": "",
+                                "allow-clear": "",
+                                "filter-option": filterOption,
+                                "option-label-prop": "label",
+                                "dropdown-class-name": "gct-custom-select-dropdown",
+                                options: getTargetFieldOptions(element.fromField),
+                                onChange: (val) => handleFlatTargetChange(val, element)
+                              }, null, 8, ["value", "onUpdate:value", "placeholder", "options", "onChange"])) : (openBlock(), createBlock(_component_a_tree_select, {
+                                key: 1,
+                                value: getTargetFieldValue(element),
+                                placeholder: unref($t2)("sys.chooseText") + unref($t2)("sys.field"),
+                                "show-search": "",
+                                "tree-default-expand-all": "",
+                                "allow-clear": "",
+                                "tree-node-filter-prop": "label",
+                                "dropdown-class-name": "gct-custom-select-dropdown autofill-to-field-tree",
+                                "tree-data": getTargetFieldTreeData(element.fromField),
+                                onChange: (val, _label, extra) => handleTargetChange(val, extra, element)
+                              }, {
+                                title: withCtx((data) => [
+                                  createElementVNode("span", {
+                                    class: normalizeClass([
+                                      "atuofill-field-icon",
+                                      { "text-[#8B8B8B]": data.selectable === false }
+                                    ])
+                                  }, [
+                                    data.type ? (openBlock(), createElementBlock("i", {
+                                      key: 0,
+                                      class: normalizeClass(["iconfont", unref(FieldIconMap)[data.type] || "text"])
+                                    }, null, 2)) : createCommentVNode("", true),
+                                    createTextVNode(" " + toDisplayString(data.label), 1)
+                                  ], 2)
+                                ]),
+                                _: 1
+                              }, 8, ["value", "placeholder", "tree-data", "onChange"]))
+                            ]),
+                            _: 2
+                          }, 1032, ["name", "rules"])
+                        ]),
+                        _: 2
+                      }, 1024),
+                      createVNode(_component_a_col, {
+                        span: 1,
+                        class: "rule-flex-col"
+                      }, {
+                        default: withCtx(() => [
+                          withDirectives(createElementVNode("i", {
+                            class: "iconfont icon-shanchu2 text-[#797A7D] error-gct-hover cursor-pointer",
+                            onClick: ($event) => removeRule(index)
+                          }, null, 8, _hoisted_6), [
+                            [vShow, formState.rules.length > 1]
+                          ])
+                        ]),
+                        _: 2
+                      }, 1024)
+                    ]),
+                    _: 2
+                  }, 1024))
+                ]),
+                _: 1
+              }, 8, ["list"])
+            ]),
+            _: 1
+          }, 8, ["model"])
+        ])
+      ]);
+    };
+  }
+});
+const AutofillRulesModal = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-7b7a8bd0"]]);
+const _hoisted_1 = { class: "inpt-box" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ref-autofill-editor",
+  props: {
+    fieldMeta: {},
+    autofillRules: {},
+    enableAutofill: { type: Boolean },
+    disabled: { type: Boolean }
+  },
+  emits: ["update:autofillRules", "update:enableAutofill"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const detail = computed({
+      get() {
+        return props.autofillRules;
+      },
+      set(v) {
+        emit("update:autofillRules", v);
+      }
+    });
+    const enabled = computed({
+      get() {
+        return props.enableAutofill ?? !!props.autofillRules?.length;
+      },
+      set(v) {
+        emit("update:enableAutofill", v);
+      }
+    });
+    const btnAttrs = computed(() => {
+      return detail.value?.length ? { type: "primary", block: true } : { type: "primary", ghost: true, block: true };
+    });
+    const handleFilterClick = async () => {
+      const result = await window.NocodeAdapter.utils.overlay.modal(
+        AutofillRulesModal,
+        {
+          fieldMeta: props.fieldMeta,
+          rules: detail.value
+        },
+        {
+          title: !detail.value?.length ? $t("sys.pageDesigner.addRule") : $t("sys.pageDesigner.editRule"),
+          centered: true,
+          width: 640
+        }
+      );
+      if (result.ok && result.data) {
+        emit("update:autofillRules", cloneDeep(result.data));
+      }
+    };
+    return (_ctx, _cache) => {
+      const _component_a_switch = resolveComponent("a-switch");
+      const _component_a_button = resolveComponent("a-button");
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["ref-autofill-editor", { "is-off": !enabled.value }])
+      }, [
+        createVNode(FormItem, {
+          inline: false,
+          label: _ctx.$t("sys.pageDesigner.dataFill")
+        }, {
+          extra: withCtx(() => [
+            createVNode(_component_a_switch, {
+              size: "small",
+              checked: enabled.value,
+              "onUpdate:checked": _cache[0] || (_cache[0] = ($event) => enabled.value = $event),
+              disabled: __props.disabled
+            }, null, 8, ["checked", "disabled"])
+          ]),
+          default: withCtx(() => [
+            enabled.value ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "data-filter-box",
+              onClick: handleFilterClick
+            }, [
+              createElementVNode("div", _hoisted_1, [
+                createVNode(_component_a_button, mergeProps(btnAttrs.value, { disabled: __props.disabled }), {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(detail.value?.length ? _ctx.$t("sys.pageDesigner.editRule") : _ctx.$t("sys.pageDesigner.addRule")), 1)
+                  ]),
+                  _: 1
+                }, 16, ["disabled"])
+              ])
+            ])) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 8, ["label"])
+      ], 2);
+    };
+  }
+});
+const RefAutofillEditor = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-57b22ed1"]]);
+export {
+  RefAutofillEditor as R,
+  _sfc_main$2 as _
+};