bm-admin-ui 1.0.21-alpha → 1.0.22-alpha

package/lib/components/form-create/index.js

@@ -0,0 +1,2781 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var withInstall = require('bm-admin-ui/lib/utils/with-install');
+var vue = require('vue');
+var antDesignVue = require('ant-design-vue');
+var dayjs = require('dayjs');
+var Picture = require('bm-admin-ui/lib/components/upload');
+var BmStaffsSelector = require('bm-admin-ui/lib/components/staffs-selector');
+var components = require('bm-admin-ui/lib/components');
+var iconsVue = require('@ant-design/icons-vue');
+var lodashEs = require('lodash-es');
+var FC = require('@form-create/ant-design-vue');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+var Picture__default = /*#__PURE__*/_interopDefaultLegacy(Picture);
+var BmStaffsSelector__default = /*#__PURE__*/_interopDefaultLegacy(BmStaffsSelector);
+var FC__default = /*#__PURE__*/_interopDefaultLegacy(FC);
+
+const fieldRatioMap = {
+    '25%': 6,
+    '50%': 12,
+    '75%': 18,
+    '100': 24,
+    6: 6,
+    12: 12,
+    18: 18,
+    24: 24,
+};
+
+var input = {
+    name: 'input',
+    rule(data) {
+        return {
+            type: 'input',
+            field: data.field,
+            title: data.title.title,
+            props: {
+                maxlength: 200,
+                placeholder: data.props.placeholder,
+            },
+            value: data.value,
+            effect: {
+                required: data.effect.required && '请输入',
+            },
+            wrap: {
+                wrapperCol: {
+                    span: fieldRatioMap[data.config.fieldRatio],
+                },
+            },
+        };
+    },
+    rowRule(data) {
+        return {
+            type: 'input',
+            field: data.field,
+            title: data.title.title,
+            props: {
+                maxlength: 200,
+                placeholder: data.props.placeholder,
+            },
+            value: data.value,
+            effect: {
+                required: data.effect.required && '请输入',
+            },
+            col: {
+                span: fieldRatioMap[data.config.fieldRatio],
+            },
+        };
+    },
+    tableRule(data) {
+        const field = data.field;
+        return {
+            field,
+            title: data.title.title,
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: data.config.fieldRatio,
+            slots: {
+                default({ row }) {
+                    return vue.h(antDesignVue.Input, {
+                        value: row[field],
+                        placeholder: data.props.placeholder,
+                        maxlength: 200,
+                        'onUpdate:value': (value) => {
+                            row[field] = value;
+                        },
+                    });
+                },
+            },
+        };
+    },
+};
+
+var textarea = {
+    name: 'textarea',
+    rule(data) {
+        return {
+            type: 'input',
+            field: data.field,
+            title: data.title.title,
+            props: {
+                type: 'textarea',
+                maxlength: 5000,
+                placeholder: data.props.placeholder,
+            },
+            value: data.value,
+            effect: {
+                required: data.effect.required && '请输入',
+            },
+            wrap: {
+                wrapperCol: {
+                    span: fieldRatioMap[data.config.fieldRatio],
+                },
+            },
+        };
+    },
+    rowRule(data) {
+        return {
+            type: 'input',
+            field: data.field,
+            title: data.title.title,
+            props: {
+                type: 'textarea',
+                maxlength: 5000,
+                placeholder: data.props.placeholder,
+            },
+            value: data.value,
+            effect: {
+                required: data.effect.required && '请输入',
+            },
+            col: {
+                span: fieldRatioMap[data.config.fieldRatio],
+            },
+        };
+    },
+    tableRule(data) {
+        const field = data.field;
+        return {
+            field,
+            title: data.title.title,
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: data.config.fieldRatio,
+            slots: {
+                default({ row }) {
+                    return vue.h(antDesignVue.Input, {
+                        type: 'textarea',
+                        value: row[field],
+                        maxlength: 5000,
+                        placeholder: data.props.placeholder,
+                        'onUpdate:value': (value) => {
+                            row[field] = value;
+                        },
+                    });
+                },
+            },
+        };
+    },
+};
+
+var numInput = {
+    name: 'numInput',
+    rule(data) {
+        return {
+            type: 'inputNumber',
+            field: data.field,
+            title: data.title.title,
+            props: {
+                placeholder: data.props.placeholder,
+            },
+            value: data.value,
+            effect: {
+                required: data.effect.required && '请输入',
+            },
+            wrap: {
+                wrapperCol: {
+                    span: fieldRatioMap[data.config.fieldRatio],
+                },
+            },
+            style: {
+                width: '100%',
+            },
+        };
+    },
+    rowRule(data) {
+        return {
+            type: 'inputNumber',
+            field: data.field,
+            title: data.title.title,
+            props: {
+                placeholder: data.props.placeholder,
+            },
+            value: data.value,
+            effect: {
+                required: data.effect.required && '请输入',
+            },
+            col: {
+                span: fieldRatioMap[data.config.fieldRatio],
+            },
+            style: {
+                width: '100%',
+            },
+        };
+    },
+    tableRule(data) {
+        const field = data.field;
+        return {
+            field,
+            title: data.title.title,
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: data.config.fieldRatio,
+            slots: {
+                default({ row }) {
+                    return vue.h(antDesignVue.InputNumber, {
+                        value: row[field],
+                        placeholder: data.props.placeholder,
+                        'onUpdate:value': (value) => {
+                            row[field] = value;
+                        },
+                        style: {
+                            width: '100%',
+                        },
+                    });
+                },
+            },
+        };
+    },
+};
+
+var radio = {
+    name: 'radio',
+    rule(data) {
+        return {
+            type: data.type,
+            field: data.field,
+            title: data.title.title,
+            props: {
+                placeholder: data.props.placeholder,
+            },
+            options: data.options,
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            wrap: {
+                wrapperCol: {
+                    span: fieldRatioMap[data.config.fieldRatio],
+                },
+            },
+            value: data.value,
+        };
+    },
+    rowRule(data) {
+        return {
+            type: data.type,
+            field: data.field,
+            title: data.title.title,
+            props: {
+                placeholder: data.props.placeholder,
+            },
+            options: data.options,
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            col: {
+                span: fieldRatioMap[data.config.fieldRatio],
+            },
+            value: data.value,
+        };
+    },
+    tableRule(data) {
+        const field = data.field;
+        return {
+            field,
+            title: data.title.title,
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: data.config.fieldRatio,
+            slots: {
+                default({ row }) {
+                    return vue.h(antDesignVue.Select, {
+                        value: row[field],
+                        placeholder: data.props.placeholder,
+                        options: data.options,
+                        'onUpdate:value': (value) => {
+                            row[field] = value;
+                        },
+                    });
+                },
+            },
+        };
+    },
+};
+
+var checkbox = {
+    name: 'checkbox',
+    rule(data) {
+        const extraProps = data.type === 'select' ? { mode: 'multiple' } : {};
+        return {
+            type: data.type,
+            field: data.field,
+            title: data.title.title,
+            props: Object.assign({ placeholder: data.props.placeholder }, extraProps),
+            options: data.options,
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            wrap: {
+                wrapperCol: {
+                    span: fieldRatioMap[data.config.fieldRatio],
+                },
+            },
+            value: data.value,
+        };
+    },
+    rowRule(data) {
+        const extraProps = data.type === 'select' ? { mode: 'multiple' } : {};
+        return {
+            type: data.type,
+            field: data.field,
+            title: data.title.title,
+            props: Object.assign({ placeholder: data.props.placeholder }, extraProps),
+            options: data.options,
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            col: {
+                span: fieldRatioMap[data.config.fieldRatio],
+            },
+            value: data.value,
+        };
+    },
+    tableRule(data) {
+        const field = data.field;
+        return {
+            field,
+            title: data.title.title,
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: data.config.fieldRatio,
+            slots: {
+                default({ row }) {
+                    return vue.h(antDesignVue.Select, {
+                        value: row[field],
+                        placeholder: data.props.placeholder,
+                        options: data.options,
+                        mode: 'multiple',
+                        'onUpdate:value': (value) => {
+                            row[field] = value;
+                        },
+                    });
+                },
+            },
+        };
+    },
+};
+
+var date = {
+    name: 'date',
+    rule(data) {
+        const format = data.props.format;
+        const value = data.config.defaultValue || data.value
+            ? data.value
+            : dayjs__default["default"]().format(format);
+        const extraProps = {
+            picker: format === 'YYYY-MM' ? 'month' : '',
+            showTime: format === 'YYYY-MM-DD HH:mm',
+        };
+        return {
+            type: 'datePicker',
+            field: data.field,
+            title: data.title.title,
+            props: Object.assign({ format, valueFormat: format, placeholder: data.props.placeholder }, extraProps),
+            value,
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            wrap: {
+                wrapperCol: {
+                    span: fieldRatioMap[data.config.fieldRatio],
+                },
+            },
+            style: {
+                width: '100%',
+            },
+        };
+    },
+    rowRule(data) {
+        const format = data.props.format;
+        const value = data.config.defaultValue || data.value
+            ? data.value
+            : dayjs__default["default"]().format(format);
+        const extraProps = {
+            picker: format === 'YYYY-MM' ? 'month' : '',
+            showTime: format === 'YYYY-MM-DD HH:mm',
+        };
+        return {
+            type: 'datePicker',
+            field: data.field,
+            title: data.title.title,
+            props: Object.assign({ format, valueFormat: format, placeholder: data.props.placeholder }, extraProps),
+            value,
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            col: {
+                span: fieldRatioMap[data.config.fieldRatio],
+            },
+            style: {
+                width: '100%',
+            },
+        };
+    },
+    tableRule(data) {
+        const field = data.field;
+        const format = data.props.format;
+        return {
+            field,
+            title: data.title.title,
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: data.config.fieldRatio,
+            slots: {
+                default({ row }) {
+                    return vue.h(antDesignVue.DatePicker, {
+                        value: row[field],
+                        placeholder: data.props.placeholder,
+                        format,
+                        valueFormat: format,
+                        picker: format === 'YYYY-MM' ? 'month' : 'date',
+                        showTime: format === 'YYYY-MM-DD HH:mm',
+                        'onUpdate:value': (value) => {
+                            row[field] = value;
+                        },
+                        style: {
+                            width: '100%',
+                        },
+                    });
+                },
+            },
+        };
+    },
+};
+
+var dateRange = {
+    name: 'dateRange',
+    rule(data) {
+        const format = data.props.format;
+        const extraProps = {
+            picker: format === 'YYYY-MM' ? 'month' : '',
+            showTime: format === 'YYYY-MM-DD HH:mm',
+        };
+        return {
+            type: 'datePicker',
+            field: data.field,
+            title: data.title.title,
+            props: Object.assign({ range: true, separator: '~', format, valueFormat: format, placeholder: data.props.placeholder }, extraProps),
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            wrap: {
+                wrapperCol: {
+                    span: fieldRatioMap[data.config.fieldRatio],
+                },
+            },
+            style: {
+                width: '100%',
+            },
+            value: data.value,
+        };
+    },
+    rowRule(data) {
+        const format = data.props.format;
+        const extraProps = {
+            picker: format === 'YYYY-MM' ? 'month' : '',
+            showTime: format === 'YYYY-MM-DD HH:mm',
+        };
+        return {
+            type: 'datePicker',
+            field: data.field,
+            title: data.title.title,
+            props: Object.assign({ range: true, separator: '~', format, valueFormat: format, placeholder: data.props.placeholder }, extraProps),
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            col: {
+                span: fieldRatioMap[data.config.fieldRatio],
+            },
+            style: {
+                width: '100%',
+            },
+            value: data.value,
+        };
+    },
+    tableRule(data) {
+        const field = data.field;
+        const format = data.props.format;
+        return {
+            field,
+            title: data.title.title,
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: data.config.fieldRatio,
+            slots: {
+                default({ row }) {
+                    return vue.h(antDesignVue.RangePicker, {
+                        value: row[field],
+                        placeholder: data.props.placeholder,
+                        format,
+                        valueFormat: format,
+                        picker: format === 'YYYY-MM' ? 'month' : 'date',
+                        showTime: format === 'YYYY-MM-DD HH:mm',
+                        'onUpdate:value': (value) => {
+                            row[field] = value;
+                        },
+                        style: {
+                            width: '100%',
+                        },
+                    });
+                },
+            },
+        };
+    },
+};
+
+var instruction = {
+    name: 'instruction',
+    rule(data) {
+        return {
+            type: 'div',
+            field: data.field,
+            children: [data.value],
+            style: {
+                padding: '16px 12px',
+                color: data.style.color,
+                fontSize: '14px',
+                lineHeight: '22px',
+                borderRadius: '4px',
+                backgroundColor: '#EAF2FF',
+            },
+        };
+    },
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+var picture = {
+    name: 'picture',
+    rule(data, extraConfig) {
+        const maxCount = data.props.extraProps.maxCount;
+        return {
+            type: 'Picture',
+            component: Picture__default["default"],
+            field: data.field,
+            title: data.title.title,
+            props: {
+                uploadProps: {
+                    listType: 'picture-card',
+                    text: '请选择',
+                    multiple: maxCount > 1,
+                },
+                extraProps: {
+                    maxSize: 10,
+                    maxCount,
+                },
+                defaultList: data.value,
+                uploadRequest(inject, file) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        return yield extraConfig.picture.fetch(file);
+                    });
+                },
+            },
+            validate: [
+                {
+                    required: data.effect.required,
+                    type: 'array',
+                    min: 1,
+                    message: '请上传图片',
+                },
+            ],
+            inject: true,
+            on: {
+                update(inject, list) {
+                    const rule = inject.self;
+                    rule.value = list;
+                    vue.nextTick(() => {
+                        inject.api.validateField(rule.field);
+                    });
+                },
+                error(inject, error) {
+                    antDesignVue.message.error(error.message);
+                },
+            },
+        };
+    },
+    rowRule(data, extraConfig) {
+        const maxCount = data.props.extraProps.maxCount;
+        return {
+            type: 'Picture',
+            component: Picture__default["default"],
+            field: data.field,
+            title: data.title.title,
+            props: {
+                uploadProps: {
+                    listType: 'picture-card',
+                    text: '请选择',
+                    multiple: maxCount > 1,
+                },
+                extraProps: {
+                    maxSize: 10,
+                    maxCount,
+                },
+                defaultList: data.value,
+                uploadRequest(inject, file) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        return yield extraConfig.picture.fetch(file);
+                    });
+                },
+            },
+            validate: [
+                {
+                    required: data.effect.required,
+                    type: 'array',
+                    min: 1,
+                    message: '请上传图片',
+                },
+            ],
+            inject: true,
+            on: {
+                update(inject, list) {
+                    const rule = inject.self;
+                    rule.value = list;
+                    vue.nextTick(() => {
+                        inject.api.validateField(rule.field);
+                    });
+                },
+                error(inject, error) {
+                    antDesignVue.message.error(error.message);
+                },
+            },
+            col: {
+                span: 12,
+            },
+        };
+    },
+};
+
+var file = {
+    name: 'file',
+    rule(data, extraConfig) {
+        return {
+            type: 'Picture',
+            component: Picture__default["default"],
+            field: data.field,
+            title: data.title.title,
+            props: {
+                extraProps: {
+                    maxSize: 20,
+                    tips: '单个附件大小需≤20M',
+                },
+                defaultList: data.value,
+                uploadRequest(inject, file) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        return yield extraConfig.picture.fetch(file);
+                    });
+                },
+            },
+            validate: [
+                {
+                    required: data.effect.required,
+                    type: 'array',
+                    len: 1,
+                    message: '请上传附件',
+                },
+            ],
+            inject: true,
+            on: {
+                update(inject, list) {
+                    const rule = inject.self;
+                    rule.value = list;
+                    vue.nextTick(() => {
+                        inject.api.validateField(rule.field);
+                    });
+                },
+                error(inject, error) {
+                    antDesignVue.message.error(error.message);
+                },
+            },
+        };
+    },
+    rowRule(data, extraConfig) {
+        return {
+            type: 'Picture',
+            component: Picture__default["default"],
+            field: data.field,
+            title: data.title.title,
+            props: {
+                extraProps: {
+                    maxSize: 20,
+                    tips: '单个附件大小需≤20M',
+                },
+                defaultList: data.value,
+                uploadRequest(inject, file) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        return yield extraConfig.picture.fetch(file);
+                    });
+                },
+            },
+            validate: [
+                {
+                    required: data.effect.required,
+                    type: 'array',
+                    len: 1,
+                    message: '请上传附件',
+                },
+            ],
+            inject: true,
+            on: {
+                update(inject, list) {
+                    const rule = inject.self;
+                    rule.value = list;
+                    vue.nextTick(() => {
+                        inject.api.validateField(rule.field);
+                    });
+                },
+                error(inject, error) {
+                    antDesignVue.message.error(error.message);
+                },
+            },
+            col: {
+                span: 12,
+            },
+        };
+    },
+};
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _sfc_main$8 = /* @__PURE__ */ vue.defineComponent({
+  __name: "staff-selector",
+  props: ["placeholder", "defaultSelected"],
+  emits: ["change"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const selected = vue.ref([]);
+    const visible = vue.ref(false);
+    function selectedChange(val) {
+      emits("change", val);
+    }
+    function handleAdd() {
+      visible.value = true;
+    }
+    vue.watch(
+      () => props.defaultSelected,
+      (val) => {
+        selected.value = val;
+      },
+      {
+        immediate: true
+      }
+    );
+    vue.watch(selected, (val) => {
+      selectedChange(val);
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", null, [
+        vue.createVNode(vue.unref(components.BmTagsDisplay), {
+          list: selected.value,
+          "onUpdate:list": _cache[0] || (_cache[0] = ($event) => selected.value = $event),
+          "show-empty-btn": false,
+          "show-empty": "",
+          onAddClick: handleAdd
+        }, null, 8, ["list"]),
+        vue.createVNode(vue.unref(BmStaffsSelector__default["default"]), vue.mergeProps({
+          select: selected.value,
+          "onUpdate:select": _cache[1] || (_cache[1] = ($event) => selected.value = $event),
+          visible: visible.value,
+          "onUpdate:visible": _cache[2] || (_cache[2] = ($event) => visible.value = $event)
+        }, _ctx.$attrs), null, 16, ["select", "visible"])
+      ]);
+    };
+  }
+});
+var StaffSelector = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["__file", "staff-selector.vue"]]);
+
+var people = {
+    name: 'people',
+    rule(data, extraConfig) {
+        return {
+            type: 'StaffSelector',
+            component: StaffSelector,
+            field: data.field,
+            title: data.title.title,
+            props: {
+                title: '添加员工',
+                mode: data.props.limit ? 'radio' : 'multiple',
+                placeholder: data.props.placeholder,
+                defaultSelected: data.value,
+                load(inject, params) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        return yield extraConfig.people.fetch(params);
+                    });
+                },
+            },
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            wrap: {
+                wrapperCol: {
+                    span: fieldRatioMap[data.config.fieldRatio],
+                },
+            },
+            inject: true,
+            on: {
+                change(inject, list) {
+                    const rule = inject.self;
+                    rule.value = list;
+                    inject.api.validateField(rule.field, () => {
+                        if (list.length) {
+                            inject.api.clearValidateState(rule.field);
+                        }
+                    });
+                },
+            },
+        };
+    },
+    rowRule(data, extraConfig) {
+        return {
+            type: 'StaffSelector',
+            component: StaffSelector,
+            field: data.field,
+            title: data.title.title,
+            props: {
+                title: '添加员工',
+                mode: data.props.limit ? 'radio' : 'multiple',
+                placeholder: data.props.placeholder,
+                defaultSelected: data.value,
+                load(inject, params) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        return yield extraConfig.people.fetch(params);
+                    });
+                },
+            },
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            col: {
+                span: fieldRatioMap[data.config.fieldRatio],
+            },
+            inject: true,
+            on: {
+                change(inject, list) {
+                    const rule = inject.self;
+                    rule.value = list;
+                    inject.api.validateField(rule.field, () => {
+                        if (list.length) {
+                            inject.api.clearValidateState(rule.field);
+                        }
+                    });
+                },
+            },
+        };
+    },
+    tableRule(data, extraConfig) {
+        const field = data.field;
+        return {
+            field,
+            title: data.title.title,
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: data.config.fieldRatio,
+            slots: {
+                default({ row }) {
+                    return vue.h(StaffSelector, Object.assign({ title: '添加员工', mode: data.props.limit ? 'radio' : 'multiple', placeholder: data.props.placeholder, onChange: (value) => {
+                            row[field] = value;
+                        }, defaultSelected: row[field] }, extraConfig.people));
+                },
+            },
+        };
+    },
+};
+
+const _sfc_main$7 = /* @__PURE__ */ vue.defineComponent({
+  __name: "temp-content",
+  props: ["content"],
+  setup(__props) {
+    const props = __props;
+    const layers = vue.computed(() => {
+      if (props.content) {
+        try {
+          return JSON.parse(props.content).filter((layer) => !layer.src);
+        } catch {
+          return [];
+        }
+      }
+      return [];
+    });
+    const layerBackGround = vue.computed(() => {
+      if (!props.content) {
+        try {
+          return JSON.parse(props.content).find((layer) => layer.src).src;
+        } catch {
+          return "";
+        }
+      }
+      return "";
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: "bm-fc-rect-outer",
+        style: vue.normalizeStyle(
+          vue.unref(layerBackGround) ? { backgroundImage: `url('${vue.unref(layerBackGround)}')` } : {}
+        )
+      }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(layers), (layer) => {
+          return vue.openBlock(), vue.createElementBlock("div", {
+            key: layer.uuid,
+            class: vue.normalizeClass(["bm-fc-rect", { "is-ele": layer.backgroundImage }]),
+            style: vue.normalizeStyle(layer)
+          }, null, 6);
+        }), 128))
+      ], 4);
+    };
+  }
+});
+var TempContent = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__file", "temp-content.vue"]]);
+
+const _hoisted_1$3 = /* @__PURE__ */ vue.createTextVNode("\u91CD\u7F6E");
+const _hoisted_2$3 = /* @__PURE__ */ vue.createTextVNode(" \u67E5\u8BE2 ");
+const _hoisted_3$3 = { class: "bm-fc-select-material-temp__content__item-info" };
+const _hoisted_4$2 = { class: "bm-fc-select-material-temp__content__item-info__cover" };
+const _hoisted_5$2 = ["src"];
+const _hoisted_6$2 = ["onClick"];
+const _hoisted_7$2 = {
+  key: 1,
+  class: "bm-fc-select-material-temp__content__circle"
+};
+const _hoisted_8$2 = ["title"];
+const _hoisted_9$2 = { class: "bm-fc-select-material-temp__content__item-time" };
+const _sfc_main$6 = /* @__PURE__ */ vue.defineComponent({
+  __name: "select-material-temp",
+  props: ["visible", "fetchMaterialType", "fetchMaterialTemp"],
+  emits: ["update:visible", "select"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const treeData = vue.ref([]);
+    const templateName = vue.ref("");
+    const list = vue.ref([]);
+    const selectTypeKeys = vue.ref([]);
+    const params = vue.computed(() => ({
+      timestamp: timestamp.value,
+      pageType: 1,
+      templateName: templateName.value,
+      categoryCode: selectTypeKeys.value?.[0],
+      secondCategoryCode: selectTypeKeys.value?.[1],
+      thirdCategoryCode: selectTypeKeys.value?.[2],
+      pageSize: pagination.pageSize,
+      pageNum: pagination.current
+    }));
+    const selectItem = vue.ref({});
+    const pagination = vue.reactive({
+      current: 1,
+      pageSize: 8,
+      total: 0
+    });
+    const timestamp = vue.ref("");
+    function initType() {
+      props.fetchMaterialType({
+        level: 1,
+        relationCode: ""
+      }).then((result) => {
+        result.forEach((item) => {
+          item.isLeaf = false;
+        });
+        treeData.value = result;
+      });
+    }
+    function onLoadData(treeNode) {
+      return new Promise((resolve) => {
+        if (treeNode.dataRef.children) {
+          resolve();
+          return;
+        }
+        const level = treeNode.parent ? 3 : 2;
+        const isLeaf = level === 3;
+        props.fetchMaterialType({
+          level,
+          relationCode: treeNode.dataRef.key
+        }).then((data) => {
+          data.forEach((item) => {
+            item.isLeaf = isLeaf;
+          });
+          if (!data.length) {
+            treeNode.dataRef.isLeaf = true;
+          }
+          treeNode.dataRef.children = data;
+          treeData.value = [...treeData.value];
+        }).finally(() => {
+          resolve();
+        });
+      });
+    }
+    function getSelectTypeKeys(node) {
+      const result = [];
+      result.unshift(node.key);
+      while (node.parent) {
+        node = node.parent;
+        result.unshift(node.key);
+      }
+      return result;
+    }
+    function handleTreeSelect(selectedKeys, e) {
+      selectTypeKeys.value = getSelectTypeKeys(e.node);
+      pagination.current = 1;
+      getTem();
+    }
+    function getTem() {
+      props.fetchMaterialTemp(params.value).then((data) => {
+        list.value = data.list;
+        pagination.total = data.total;
+        timestamp.value = data.timestamp;
+      });
+    }
+    function select(item) {
+      selectItem.value = item;
+    }
+    function reset() {
+      pagination.current = 1;
+      templateName.value = "";
+      getTem();
+    }
+    function search() {
+      pagination.current = 1;
+      getTem();
+    }
+    function pageChange(page) {
+      pagination.current = page;
+      getTem();
+    }
+    function handleOk() {
+      emits("select", selectItem.value.templateCode);
+      emits("update:visible", false);
+    }
+    initType();
+    getTem();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.Modal), {
+        title: "\u9009\u62E9\u7D20\u6750\u6A21\u677F",
+        centered: "",
+        width: 1e3,
+        visible: __props.visible,
+        "body-style": { padding: 0 },
+        "onUpdate:visible": _cache[1] || (_cache[1] = ($event) => _ctx.$emit("update:visible", false)),
+        onOk: handleOk
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(vue.unref(antDesignVue.Layout), { class: "bm-fc-select-material-temp" }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(antDesignVue.LayoutSider), { class: "bm-fc-select-material-temp__sider" }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(antDesignVue.Tree), {
+                    "tree-data": treeData.value,
+                    "load-data": onLoadData,
+                    onSelect: handleTreeSelect
+                  }, null, 8, ["tree-data"])
+                ]),
+                _: 1
+              }),
+              vue.createVNode(vue.unref(antDesignVue.LayoutContent), { class: "bm-fc-select-material-temp__content" }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(antDesignVue.Input), {
+                    value: templateName.value,
+                    "onUpdate:value": _cache[0] || (_cache[0] = ($event) => templateName.value = $event),
+                    class: "bm-fc-select-material-temp__content__input",
+                    placeholder: "\u8BF7\u8F93\u5165\u6A21\u677F\u540D\u79F0\u641C\u7D22"
+                  }, null, 8, ["value"]),
+                  vue.createVNode(vue.unref(antDesignVue.Button), {
+                    class: "bm-fc-select-material-temp__content__btn",
+                    onClick: reset
+                  }, {
+                    default: vue.withCtx(() => [
+                      _hoisted_1$3
+                    ]),
+                    _: 1
+                  }),
+                  vue.createVNode(vue.unref(antDesignVue.Button), {
+                    class: "bm-fc-select-material-temp__content__btn",
+                    type: "primary",
+                    onClick: search
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(vue.unref(iconsVue.SearchOutlined)),
+                      _hoisted_2$3
+                    ]),
+                    _: 1
+                  }),
+                  vue.createVNode(vue.unref(antDesignVue.Row), { gutter: [16, 16] }, {
+                    default: vue.withCtx(() => [
+                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(list.value, (item) => {
+                        return vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.Col), {
+                          key: item.id,
+                          span: 6
+                        }, {
+                          default: vue.withCtx(() => [
+                            vue.createElementVNode("div", _hoisted_3$3, [
+                              vue.createElementVNode("div", _hoisted_4$2, [
+                                item.coverPlanUrl ? (vue.openBlock(), vue.createElementBlock("img", {
+                                  key: 0,
+                                  class: "bm-fc-select-material-temp__content__item-info__cover__img",
+                                  src: item.coverPlanUrl,
+                                  alt: ""
+                                }, null, 8, _hoisted_5$2)) : (vue.openBlock(), vue.createBlock(TempContent, {
+                                  key: 1,
+                                  content: item.htmlContent
+                                }, null, 8, ["content"]))
+                              ]),
+                              vue.createElementVNode("div", {
+                                class: "bm-fc-select-material-temp__content__item-name",
+                                onClick: ($event) => select(item)
+                              }, [
+                                selectItem.value.id === item.id ? (vue.openBlock(), vue.createBlock(vue.unref(iconsVue.CheckCircleFilled), {
+                                  key: 0,
+                                  class: "bm-fc-select-material-temp__content__check-icon"
+                                })) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_7$2)),
+                                vue.createElementVNode("span", {
+                                  class: "bm-fc-select-material-temp__content__name",
+                                  title: item.templateName
+                                }, vue.toDisplayString(item.templateName), 9, _hoisted_8$2)
+                              ], 8, _hoisted_6$2),
+                              vue.createElementVNode("div", _hoisted_9$2, vue.toDisplayString(vue.unref(dayjs__default["default"])(item.lastUpdateTime).format("YYYY/MM/DD")), 1)
+                            ])
+                          ]),
+                          _: 2
+                        }, 1024);
+                      }), 128))
+                    ]),
+                    _: 1
+                  }),
+                  vue.createVNode(vue.unref(antDesignVue.Pagination), {
+                    style: { "text-align": "right", "margin-top": "20px" },
+                    current: pagination.current,
+                    "page-size": pagination.pageSize,
+                    total: pagination.total,
+                    size: "small",
+                    "show-quick-jumper": "",
+                    onChange: pageChange
+                  }, null, 8, ["current", "page-size", "total"])
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["visible"]);
+    };
+  }
+});
+var SelectMaterialTemp = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__file", "select-material-temp.vue"]]);
+
+const _hoisted_1$2 = { class: "bm-dc-table-widget" };
+const _hoisted_2$2 = { class: "bm-dc-table-widget__title" };
+const _hoisted_3$2 = { class: "bm-dc-table-widget__title-samll" };
+const _hoisted_4$1 = { class: "bm-dc-table-widget__top-bar" };
+const _hoisted_5$1 = /* @__PURE__ */ vue.createTextVNode("\u4E0B\u8F7D\u6A21\u677F");
+const _hoisted_6$1 = /* @__PURE__ */ vue.createTextVNode("\u6279\u91CF\u5BFC\u5165");
+const _hoisted_7$1 = /* @__PURE__ */ vue.createTextVNode("\u6279\u91CF\u5220\u9664");
+const _hoisted_8$1 = /* @__PURE__ */ vue.createTextVNode(" \u65B0\u589E ");
+const _hoisted_9$1 = { class: "bm-dc-table-widget__table" };
+const _hoisted_10$1 = ["onClick"];
+const _hoisted_11$1 = ["onClick"];
+const _sfc_main$5 = /* @__PURE__ */ vue.defineComponent({
+  __name: "table-widget",
+  props: ["rule", "extraConfig"],
+  emits: ["change"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const productInfoKeyMap = {
+      \u5546\u54C1\u540D\u79F0: "productName",
+      \u5546\u54C1\u7B80\u79F0: "productShortName",
+      \u5546\u54C1\u56FE\u7247: "picUrl",
+      \u5EFA\u8BAE\u96F6\u552E\u4EF7: "retailPrice",
+      \u5546\u54C1\u7BB1\u89C4: "carton",
+      \u5546\u54C1\u5355\u4F4D: "unit"
+    };
+    const oper = "oper";
+    const bmFloatTableRef = vue.ref();
+    const importFeature = vue.computed(() => isShow("import"));
+    const deleteFeature = vue.computed(() => isShow("delete"));
+    const copyFeature = vue.computed(() => isShow("copy"));
+    const columns = vue.reactive([]);
+    const data = vue.reactive([]);
+    const config = vue.computed(() => ({
+      columns: [...columns],
+      data: [...data],
+      checkboxConfig: {
+        trigger: "cell"
+      }
+    }));
+    const countText = vue.computed(() => {
+      const cache = {};
+      props.rule.config.childRules?.forEach((rule) => {
+        if (rule.name === "numInput" && rule.config.count) {
+          cache[rule.field] = { title: rule.title.title, count: 0 };
+        }
+      });
+      data.forEach((row) => {
+        Object.keys(cache).forEach((key) => {
+          if (!isNaN(row[key]))
+            cache[key].count += row[key];
+        });
+      });
+      if (Object.keys(cache).length)
+        return `\uFF08\u5B57\u6BB5\u540D\u603B\u8BA1\uFF1A${Object.values(cache).reduce((pre, cur, index) => {
+          if (index !== 0)
+            pre += "\u3001";
+          pre += `${cur.title}\uFF1A${cur.count}`;
+          return pre;
+        }, "")}\uFF09`;
+      else
+        return "";
+    });
+    const xGrid = vue.computed(() => bmFloatTableRef.value.xGrid || {});
+    const inputRef = vue.ref();
+    function isShow(key) {
+      return props.rule.config.tableAdvancedFeatures.includes(key);
+    }
+    function initConfig() {
+      columns.splice(0, columns.length);
+      data.splice(0, data.length);
+      const childRules = props.rule.config.childRules;
+      const value = props.rule.value;
+      if (deleteFeature.value) {
+        columns.push({
+          type: "checkbox",
+          width: "54px"
+        });
+      }
+      childRules?.length && columns.push(
+        ...childRules.reduce((pre, cur) => {
+          const name = cur.name;
+          if (name === "product") {
+            pre.push(...getProductColumn(cur));
+          } else {
+            pre.push(ruleList[name].tableRule(cur, props.extraConfig));
+          }
+          return pre;
+        }, [])
+      );
+      columns.push({
+        field: oper,
+        title: "\u64CD\u4F5C",
+        width: "100px",
+        fixed: "right",
+        slots: {
+          default: "floatHandle"
+        }
+      });
+      handleAdd(value);
+    }
+    function getRowData() {
+      return props.rule.config.childRules?.reduce((pre, cur) => {
+        if (cur.name === "date" && !cur.config.defaultValue) {
+          pre[cur.field] = dayjs__default["default"]().format(cur.props.format);
+        } else {
+          pre[cur.field] = cur.value;
+        }
+        return pre;
+      }, {});
+    }
+    function getProductColumn(rule) {
+      const field = rule.field;
+      const associatedFields = rule.config.associatedFields;
+      const columns2 = [
+        {
+          field,
+          title: "\u5546\u54C1\u7F16\u7801",
+          headerClassName: rule.effect.required ? "is-required" : "",
+          width: "138px",
+          slots: {
+            default({ row }) {
+              return vue.h(antDesignVue.Input, {
+                value: row[field],
+                placeholder: "\u8BF7\u8F93\u5165",
+                "onUpdate:value": (value) => {
+                  row[field] = value;
+                },
+                onChange() {
+                  queryProductInfo(rule, row);
+                }
+              });
+            }
+          }
+        }
+      ];
+      if (associatedFields.length) {
+        associatedFields.forEach((item) => {
+          const childField = field + item.value;
+          columns2.push({
+            field: childField,
+            title: item.label,
+            width: "138px",
+            slots: {
+              default({ row }) {
+                if (item.value === "\u5546\u54C1\u56FE\u7247" && row[childField]) {
+                  return vue.h("img", {
+                    src: "/cloudStorage/read/read?p=" + row[childField],
+                    style: {
+                      width: "86px",
+                      height: "86px",
+                      padding: "8px"
+                    }
+                  });
+                }
+                return vue.h(
+                  "div",
+                  {
+                    style: {
+                      color: "#9393A3"
+                    }
+                  },
+                  [row[childField] || "\u7CFB\u7EDF\u81EA\u52A8\u5E26\u51FA"]
+                );
+              }
+            }
+          });
+        });
+      }
+      return columns2;
+    }
+    function handleAdd(rowData) {
+      Array.isArray(rowData) ? data.push(...rowData) : data.push(getRowData());
+    }
+    function handleCopy(row) {
+      data.push(lodashEs.cloneDeep(row));
+    }
+    function handleDelete(index) {
+      data.splice(index, 1);
+    }
+    function handleBatchDelete() {
+      const selected = xGrid.value.getCheckboxRecords();
+      selected.forEach((item) => {
+        const index = data.indexOf(item);
+        handleDelete(index);
+      });
+    }
+    function handleDownload() {
+      xGrid.value.exportData({
+        type: "csv",
+        data: [],
+        columnFilterMethod({ column }) {
+          return isValidColumn(column);
+        }
+      });
+    }
+    function handleImport() {
+      inputRef.value.click();
+    }
+    function emitChange() {
+      emits("change", data);
+    }
+    function queryProductInfo(rule, row) {
+      const field = rule.field;
+      const associatedFields = rule?.config?.associatedFields;
+      associatedFields.length && props.extraConfig.product.fetch({ productCode: row[field] }).then((data2) => {
+        associatedFields.forEach((item) => {
+          row[field + item.value] = data2[productInfoKeyMap[item.value]];
+        });
+      });
+    }
+    function handleChange(e) {
+      const file = e.target.files[0];
+      const reader = new FileReader();
+      reader.onload = (fr) => {
+        const rows = parseCsv(fr?.target?.result);
+        const validColumns = columns.filter((c) => isValidColumn(c));
+        rows.forEach((row) => {
+          const rowData = {};
+          row.forEach((item, index) => {
+            rowData[validColumns[index].field] = item;
+          });
+          data.push(rowData);
+        });
+        e.target.value = "";
+      };
+      file && reader.readAsText(file, "GB2312");
+    }
+    function isValidColumn(c) {
+      return c.type !== "checkbox" && c.field !== oper;
+    }
+    function parseCsv(result) {
+      let data2 = [];
+      if (result) {
+        data2 = result.split("\r\n").slice(1).filter((item) => item).map((item) => item.split(","));
+      }
+      return data2;
+    }
+    vue.watch(
+      () => props.rule,
+      () => {
+        initConfig();
+      },
+      {
+        immediate: true
+      }
+    );
+    vue.watch(
+      () => data,
+      () => {
+        emitChange();
+      },
+      { deep: true, immediate: true }
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$2, [
+        vue.createElementVNode("div", _hoisted_2$2, [
+          vue.createTextVNode(vue.toDisplayString(__props.rule.title.title) + " ", 1),
+          vue.createElementVNode("span", _hoisted_3$2, vue.toDisplayString(vue.unref(countText)), 1),
+          vue.createElementVNode("div", _hoisted_4$1, [
+            vue.unref(importFeature) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+              vue.createVNode(vue.unref(antDesignVue.Button), { onClick: handleDownload }, {
+                default: vue.withCtx(() => [
+                  _hoisted_5$1
+                ]),
+                _: 1
+              }),
+              vue.createVNode(vue.unref(antDesignVue.Button), { onClick: handleImport }, {
+                default: vue.withCtx(() => [
+                  _hoisted_6$1
+                ]),
+                _: 1
+              }),
+              vue.createElementVNode("input", {
+                ref_key: "inputRef",
+                ref: inputRef,
+                style: { "display": "none" },
+                name: "file",
+                type: "file",
+                accept: "text/csv",
+                onChange: handleChange
+              }, null, 544)
+            ], 64)) : vue.createCommentVNode("v-if", true),
+            vue.unref(deleteFeature) ? (vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.Button), {
+              key: 1,
+              onClick: handleBatchDelete
+            }, {
+              default: vue.withCtx(() => [
+                _hoisted_7$1
+              ]),
+              _: 1
+            })) : vue.createCommentVNode("v-if", true),
+            vue.createVNode(vue.unref(antDesignVue.Button), {
+              type: "primary",
+              onClick: handleAdd
+            }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(vue.unref(iconsVue.PlusOutlined)),
+                _hoisted_8$1
+              ]),
+              _: 1
+            })
+          ])
+        ]),
+        vue.createElementVNode("div", _hoisted_9$1, [
+          vue.createVNode(vue.unref(antDesignVue.FormItemRest), null, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(components.BmFloatTable), {
+                ref_key: "bmFloatTableRef",
+                ref: bmFloatTableRef,
+                config: vue.unref(config)
+              }, {
+                floatHandle: vue.withCtx(({ row, rowIndex }) => [
+                  vue.unref(copyFeature) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                    vue.createElementVNode("a", {
+                      onClick: ($event) => handleCopy(row)
+                    }, "\u590D\u5236", 8, _hoisted_10$1),
+                    vue.createVNode(vue.unref(antDesignVue.Divider), { type: "vertical" })
+                  ], 64)) : vue.createCommentVNode("v-if", true),
+                  vue.createElementVNode("a", {
+                    onClick: ($event) => handleDelete(rowIndex)
+                  }, "\u5220\u9664", 8, _hoisted_11$1)
+                ]),
+                _: 1
+              }, 8, ["config"])
+            ]),
+            _: 1
+          })
+        ])
+      ]);
+    };
+  }
+});
+var TableWidget = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__file", "table-widget.vue"]]);
+
+const _hoisted_1$1 = /* @__PURE__ */ vue.createElementVNode("span", { class: "bm-fc-form-item-label is-required" }, "\u7D20\u6750\u6A21\u677F\uFF1A", -1);
+const _hoisted_2$1 = { key: 0 };
+const _hoisted_3$1 = /* @__PURE__ */ vue.createTextVNode("\u66F4\u6362\u6A21\u677F");
+const _hoisted_4 = /* @__PURE__ */ vue.createTextVNode(" \u9009\u62E9\u6A21\u677F ");
+const _hoisted_5 = /* @__PURE__ */ vue.createElementVNode("span", { class: "bm-fc-form-item-label" }, "\u7D20\u6750\u7C7B\u578B\uFF1A", -1);
+const _hoisted_6 = /* @__PURE__ */ vue.createElementVNode("span", { class: "bm-fc-form-item-label" }, "\u5C3A\u5BF8\uFF1A", -1);
+const _hoisted_7 = /* @__PURE__ */ vue.createElementVNode("span", { class: "bm-fc-form-item-label" }, "\u5C01\u9762\u56FE\uFF1A", -1);
+const _hoisted_8 = ["src"];
+const _hoisted_9 = { key: 1 };
+const _hoisted_10 = /* @__PURE__ */ vue.createElementVNode("span", { class: "bm-fc-form-item-label" }, "\u6A21\u677F\u7ED3\u6784\u56FE\uFF1A", -1);
+const _hoisted_11 = { key: 1 };
+const _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
+  __name: "material-temp",
+  props: [
+    "uploadPictureRule",
+    "extraConfig",
+    "formCreateInject",
+    "value"
+  ],
+  emits: ["change"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const activeKey = vue.ref("\u7D20\u67501");
+    const visible = vue.ref(false);
+    vue.computed(() => props.formCreateInject.rule.value || {});
+    const panes = vue.reactive([
+      {
+        key: "\u7D20\u67501",
+        title: "\u7D20\u67501",
+        tempSelected: {}
+      }
+    ]);
+    vue.computed(
+      () => panes.find((pane) => pane.key === activeKey.value)
+    );
+    let index = 2;
+    const measrueDicts = vue.ref([]);
+    function selectTemp() {
+      visible.value = true;
+    }
+    function handleSelect(tempId) {
+      return getTempDetail(tempId).then((result) => {
+        const activePane2 = getAcitvePane();
+        activePane2.tempSelected = result;
+        activePane2.tableRule = getTableRule(result.coverageArr);
+      });
+    }
+    function getAcitvePane() {
+      return panes.find((pane) => pane.key === activeKey.value);
+    }
+    function getTempDetail(templateCode) {
+      return props.extraConfig.fetchMaterialTempDetail({ templateCode });
+    }
+    function handleUpload(list) {
+      getAcitvePane().uploadList = list;
+    }
+    function handleAdd() {
+      const key = `\u7D20\u6750${index}`;
+      panes.push({
+        key,
+        title: `\u7D20\u6750${index}`,
+        tempSelected: {}
+      });
+      activeKey.value = key;
+      index++;
+    }
+    function handleDelete(targetKey) {
+      panes.splice(
+        panes.findIndex((pane) => pane.key === targetKey),
+        1
+      );
+    }
+    function getTableRule(coverageArr) {
+      const fieldTypeMap = {
+        1: "input",
+        2: "numInput",
+        3: "date",
+        4: "input"
+      };
+      const formatMap = {
+        0: "YYYY-MM",
+        1: "YYYY-MM-DD",
+        2: "YYYY-MM-DD HH:mm"
+      };
+      const activePane2 = getAcitvePane();
+      const childRules = coverageArr.filter((coverage) => coverage.fieldType === 4 || coverage.isEdit).map((coverage) => {
+        const extraValues = JSON.parse(coverage.extraValues);
+        const value = {
+          name: fieldTypeMap[coverage.fieldType],
+          title: {
+            title: coverage.name
+          },
+          field: coverage.name,
+          effect: {
+            required: coverage.fieldType === 4 || coverage.isCheck
+          },
+          config: {
+            fieldRatio: "140px"
+          }
+        };
+        if (coverage.fieldType === 3) {
+          value.props = {};
+          value.props.format = formatMap[extraValues.format];
+        }
+        if (coverage.fieldType === 1 || coverage.fieldType === 2 || coverage.fieldType === 4) {
+          value.props = {};
+          value.props.placeholder = "\u8BF7\u8F93\u5165";
+        }
+        return value;
+      });
+      if (childRules.length)
+        return {
+          title: {
+            title: "\u660E\u7EC6\u5217\u8868"
+          },
+          config: {
+            tableAdvancedFeatures: ["import", "delete", "copy"],
+            childRules
+          },
+          value: activePane2.tableData
+        };
+      else
+        return void 0;
+    }
+    function handleTableDataChange(value) {
+      getAcitvePane().tableData = value;
+    }
+    function emitChange() {
+      emits("change", {
+        index,
+        panes: panes.map((pane) => ({
+          key: pane.key,
+          title: pane.title,
+          tempIdSelected: pane.tempSelected.templateCode || pane.tempIdSelected,
+          tableData: pane.tableData,
+          uploadList: pane.uploadList
+        }))
+      });
+    }
+    function initValue(value) {
+      index = props.value.index;
+      panes.splice(0, panes.length);
+      value.panes.forEach((pane, index2) => {
+        pane.tempSelected = {};
+        if (index2 === 0) {
+          activeKey.value = pane.key;
+        }
+        panes.push(pane);
+      });
+      handTabChange();
+    }
+    function handTabChange() {
+      const activePane2 = getAcitvePane();
+      if (activePane2.tempIdSelected) {
+        handleSelect(activePane2.tempIdSelected).then(() => {
+          delete activePane2.tempIdSelected;
+        });
+      }
+    }
+    props.value && initValue(props.value);
+    props.extraConfig.getDict().then((data) => {
+      measrueDicts.value = data;
+    });
+    vue.watch(
+      () => panes,
+      () => {
+        emitChange();
+      },
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+        vue.createVNode(vue.unref(antDesignVue.Tabs), {
+          activeKey: activeKey.value,
+          "onUpdate:activeKey": _cache[0] || (_cache[0] = ($event) => activeKey.value = $event),
+          class: "bm-fc-material-temp",
+          type: "editable-card",
+          "hide-add": "",
+          size: "small",
+          onEdit: handleDelete,
+          onChange: handTabChange
+        }, {
+          rightExtra: vue.withCtx(() => [
+            vue.createElementVNode("span", {
+              class: "bm-fc-material-temp__add",
+              onClick: handleAdd
+            }, [
+              vue.createVNode(vue.unref(iconsVue.PlusOutlined))
+            ])
+          ]),
+          default: vue.withCtx(() => [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(panes, (pane) => {
+              return vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.TabPane), {
+                key: pane.key,
+                tab: pane.title
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(antDesignVue.FormItemRest), null, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(vue.unref(antDesignVue.Row), { gutter: [0, 24] }, {
+                        default: vue.withCtx(() => [
+                          vue.createVNode(vue.unref(antDesignVue.Col), { span: 8 }, {
+                            default: vue.withCtx(() => [
+                              vue.createVNode(vue.unref(antDesignVue.Row), null, {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(vue.unref(antDesignVue.Col), null, {
+                                    default: vue.withCtx(() => [
+                                      _hoisted_1$1
+                                    ]),
+                                    _: 1
+                                  }),
+                                  vue.createVNode(vue.unref(antDesignVue.Col), { flex: 1 }, {
+                                    default: vue.withCtx(() => [
+                                      pane.tempSelected.templateName ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$1, [
+                                        vue.createTextVNode(vue.toDisplayString(pane.tempSelected.templateName) + " ", 1),
+                                        vue.createVNode(vue.unref(antDesignVue.Button), {
+                                          type: "link",
+                                          onClick: selectTemp
+                                        }, {
+                                          default: vue.withCtx(() => [
+                                            _hoisted_3$1
+                                          ]),
+                                          _: 1
+                                        })
+                                      ])) : (vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.Button), {
+                                        key: 1,
+                                        onClick: selectTemp
+                                      }, {
+                                        default: vue.withCtx(() => [
+                                          vue.createVNode(vue.unref(iconsVue.PlusOutlined)),
+                                          _hoisted_4
+                                        ]),
+                                        _: 1
+                                      }))
+                                    ]),
+                                    _: 2
+                                  }, 1024)
+                                ]),
+                                _: 2
+                              }, 1024)
+                            ]),
+                            _: 2
+                          }, 1024),
+                          vue.createVNode(vue.unref(antDesignVue.Col), { span: 8 }, {
+                            default: vue.withCtx(() => [
+                              vue.createVNode(vue.unref(antDesignVue.Row), null, {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(vue.unref(antDesignVue.Col), null, {
+                                    default: vue.withCtx(() => [
+                                      _hoisted_5
+                                    ]),
+                                    _: 1
+                                  }),
+                                  vue.createVNode(vue.unref(antDesignVue.Col), {
+                                    class: "bm-fc-form-item",
+                                    flex: 1
+                                  }, {
+                                    default: vue.withCtx(() => [
+                                      vue.createTextVNode(vue.toDisplayString(pane.tempSelected.materialCategoryNameShow || "\u7CFB\u7EDF\u81EA\u52A8\u5E26\u51FA"), 1)
+                                    ]),
+                                    _: 2
+                                  }, 1024)
+                                ]),
+                                _: 2
+                              }, 1024)
+                            ]),
+                            _: 2
+                          }, 1024),
+                          vue.createVNode(vue.unref(antDesignVue.Col), { span: 8 }, {
+                            default: vue.withCtx(() => [
+                              vue.createVNode(vue.unref(antDesignVue.Row), null, {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(vue.unref(antDesignVue.Col), null, {
+                                    default: vue.withCtx(() => [
+                                      _hoisted_6
+                                    ]),
+                                    _: 1
+                                  }),
+                                  vue.createVNode(vue.unref(antDesignVue.Col), {
+                                    class: "bm-fc-form-item",
+                                    flex: 1
+                                  }, {
+                                    default: vue.withCtx(() => [
+                                      vue.createTextVNode(vue.toDisplayString(measrueDicts.value.find(
+                                        (dict) => dict.dictId + "" === pane.tempSelected.measure + ""
+                                      )?.dictName || "\u7CFB\u7EDF\u81EA\u52A8\u83B7\u53D6"), 1)
+                                    ]),
+                                    _: 2
+                                  }, 1024)
+                                ]),
+                                _: 2
+                              }, 1024)
+                            ]),
+                            _: 2
+                          }, 1024),
+                          vue.createVNode(vue.unref(antDesignVue.Col), { span: 8 }, {
+                            default: vue.withCtx(() => [
+                              vue.createVNode(vue.unref(antDesignVue.Row), null, {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(vue.unref(antDesignVue.Col), null, {
+                                    default: vue.withCtx(() => [
+                                      _hoisted_7
+                                    ]),
+                                    _: 1
+                                  }),
+                                  vue.createVNode(vue.unref(antDesignVue.Col), {
+                                    class: "bm-fc-form-item",
+                                    flex: 1
+                                  }, {
+                                    default: vue.withCtx(() => [
+                                      pane.tempSelected.coverPlanPath ? (vue.openBlock(), vue.createElementBlock("img", {
+                                        key: 0,
+                                        class: "bm-fc-form-item__cover",
+                                        src: pane.tempSelected.coverPlanPath
+                                      }, null, 8, _hoisted_8)) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_9, "\u7CFB\u7EDF\u81EA\u52A8\u83B7\u53D6"))
+                                    ]),
+                                    _: 2
+                                  }, 1024)
+                                ]),
+                                _: 2
+                              }, 1024)
+                            ]),
+                            _: 2
+                          }, 1024),
+                          vue.createVNode(vue.unref(antDesignVue.Col), { span: 8 }, {
+                            default: vue.withCtx(() => [
+                              vue.createVNode(vue.unref(antDesignVue.Row), null, {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(vue.unref(antDesignVue.Col), null, {
+                                    default: vue.withCtx(() => [
+                                      _hoisted_10
+                                    ]),
+                                    _: 1
+                                  }),
+                                  vue.createVNode(vue.unref(antDesignVue.Col), {
+                                    class: "bm-fc-form-item",
+                                    flex: 1
+                                  }, {
+                                    default: vue.withCtx(() => [
+                                      pane.tempSelected.content ? (vue.openBlock(), vue.createBlock(TempContent, {
+                                        key: 0,
+                                        class: "bm-fc-form-item__temp-content",
+                                        content: pane.tempSelected.content
+                                      }, null, 8, ["content"])) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_11, "\u7CFB\u7EDF\u81EA\u52A8\u83B7\u53D6"))
+                                    ]),
+                                    _: 2
+                                  }, 1024)
+                                ]),
+                                _: 2
+                              }, 1024)
+                            ]),
+                            _: 2
+                          }, 1024),
+                          !__props.uploadPictureRule.hidden ? (vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.Col), {
+                            key: 0,
+                            span: 24
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createVNode(vue.unref(antDesignVue.Row), null, {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(vue.unref(antDesignVue.Col), null, {
+                                    default: vue.withCtx(() => [
+                                      vue.createElementVNode("span", {
+                                        class: vue.normalizeClass(["bm-fc-form-item-label", { "is-required": __props.uploadPictureRule.required }])
+                                      }, "\u4E0A\u4F20\u53C2\u8003\u56FE\uFF1A", 2)
+                                    ]),
+                                    _: 1
+                                  }),
+                                  vue.createVNode(vue.unref(antDesignVue.Col), {
+                                    class: "bm-fc-form-item",
+                                    flex: 1
+                                  }, {
+                                    default: vue.withCtx(() => [
+                                      vue.createVNode(vue.unref(Picture__default["default"]), {
+                                        "upload-props": {
+                                          listType: "picture-card",
+                                          text: "\u4E0A\u4F20\u56FE\u7247",
+                                          multiple: true
+                                        },
+                                        "extra-props": {
+                                          maxCount: 9
+                                        },
+                                        "upload-request": __props.extraConfig.uploadRequest,
+                                        "default-list": pane.uploadList,
+                                        onUpdate: handleUpload
+                                      }, null, 8, ["upload-request", "default-list"])
+                                    ]),
+                                    _: 2
+                                  }, 1024)
+                                ]),
+                                _: 2
+                              }, 1024)
+                            ]),
+                            _: 2
+                          }, 1024)) : vue.createCommentVNode("v-if", true)
+                        ]),
+                        _: 2
+                      }, 1024),
+                      pane.tableRule ? (vue.openBlock(), vue.createBlock(TableWidget, {
+                        key: 0,
+                        rule: pane.tableRule,
+                        onChange: handleTableDataChange
+                      }, null, 8, ["rule"])) : vue.createCommentVNode("v-if", true)
+                    ]),
+                    _: 2
+                  }, 1024)
+                ]),
+                _: 2
+              }, 1032, ["tab"]);
+            }), 128))
+          ]),
+          _: 1
+        }, 8, ["activeKey"]),
+        vue.createVNode(SelectMaterialTemp, {
+          visible: visible.value,
+          "onUpdate:visible": _cache[1] || (_cache[1] = ($event) => visible.value = $event),
+          "fetch-material-type": __props.extraConfig.fetchMaterialType,
+          "fetch-material-temp": __props.extraConfig.fetchMaterialTemp,
+          onSelect: handleSelect
+        }, null, 8, ["visible", "fetch-material-type", "fetch-material-temp"])
+      ], 64);
+    };
+  }
+});
+var MaterialTemp = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__file", "material-temp.vue"]]);
+
+var materialTemp = {
+    name: 'materialTemp',
+    rule(data, extraConfig) {
+        return {
+            native: true,
+            type: 'div',
+            children: [
+                {
+                    native: true,
+                    type: 'div',
+                    children: ['素材信息'],
+                    class: 'bm-fc-head-line',
+                },
+                {
+                    type: 'MaterialTemp',
+                    component: MaterialTemp,
+                    field: data.field,
+                    props: {
+                        uploadPictureRule: data.config.uploadPictureRule,
+                        extraConfig: extraConfig.materialTemp,
+                        value: data.value,
+                    },
+                    inject: true,
+                    on: {
+                        change(inject, value) {
+                            inject.self.value = value;
+                        },
+                    },
+                },
+            ],
+            class: 'bm-fc-module-widget',
+        };
+    },
+};
+
+const _hoisted_1 = { class: "bm-fc-form-item-label" };
+const _hoisted_2 = ["src"];
+const _hoisted_3 = /* @__PURE__ */ vue.createTextVNode("\u7CFB\u7EDF\u81EA\u52A8\u5E26\u51FA");
+const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
+  __name: "product-info",
+  props: [
+    "associatedFields",
+    "dataFiltering",
+    "required",
+    "extraConfig",
+    "defalutValue"
+  ],
+  emits: ["change"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const productInfo = vue.ref({});
+    const productInfoKeyMap = {
+      \u5546\u54C1\u540D\u79F0: "productName",
+      \u5546\u54C1\u7B80\u79F0: "productShortName",
+      \u5546\u54C1\u56FE\u7247: "picUrl",
+      \u5EFA\u8BAE\u96F6\u552E\u4EF7: "retailPrice",
+      \u5546\u54C1\u7BB1\u89C4: "carton",
+      \u5546\u54C1\u5355\u4F4D: "unit"
+    };
+    const unitMap = ["\u652F", "\u74F6", "\u5957", "\u7EC4", "\u7BB1", "\u4E2A", "\u5F20"];
+    async function fetch(value) {
+      productInfo.value = await props.extraConfig.fetch({
+        productCode: value,
+        filterByShopcode: props.dataFiltering
+      }) || {};
+    }
+    function handleBlur(evt) {
+      const value = evt.target.value;
+      emitChange(value);
+      fetch(value);
+    }
+    function getValue(value) {
+      return productInfo.value[productInfoKeyMap[value]];
+    }
+    function emitChange(value) {
+      emits("change", value);
+    }
+    vue.watch(
+      () => props.defalutValue,
+      (val) => {
+        val && fetch(val);
+      },
+      {
+        immediate: true
+      }
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.Row), { gutter: [0, 24] }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(vue.unref(antDesignVue.Col), { span: 8 }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(antDesignVue.Row), null, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(antDesignVue.Col), null, {
+                    default: vue.withCtx(() => [
+                      vue.createElementVNode("span", {
+                        class: vue.normalizeClass([
+                          "bm-fc-form-item-label",
+                          props.required ? "is-required" : ""
+                        ])
+                      }, "\u5546\u54C1\u7F16\u53F7\uFF1A", 2)
+                    ]),
+                    _: 1
+                  }),
+                  vue.createVNode(vue.unref(antDesignVue.Col), { flex: 1 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(vue.unref(antDesignVue.Input), {
+                        placeholder: "\u8BF7\u8F93\u5165",
+                        value: __props.defalutValue,
+                        onBlur: handleBlur
+                      }, null, 8, ["value"])
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }),
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.associatedFields, (field) => {
+            return vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.Col), {
+              key: field.key,
+              span: 8
+            }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(vue.unref(antDesignVue.Row), null, {
+                  default: vue.withCtx(() => [
+                    vue.createVNode(vue.unref(antDesignVue.Col), null, {
+                      default: vue.withCtx(() => [
+                        vue.createElementVNode("span", _hoisted_1, vue.toDisplayString(field.label) + "\uFF1A", 1)
+                      ]),
+                      _: 2
+                    }, 1024),
+                    vue.createVNode(vue.unref(antDesignVue.Col), {
+                      class: "bm-fc-form-item",
+                      flex: 1
+                    }, {
+                      default: vue.withCtx(() => [
+                        getValue(field.value) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                          field.value === "\u5546\u54C1\u56FE\u7247" ? (vue.openBlock(), vue.createElementBlock("img", {
+                            key: 0,
+                            src: getValue(field.value)
+                          }, null, 8, _hoisted_2)) : field.value === "\u5546\u54C1\u5355\u4F4D" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                            vue.createTextVNode(vue.toDisplayString(unitMap[getValue(field.value)]), 1)
+                          ], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
+                            vue.createTextVNode(vue.toDisplayString(getValue(field.value)), 1)
+                          ], 64))
+                        ], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                          _hoisted_3
+                        ], 64))
+                      ]),
+                      _: 2
+                    }, 1024)
+                  ]),
+                  _: 2
+                }, 1024)
+              ]),
+              _: 2
+            }, 1024);
+          }), 128))
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+var ProductInfo = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__file", "product-info.vue"]]);
+
+var product = {
+    name: 'product',
+    rule(data, extraConfig) {
+        return {
+            type: 'ProductInfo',
+            component: ProductInfo,
+            field: data.field,
+            effect: {
+                required: data.effect.required && '请输入商品编号',
+            },
+            props: {
+                required: data.effect.required,
+                associatedFields: data.config.associatedFields,
+                dataFiltering: data.config.dataFiltering,
+                extraConfig: extraConfig.product,
+                defalutValue: data.value,
+            },
+            inject: true,
+            on: {
+                change(inject, value) {
+                    inject.self.value = value;
+                    vue.nextTick(() => {
+                        inject.api.validateField(inject.self.field);
+                    });
+                },
+            },
+        };
+    },
+    rowRule(data) {
+        return {
+            type: 'ProductInfo',
+            component: ProductInfo,
+            field: data.field,
+            effect: {
+                required: data.effect.required && '请输入商品编号',
+            },
+            props: {
+                required: data.effect.required,
+                associatedFields: data.config.associatedFields,
+                dataFiltering: data.config.dataFiltering,
+                defalutValue: data.value,
+            },
+            inject: true,
+            on: {
+                change(inject, value) {
+                    inject.self.value = value;
+                },
+            },
+        };
+    },
+};
+
+const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+  __name: "shop-widget",
+  props: ["value", "extraConfig", "rule"],
+  emits: ["change"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const options = vue.ref([]);
+    const keyword = vue.ref("");
+    const debounceFetch = lodashEs.debounce((value) => {
+      props.extraConfig.fetch(postData.value).then((data) => {
+        if (value === keyword.value)
+          options.value = data;
+      });
+    }, 300);
+    const postData = vue.computed(() => ({
+      keyword: keyword.value,
+      filterByUser: props.rule.config.dataFiltering
+    }));
+    function initOptions() {
+      props.extraConfig.fetch(postData.value).then((data) => {
+        options.value = data;
+      });
+    }
+    function handleChange(value, option) {
+      emits("change", option);
+    }
+    function handleSearch(value) {
+      keyword.value = value;
+      debounceFetch(value);
+    }
+    initOptions();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.Select), {
+        value: __props.value,
+        placeholder: "\u8BF7\u9009\u62E9",
+        "show-search": "",
+        "show-arrow": false,
+        "default-active-first-option": false,
+        "filter-option": false,
+        "not-found-content": null,
+        options: options.value,
+        onChange: handleChange,
+        onSearch: handleSearch
+      }, null, 8, ["value", "options"]);
+    };
+  }
+});
+var ShopWidget = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__file", "shop-widget.vue"]]);
+
+var shop = {
+    name: 'shop',
+    rule(data, extraConfig) {
+        const shopExtraConfig = extraConfig.shop;
+        return {
+            type: 'ShopWidget',
+            component: ShopWidget,
+            title: data.title.title,
+            field: data.field,
+            effect: {
+                required: data.effect.required && '请选择店铺',
+            },
+            props: {
+                rule: data,
+                extraConfig: shopExtraConfig,
+                value: data.value,
+            },
+            inject: true,
+            on: {
+                change(inject, value) {
+                    const rule = inject.self;
+                    rule.value = value;
+                    vue.nextTick(() => {
+                        setTimeout(() => {
+                            inject.api.validateField(rule.field);
+                        });
+                    });
+                },
+            },
+            value: data.value,
+        };
+    },
+    rowRule(data, extraConfig) {
+        const shopExtraConfig = extraConfig.shop;
+        return {
+            type: 'ShopWidget',
+            component: ShopWidget,
+            title: data.title.title,
+            field: data.field,
+            effect: {
+                required: data.effect.required && '请选择店铺',
+            },
+            props: {
+                rule: data,
+                extraConfig: shopExtraConfig,
+                value: data.value,
+            },
+            inject: true,
+            on: {
+                change(inject, value) {
+                    const rule = inject.self;
+                    rule.value = value;
+                    vue.nextTick(() => {
+                        setTimeout(() => {
+                            inject.api.validateField(rule.field);
+                        });
+                    });
+                },
+            },
+            col: {
+                span: 12,
+            },
+            value: data.value,
+        };
+    },
+    tableRule(data, extraConfig) {
+        const field = data.field;
+        return {
+            field,
+            title: data.title.title,
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: '138px',
+            slots: {
+                default({ row }) {
+                    return vue.h(ShopWidget, {
+                        rule: data,
+                        extraConfig: extraConfig.shop,
+                        value: row[field],
+                        onChange: (value) => {
+                            row[field] = value;
+                        },
+                    });
+                },
+            },
+        };
+    },
+};
+
+const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+  __name: "material-type-in-table",
+  props: ["config", "multiple", "format", "value"],
+  emits: ["change"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const options = vue.ref([]);
+    function initOptions() {
+      props.config.fetch({ level: 1, relationCode: "" }).then((result) => {
+        result.forEach((item) => {
+          item.isLeaf = props.format === 1;
+        });
+        options.value = result;
+      });
+    }
+    function loadData(selectedOptions) {
+      const optionLength = selectedOptions.length;
+      const targetOption = selectedOptions[optionLength - 1];
+      targetOption.loading = true;
+      props.config.fetch({
+        level: optionLength + 1,
+        relationCode: targetOption.value
+      }).then((result) => {
+        result.forEach((item) => {
+          item.isLeaf = props.format === optionLength + 1;
+        });
+        targetOption.children = result;
+      }).finally(() => {
+        targetOption.loading = false;
+      });
+    }
+    function handleChange(v) {
+      emits("change", v);
+    }
+    initOptions();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.Cascader), {
+        value: __props.value,
+        placeholder: "\u8BF7\u8F93\u5165",
+        multiple: __props.multiple,
+        options: options.value,
+        "load-data": loadData,
+        "onUpdate:value": handleChange
+      }, null, 8, ["value", "multiple", "options"]);
+    };
+  }
+});
+var materialTypeInTable = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__file", "material-type-in-table.vue"]]);
+
+FC__default["default"].register({
+    name: 'materialTypesOption',
+    init({ value }, rule) {
+        getOption(value, { level: 1, relationCode: '' }).then((data) => {
+            data = isLeaf(data, rule.config.format === 1);
+            if (rule.props) {
+                rule.props.options = data;
+            }
+            else {
+                (rule.props = {}).options = data;
+            }
+        });
+    },
+});
+function getOption(config, data) {
+    return config.fetch(data);
+}
+function isLeaf(data, value) {
+    data.forEach((item) => {
+        item.isLeaf = value;
+    });
+    return data;
+}
+var materialType = {
+    name: 'materialType',
+    rule(data, extraConfig) {
+        return {
+            type: 'cascader',
+            field: data.field,
+            title: '素材类型',
+            validate: [
+                {
+                    required: data.effect.required,
+                    type: 'array',
+                    min: 1,
+                    message: '请选择素材类型',
+                },
+            ],
+            props: {
+                placeholder: '请选择',
+                multiple: data.props.multiple,
+                loadData(inject, selectedOptions) {
+                    const optionLength = selectedOptions.length;
+                    const targetOption = selectedOptions[optionLength - 1];
+                    targetOption.loading = true;
+                    getOption(extraConfig.materialType, {
+                        level: optionLength + 1,
+                        relationCode: targetOption.value,
+                    })
+                        .then((result) => {
+                        result = isLeaf(result, inject.self.config.format === optionLength + 1);
+                        targetOption.children = result;
+                    })
+                        .finally(() => {
+                        targetOption.loading = false;
+                    });
+                },
+            },
+            config: {
+                format: data.config.format,
+            },
+            effect: {
+                materialTypesOption: extraConfig.materialType,
+            },
+            inject: true,
+            on: {
+                change(inject, list) {
+                    const rule = inject.self;
+                    rule.value = list;
+                    vue.nextTick(() => {
+                        inject.api.validateField(rule.field);
+                    });
+                },
+            },
+            value: data.value,
+        };
+    },
+    rowRule(data, extraConfig) {
+        return {
+            type: 'cascader',
+            field: data.field,
+            title: '素材类型',
+            validate: [
+                {
+                    required: data.effect.required,
+                    type: 'array',
+                    min: 1,
+                    message: '请选择素材类型',
+                },
+            ],
+            props: {
+                placeholder: '请选择',
+                multiple: data.props.multiple,
+                loadData(inject, selectedOptions) {
+                    const optionLength = selectedOptions.length;
+                    const targetOption = selectedOptions[optionLength - 1];
+                    targetOption.loading = true;
+                    getOption(extraConfig.materialType, optionLength + 1)
+                        .then((result) => {
+                        result = isLeaf(result, inject.self.config.format === optionLength + 1);
+                        targetOption.children = result;
+                    })
+                        .finally(() => {
+                        targetOption.loading = false;
+                    });
+                },
+            },
+            config: {
+                format: data.config.format,
+            },
+            effect: {
+                materialTypesOption: extraConfig.materialType,
+            },
+            inject: true,
+            on: {
+                change(inject, list) {
+                    const rule = inject.self;
+                    rule.value = list;
+                    vue.nextTick(() => {
+                        inject.api.validateField(rule.field);
+                    });
+                },
+            },
+            col: {
+                span: 12,
+            },
+            value: data.value,
+        };
+    },
+    tableRule(data, extraConfig) {
+        const field = data.field;
+        return {
+            field,
+            title: '素材类型',
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: '138px',
+            slots: {
+                default({ row }) {
+                    return vue.h(materialTypeInTable, {
+                        multiple: data.props.multiple,
+                        format: data.config.format,
+                        config: extraConfig.materialType,
+                        onChange: (value) => {
+                            row[field] = value;
+                        },
+                        value: row[field],
+                    });
+                },
+            },
+        };
+    },
+};
+
+var row = {
+    name: 'row',
+    rule(data) {
+        const children = [
+            {
+                type: 'row',
+                props: {
+                    gutter: [0, 24],
+                },
+                children: [],
+                class: 'bm-fc-row-widget',
+            },
+        ];
+        if (data.config.showTitle) {
+            children.unshift({
+                native: true,
+                type: 'div',
+                children: [data.config.title],
+                class: 'bm-fc-head-line',
+            });
+        }
+        return {
+            native: true,
+            type: 'div',
+            field: data.field,
+            children,
+            class: 'bm-fc-module-widget',
+        };
+    },
+};
+
+var department = {
+    name: 'department',
+    rule(data, extraConfig) {
+        return {
+            type: 'StaffSelector',
+            component: StaffSelector,
+            field: data.field,
+            title: data.title.title,
+            props: {
+                title: '添加部门',
+                mode: data.props.limit ? 'radio' : 'multiple',
+                placeholder: data.props.placeholder,
+                immediateFetch: true,
+                unitStr: '个',
+                defaultSelected: data.value,
+                load() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        return yield extraConfig.department.fetch();
+                    });
+                },
+            },
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            wrap: {
+                wrapperCol: {
+                    span: fieldRatioMap[data.config.fieldRatio],
+                },
+            },
+            inject: true,
+            on: {
+                change(inject, list) {
+                    const rule = inject.self;
+                    rule.value = list;
+                    inject.api.validateField(rule.field, () => {
+                        if (list.length) {
+                            inject.api.clearValidateState(rule.field);
+                        }
+                    });
+                },
+            },
+        };
+    },
+    rowRule(data, extraConfig) {
+        return {
+            type: 'StaffSelector',
+            component: StaffSelector,
+            field: data.field,
+            title: data.title.title,
+            props: {
+                title: '添加部门',
+                mode: data.props.limit ? 'radio' : 'multiple',
+                placeholder: data.props.placeholder,
+                immediateFetch: true,
+                unitStr: '个',
+                defaultSelected: data.value,
+                load() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        return yield extraConfig.department.fetch();
+                    });
+                },
+            },
+            effect: {
+                required: data.effect.required && '请选择',
+            },
+            col: {
+                span: fieldRatioMap[data.config.fieldRatio],
+            },
+            inject: true,
+            on: {
+                change(inject, list) {
+                    const rule = inject.self;
+                    rule.value = list;
+                    inject.api.validateField(rule.field, () => {
+                        if (list.length) {
+                            inject.api.clearValidateState(rule.field);
+                        }
+                    });
+                },
+            },
+        };
+    },
+    tableRule(data, extraConfig) {
+        const field = data.field;
+        return {
+            field,
+            title: data.title.title,
+            headerClassName: data.effect.required ? 'is-required' : '',
+            width: data.config.fieldRatio,
+            slots: {
+                default({ row }) {
+                    return vue.h(StaffSelector, Object.assign({ title: '添加部门', mode: data.props.limit ? 'radio' : 'multiple', placeholder: data.props.placeholder, immediateFetch: true, unitStr: '个', onChange: (value) => {
+                            row[field] = value;
+                        }, defaultSelected: row[field] }, extraConfig.department));
+                },
+            },
+        };
+    },
+};
+
+var table = {
+    name: 'table',
+    rule(data, extraConfig) {
+        return {
+            type: 'TableWidget',
+            component: TableWidget,
+            field: data.field,
+            props: {
+                rule: data,
+                extraConfig,
+            },
+            inject: true,
+            on: {
+                change(inject, value) {
+                    inject.self.value = value;
+                },
+            },
+        };
+    },
+    rowRule(data, extraConfig) {
+        return {
+            type: 'TableWidget',
+            component: TableWidget,
+            field: data.field,
+            props: {
+                rule: data,
+                extraConfig,
+            },
+            inject: true,
+            on: {
+                change(inject, value) {
+                    inject.self.value = value;
+                },
+            },
+            col: {
+                span: 24,
+            },
+        };
+    },
+};
+
+var ruleList = {
+    [input.name]: input,
+    [textarea.name]: textarea,
+    [numInput.name]: numInput,
+    [radio.name]: radio,
+    [checkbox.name]: checkbox,
+    [date.name]: date,
+    [dateRange.name]: dateRange,
+    [instruction.name]: instruction,
+    [picture.name]: picture,
+    [file.name]: file,
+    [people.name]: people,
+    [department.name]: department,
+    [materialTemp.name]: materialTemp,
+    [product.name]: product,
+    [shop.name]: shop,
+    [materialType.name]: materialType,
+    [row.name]: row,
+    [table.name]: table,
+};
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "form-create",
+  props: ["fdRule", "extraConfig", "value"],
+  emits: ["update:value"],
+  setup(__props, { expose, emit: emits }) {
+    const props = __props;
+    const option = {
+      wrap: {
+        labelCol: {
+          flex: "0 0 127px"
+        },
+        wrapperCol: {
+          span: 24
+        }
+      },
+      submitBtn: false
+    };
+    const fApi = vue.ref();
+    const rule = vue.ref([]);
+    function setRule(fdRule) {
+      fdRule = getRuleData(fdRule);
+      rule.value = fdRule.map((data) => {
+        const childRules = data?.config?.childRules;
+        const rule2 = ruleList[data.name].rule(data, props.extraConfig);
+        if (data.name === "row" && childRules?.length) {
+          const rowRule = rule2.children.find((item) => item.type === "row");
+          childRules.forEach((ruleItem) => {
+            rowRule.children.push(
+              ruleList[ruleItem.name].rowRule(ruleItem, props.extraConfig)
+            );
+          });
+        }
+        return rule2;
+      });
+    }
+    function handleValue(value) {
+      emits("update:value", value);
+    }
+    function getRuleData(fdRule) {
+      const ruleData = lodashEs.cloneDeep(fdRule);
+      ruleData.forEach((rule2) => {
+        if (rule2.name === "row") {
+          rule2.config.childRules?.forEach((item) => {
+            item.value = props.value[item.field];
+          });
+        }
+        rule2.value = props.value[rule2.field];
+      });
+      return ruleData;
+    }
+    vue.watch(
+      () => props.fdRule,
+      (fdRule) => {
+        setRule(fdRule);
+      },
+      {
+        immediate: true
+      }
+    );
+    expose({ fApi });
+    return (_ctx, _cache) => {
+      const _component_formCreate = vue.resolveComponent("formCreate", true);
+      return vue.openBlock(), vue.createBlock(_component_formCreate, {
+        api: fApi.value,
+        "onUpdate:api": _cache[0] || (_cache[0] = ($event) => fApi.value = $event),
+        "model-value": __props.value,
+        option,
+        rule: rule.value,
+        "onUpdate:modelValue": handleValue
+      }, null, 8, ["api", "model-value", "rule"]);
+    };
+  }
+});
+var FormCreate = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "form-create.vue"]]);
+
+const BmFormCreate = withInstall.withInstall(FormCreate);
+
+exports.BmFormCreate = BmFormCreate;
+exports["default"] = BmFormCreate;