@kp-ui/lowcode 1.0.25 → 1.0.26

package/src/components/form-render/container-item/grid-sub-form-item.vue.js

@@ -1,31 +1,31 @@
-import v from "../../../utils/emitter.js";
-import I from "../../../utils/i18n.js";
-import { deepClone as F, generateId as m, traverseFieldWidgetsOfContainer as T } from "../../../utils/util.js";
-import y from "../refMixin.js";
-import A from "./container-item-wrapper.vue.js";
-import M from "./containerItemMixin.js";
-import E from "../../form-designer/form-widget/field-widget/index.js";
-import { TpfConfirm as B } from "../../../hooks/TpfConfirm.js";
+import emitter from "../../../utils/emitter.js";
+import i18n from "../../../utils/i18n.js";
+import { deepClone, generateId, traverseFieldWidgetsOfContainer } from "../../../utils/util.js";
+import refMixin from "../refMixin.js";
+import ContainerItemWrapper from "./container-item-wrapper.vue.js";
+import containerItemMixin from "./containerItemMixin.js";
+import comps from "../../form-designer/form-widget/field-widget/index.js";
+import { TpfConfirm } from "../../../hooks/TpfConfirm.js";
 import "@ant-design/icons-vue";
-import N from "../../svg-icon/index.vue.js";
-import { resolveComponent as f, createBlock as p, openBlock as n, withCtx as l, withDirectives as S, createElementBlock as u, createElementVNode as r, Fragment as R, renderList as C, normalizeClass as _, createVNode as h, vShow as W, toDisplayString as L, resolveDynamicComponent as O, createCommentVNode as V, createTextVNode as H } from "vue";
+import SvgIcon from "../../svg-icon/index.vue.js";
+import { resolveComponent, createBlock, openBlock, withCtx, withDirectives, createElementBlock, createElementVNode, Fragment, renderList, normalizeClass, createVNode, vShow, toDisplayString, resolveDynamicComponent, createCommentVNode, createTextVNode } from "vue";
 /* empty css                        */
-import j from "../../../../_virtual/_plugin-vue_export-helper.js";
-const x = {
+import _export_sfc from "../../../../_virtual/_plugin-vue_export-helper.js";
+const _sfc_main = {
   name: "grid-sub-form-item",
   componentName: "ContainerItem",
-  mixins: [v, I, y, M],
+  mixins: [emitter, i18n, refMixin, containerItemMixin],
   components: {
-    SvgIcon: N,
-    ContainerItemWrapper: A,
-    ...E
+    SvgIcon,
+    ContainerItemWrapper,
+    ...comps
   },
   props: {
     widget: Object
   },
   provide() {
     return {
-      getSubFormFieldFlag: () => !0,
+      getSubFormFieldFlag: () => true,
       getSubFormName: () => this.widget.options.name
     };
   },
@@ -34,10 +34,10 @@ const x = {
     return {
       rowIdData: [],
       widgetSchemaData: [],
-      actionDisabled: !1,
-      insertDisabled: !1,
+      actionDisabled: false,
+      insertDisabled: false,
       //是否禁止新增、插入记录
-      deleteDisabled: !1,
+      deleteDisabled: false,
       //是否禁止删除记录
       fieldWidgetList: []
     };
@@ -47,14 +47,19 @@ const x = {
       return this.getReadMode();
     },
     actionBtnsClass() {
-      return this.widget.options.actionColumnPosition, "right-action-column";
+      return this.widget.options.actionColumnPosition || true ? "right-action-column" : "left-action-column";
     }
   },
   created() {
-    this.initRefList(), this.registerSubFormToRefList(), this.initRowIdData(!0), this.initWidgetSchemaData(), this.initEventHandler();
+    this.initRefList();
+    this.registerSubFormToRefList();
+    this.initRowIdData(true);
+    this.initWidgetSchemaData();
+    this.initEventHandler();
   },
   mounted() {
-    this.extractFieldWidgetList(), this.handleSubFormFirstRowAdd();
+    this.extractFieldWidgetList();
+    this.handleSubFormFirstRowAdd();
   },
   beforeUnmount() {
     this.unregisterFromRefList();
@@ -62,253 +67,321 @@ const x = {
   methods: {
     extractFieldWidgetList() {
       this.fieldWidgetList.splice(0, this.fieldWidgetList.length);
-      const t = (e) => {
-        this.fieldWidgetList.push(e);
+      const fieldListFn = (fw) => {
+        this.fieldWidgetList.push(fw);
       };
-      T(this.widget, t);
+      traverseFieldWidgetsOfContainer(this.widget, fieldListFn);
     },
-    getLabelAlign(t, e) {
-      return e.options.labelAlign || t.options.labelAlign;
+    getLabelAlign(widget, subWidget) {
+      return subWidget.options.labelAlign || widget.options.labelAlign;
     },
     registerSubFormToRefList() {
-      this.widget.type === "grid-sub-form" && (this.sfRefList[this.widget.options.name] = this);
+      if (this.widget.type === "grid-sub-form") {
+        this.sfRefList[this.widget.options.name] = this;
+      }
     },
-    initRowIdData(t) {
+    initRowIdData(initFlag) {
       if (this.widget.type === "grid-sub-form") {
         this.rowIdData.splice(0, this.rowIdData.length);
-        const e = this.formModel[this.widget.options.name];
-        e && e.length > 0 && (e.forEach(() => {
-          this.rowIdData.push("id" + m());
-        }), t && setTimeout(() => {
-          this.handleSubFormRowChange(e);
-        }, 800));
+        const subFormModel = this.formModel[this.widget.options.name];
+        if (!!subFormModel && subFormModel.length > 0) {
+          subFormModel.forEach(() => {
+            this.rowIdData.push("id" + generateId());
+          });
+          if (!!initFlag) {
+            setTimeout(() => {
+              this.handleSubFormRowChange(subFormModel);
+            }, 800);
+          }
+        }
       }
     },
     addToRowIdData() {
-      this.rowIdData.push("id" + m());
+      this.rowIdData.push("id" + generateId());
     },
-    insertToRowIdData(t) {
-      this.rowIdData.splice(t, 0, "id" + m());
+    insertToRowIdData(rowIndex) {
+      this.rowIdData.splice(rowIndex, 0, "id" + generateId());
     },
-    deleteFromRowIdData(t) {
-      this.rowIdData.splice(t, 1);
+    deleteFromRowIdData(rowIndex) {
+      this.rowIdData.splice(rowIndex, 1);
     },
     getRowIdData() {
       return this.rowIdData;
     },
-    getWidgetRefOfSubForm(t, e) {
-      const i = t + "@row" + this.rowIdData[e];
-      return this.getWidgetRef(i);
+    getWidgetRefOfSubForm(widgetName, rowIndex) {
+      const realWidgetName = widgetName + "@row" + this.rowIdData[rowIndex];
+      return this.getWidgetRef(realWidgetName);
     },
     initWidgetSchemaData() {
-      if (this.widget.type !== "grid-sub-form")
+      if (this.widget.type !== "grid-sub-form") {
         return;
-      const t = this.rowIdData.length;
-      if (this.widgetSchemaData.splice(0, this.widgetSchemaData.length), t > 0)
-        for (let e = 0; e < t; e++) {
-          const i = [];
-          this.widget.widgetList.forEach((a) => {
-            i.push(this.cloneSchemaOfWidget(a));
-          }), this.widgetSchemaData.push(i);
+      }
+      const rowLength = this.rowIdData.length;
+      this.widgetSchemaData.splice(0, this.widgetSchemaData.length);
+      if (rowLength > 0) {
+        for (let i = 0; i < rowLength; i++) {
+          const widgetSchemas = [];
+          this.widget.widgetList.forEach((swItem) => {
+            widgetSchemas.push(this.cloneSchemaOfWidget(swItem));
+          });
+          this.widgetSchemaData.push(widgetSchemas);
         }
+      }
     },
-    addToWidgetSchemaData(t) {
-      const e = [];
-      this.widget.widgetList.forEach((i) => {
-        e.push(this.cloneSchemaOfWidget(i));
-      }), t === void 0 ? this.widgetSchemaData.push(e) : this.widgetSchemaData.splice(t, 0, e);
+    addToWidgetSchemaData(rowIndex) {
+      const widgetSchemas = [];
+      this.widget.widgetList.forEach((swItem) => {
+        widgetSchemas.push(this.cloneSchemaOfWidget(swItem));
+      });
+      if (rowIndex === void 0) {
+        this.widgetSchemaData.push(widgetSchemas);
+      } else {
+        this.widgetSchemaData.splice(rowIndex, 0, widgetSchemas);
+      }
     },
-    deleteFromWidgetSchemaData(t) {
-      this.widgetSchemaData.splice(t, 1);
+    deleteFromWidgetSchemaData(rowIndex) {
+      this.widgetSchemaData.splice(rowIndex, 1);
     },
-    cloneSchemaOfWidget(t) {
-      const e = F(t);
-      return e.id = t.type + m(), e;
+    cloneSchemaOfWidget(widget) {
+      const newWidgetSchema = deepClone(widget);
+      newWidgetSchema.id = widget.type + generateId();
+      return newWidgetSchema;
     },
     initEventHandler() {
-      this.widget.type === "grid-sub-form" && this.on$("setFormData", (t) => {
-        this.initRowIdData(!1), this.initWidgetSchemaData();
-        const e = t[this.widget.options.name] || [];
+      if (this.widget.type !== "grid-sub-form") {
+        return;
+      }
+      this.on$("setFormData", (newFormData) => {
+        this.initRowIdData(false);
+        this.initWidgetSchemaData();
+        const subFormData = newFormData[this.widget.options.name] || [];
         setTimeout(() => {
-          this.handleSubFormRowChange(e);
+          this.handleSubFormRowChange(subFormData);
         }, 800);
       });
     },
     handleSubFormFirstRowAdd() {
-      if (this.widget.type === "grid-sub-form" && this.widget.options.showBlankRow && this.rowIdData.length === 1) {
-        const t = this.formModel[this.widget.options.name] || [];
+      if (this.widget.type !== "grid-sub-form") {
+        return;
+      }
+      if (!!this.widget.options.showBlankRow && this.rowIdData.length === 1) {
+        const oldSubFormData = this.formModel[this.widget.options.name] || [];
         this.$nextTick(() => {
-          this.handleSubFormRowAdd(t, this.rowIdData[0]), this.handleSubFormRowChange(t);
+          this.handleSubFormRowAdd(oldSubFormData, this.rowIdData[0]);
+          this.handleSubFormRowChange(oldSubFormData);
         });
       }
     },
     addSubFormRow() {
-      const t = {};
-      this.fieldWidgetList.forEach((i) => {
-        i.formItemFlag && (t[i.options.name] = i.options.defaultValue);
+      const newSubFormDataRow = {};
+      this.fieldWidgetList.forEach((subFormItem) => {
+        if (!!subFormItem.formItemFlag) {
+          newSubFormDataRow[subFormItem.options.name] = subFormItem.options.defaultValue;
+        }
       });
-      const e = this.formModel[this.widget.options.name] || [];
-      e.push(t), this.addToRowIdData(), this.addToWidgetSchemaData(), this.$nextTick(() => {
-        this.handleSubFormRowAdd(e, this.rowIdData[e.length - 1]), this.handleSubFormRowChange(e);
+      const oldSubFormData = this.formModel[this.widget.options.name] || [];
+      oldSubFormData.push(newSubFormDataRow);
+      this.addToRowIdData();
+      this.addToWidgetSchemaData();
+      this.$nextTick(() => {
+        this.handleSubFormRowAdd(oldSubFormData, this.rowIdData[oldSubFormData.length - 1]);
+        this.handleSubFormRowChange(oldSubFormData);
       });
     },
-    insertSubFormRow(t) {
-      const e = {};
-      this.fieldWidgetList.forEach((a) => {
-        a.formItemFlag && (e[a.options.name] = a.options.defaultValue);
+    insertSubFormRow(beforeFormRowIndex) {
+      const newSubFormDataRow = {};
+      this.fieldWidgetList.forEach((subFormItem) => {
+        if (!!subFormItem.formItemFlag) {
+          newSubFormDataRow[subFormItem.options.name] = subFormItem.options.defaultValue;
+        }
       });
-      const i = this.formModel[this.widget.options.name] || [];
-      i.splice(t, 0, e), this.insertToRowIdData(t), this.addToWidgetSchemaData(t), this.$nextTick(() => {
-        this.handleSubFormRowInsert(i, this.rowIdData[t]), this.handleSubFormRowChange(i);
+      const oldSubFormData = this.formModel[this.widget.options.name] || [];
+      oldSubFormData.splice(beforeFormRowIndex, 0, newSubFormDataRow);
+      this.insertToRowIdData(beforeFormRowIndex);
+      this.addToWidgetSchemaData(beforeFormRowIndex);
+      this.$nextTick(() => {
+        this.handleSubFormRowInsert(oldSubFormData, this.rowIdData[beforeFormRowIndex]);
+        this.handleSubFormRowChange(oldSubFormData);
       });
     },
-    deleteSubFormRow(t) {
-      B({
+    deleteSubFormRow(formRowIndex) {
+      TpfConfirm({
         type: "confirm",
         content: this.i18nt("render.hint.deleteSubFormRow") + "?",
         title: this.i18nt("render.hint.prompt"),
         okText: this.i18nt("render.hint.confirm"),
         cancelText: this.i18nt("render.hint.cancel")
       }).then(() => {
-        const e = this.formModel[this.widget.options.name] || [], i = F(e[t]);
-        e.splice(t, 1), this.deleteFromRowIdData(t), this.deleteFromWidgetSchemaData(t), this.$nextTick(() => {
-          this.handleSubFormRowDelete(e, i), this.handleSubFormRowChange(e);
+        const oldSubFormData = this.formModel[this.widget.options.name] || [];
+        const deletedDataRow = deepClone(oldSubFormData[formRowIndex]);
+        oldSubFormData.splice(formRowIndex, 1);
+        this.deleteFromRowIdData(formRowIndex);
+        this.deleteFromWidgetSchemaData(formRowIndex);
+        this.$nextTick(() => {
+          this.handleSubFormRowDelete(oldSubFormData, deletedDataRow);
+          this.handleSubFormRowChange(oldSubFormData);
         });
       }).catch(() => {
       });
     },
-    handleSubFormRowChange(t) {
-      this.widget.options.onSubFormRowChange && new Function("subFormData", this.widget.options.onSubFormRowChange).call(this, t);
+    handleSubFormRowChange(subFormData) {
+      if (!!this.widget.options.onSubFormRowChange) {
+        const customFunc = new Function("subFormData", this.widget.options.onSubFormRowChange);
+        customFunc.call(this, subFormData);
+      }
     },
-    handleSubFormRowAdd(t, e) {
-      this.widget.options.onSubFormRowAdd && new Function(
-        "subFormData",
-        "newRowId",
-        this.widget.options.onSubFormRowAdd
-      ).call(this, t, e);
+    handleSubFormRowAdd(subFormData, newRowId) {
+      if (!!this.widget.options.onSubFormRowAdd) {
+        const customFunc = new Function(
+          "subFormData",
+          "newRowId",
+          this.widget.options.onSubFormRowAdd
+        );
+        customFunc.call(this, subFormData, newRowId);
+      }
     },
-    handleSubFormRowInsert(t, e) {
-      this.widget.options.onSubFormRowInsert && new Function(
-        "subFormData",
-        "newRowId",
-        this.widget.options.onSubFormRowInsert
-      ).call(this, t, e);
+    handleSubFormRowInsert(subFormData, newRowId) {
+      if (!!this.widget.options.onSubFormRowInsert) {
+        const customFunc = new Function(
+          "subFormData",
+          "newRowId",
+          this.widget.options.onSubFormRowInsert
+        );
+        customFunc.call(this, subFormData, newRowId);
+      }
     },
-    handleSubFormRowDelete(t, e) {
-      this.widget.options.onSubFormRowDelete && new Function(
-        "subFormData",
-        "deletedDataRow",
-        this.widget.options.onSubFormRowDelete
-      ).call(this, t, e);
+    handleSubFormRowDelete(subFormData, deletedDataRow) {
+      if (!!this.widget.options.onSubFormRowDelete) {
+        const customFunc = new Function(
+          "subFormData",
+          "deletedDataRow",
+          this.widget.options.onSubFormRowDelete
+        );
+        customFunc.call(this, subFormData, deletedDataRow);
+      }
     },
-    setDisabled(t) {
-      t ? this.disableGridSubForm() : this.enableGridSubForm();
+    setDisabled(flag) {
+      if (!!flag) {
+        this.disableGridSubForm();
+      } else {
+        this.enableGridSubForm();
+      }
     },
     /**
      * 设置单行子表单是否禁止新增、插入记录
      * @param flag
      */
-    setInsertDisabled(t) {
-      this.insertDisabled = t;
+    setInsertDisabled(flag) {
+      this.insertDisabled = flag;
     },
     /**
      * 设置单行子表单是否禁止删除记录
      * @param flag
      */
-    setDeleteDisabled(t) {
-      this.deleteDisabled = t;
+    setDeleteDisabled(flag) {
+      this.deleteDisabled = flag;
     }
   }
-}, z = { class: "row-no-column" }, G = { class: "row-number-span" }, P = { class: "grid-sub-form-data-row" }, U = { class: "header-row" };
-function q(t, e, i, a, o, s) {
-  const w = f("svg-icon"), g = f("a-button"), k = f("container-item-wrapper");
-  return n(), p(k, { widget: i.widget }, {
-    default: l(() => [
-      S((n(), u("div", {
-        key: i.widget.id,
+};
+const _hoisted_1 = { class: "row-no-column" };
+const _hoisted_2 = { class: "row-number-span" };
+const _hoisted_3 = { class: "grid-sub-form-data-row" };
+const _hoisted_4 = { class: "header-row" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_svg_icon = resolveComponent("svg-icon");
+  const _component_a_button = resolveComponent("a-button");
+  const _component_container_item_wrapper = resolveComponent("container-item-wrapper");
+  return openBlock(), createBlock(_component_container_item_wrapper, { widget: $props.widget }, {
+    default: withCtx(() => [
+      withDirectives((openBlock(), createElementBlock("div", {
+        key: $props.widget.id,
         class: "sub-form-container"
       }, [
-        (n(!0), u(R, null, C(o.rowIdData, (D, d) => (n(), u("div", {
-          class: "sub-form-row",
-          key: D
-        }, [
-          r("div", {
-            class: _(["sub-form-action-column hide-label", s.actionBtnsClass])
+        (openBlock(true), createElementBlock(Fragment, null, renderList($data.rowIdData, (subFormRowId, sfrIdx) => {
+          return openBlock(), createElementBlock("div", {
+            class: "sub-form-row",
+            key: subFormRowId
           }, [
-            S(r("div", {
-              class: _(["action-button-column", s.actionBtnsClass])
+            createElementVNode("div", {
+              class: normalizeClass(["sub-form-action-column hide-label", $options.actionBtnsClass])
             }, [
-              h(g, {
-                type: "link",
-                title: t.i18nt("render.hint.insertSubFormRow"),
-                disabled: o.actionDisabled || o.deleteDisabled,
-                onClick: (b) => s.insertSubFormRow(d)
-              }, {
-                icon: l(() => [
-                  h(w, { "icon-class": "el-plus" })
-                ]),
-                _: 2
-              }, 1032, ["title", "disabled", "onClick"]),
-              h(g, {
-                type: "link",
-                title: t.i18nt("render.hint.deleteSubFormRow"),
-                disabled: o.actionDisabled || o.deleteDisabled,
-                onClick: (b) => s.deleteSubFormRow(d)
-              }, {
-                icon: l(() => [
-                  h(w, { "icon-class": "el-delete" })
-                ]),
-                _: 2
-              }, 1032, ["title", "disabled", "onClick"])
-            ], 2), [
-              [W, !s.isReadMode]
+              withDirectives(createElementVNode("div", {
+                class: normalizeClass(["action-button-column", $options.actionBtnsClass])
+              }, [
+                createVNode(_component_a_button, {
+                  type: "link",
+                  title: _ctx.i18nt("render.hint.insertSubFormRow"),
+                  disabled: $data.actionDisabled || $data.deleteDisabled,
+                  onClick: ($event) => $options.insertSubFormRow(sfrIdx)
+                }, {
+                  icon: withCtx(() => [
+                    createVNode(_component_svg_icon, { "icon-class": "el-plus" })
+                  ]),
+                  _: 2
+                }, 1032, ["title", "disabled", "onClick"]),
+                createVNode(_component_a_button, {
+                  type: "link",
+                  title: _ctx.i18nt("render.hint.deleteSubFormRow"),
+                  disabled: $data.actionDisabled || $data.deleteDisabled,
+                  onClick: ($event) => $options.deleteSubFormRow(sfrIdx)
+                }, {
+                  icon: withCtx(() => [
+                    createVNode(_component_svg_icon, { "icon-class": "el-delete" })
+                  ]),
+                  _: 2
+                }, 1032, ["title", "disabled", "onClick"])
+              ], 2), [
+                [vShow, !$options.isReadMode]
+              ])
+            ], 2),
+            createElementVNode("div", _hoisted_1, [
+              createElementVNode("span", _hoisted_2, "#" + toDisplayString(sfrIdx + 1), 1)
+            ]),
+            createElementVNode("div", _hoisted_3, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList($props.widget.widgetList, (subWidget, swIdx) => {
+                return openBlock(), createBlock(resolveDynamicComponent(_ctx.getComponentByContainer(subWidget)), {
+                  key: $data.widgetSchemaData[sfrIdx][swIdx].id,
+                  widget: $data.widgetSchemaData[sfrIdx][swIdx],
+                  "parent-list": $props.widget.widgetList,
+                  "index-of-parent-list": swIdx,
+                  "parent-widget": $props.widget,
+                  "sub-form-row-id": subFormRowId,
+                  "sub-form-row-index": sfrIdx,
+                  "sub-form-col-index": swIdx
+                }, null, 8, ["widget", "parent-list", "index-of-parent-list", "parent-widget", "sub-form-row-id", "sub-form-row-index", "sub-form-col-index"]);
+              }), 128))
             ])
-          ], 2),
-          r("div", z, [
-            r("span", G, "#" + L(d + 1), 1)
-          ]),
-          r("div", P, [
-            (n(!0), u(R, null, C(i.widget.widgetList, (b, c) => (n(), p(O(t.getComponentByContainer(b)), {
-              key: o.widgetSchemaData[d][c].id,
-              widget: o.widgetSchemaData[d][c],
-              "parent-list": i.widget.widgetList,
-              "index-of-parent-list": c,
-              "parent-widget": i.widget,
-              "sub-form-row-id": D,
-              "sub-form-row-index": d,
-              "sub-form-col-index": c
-            }, null, 8, ["widget", "parent-list", "index-of-parent-list", "parent-widget", "sub-form-row-id", "sub-form-row-index", "sub-form-col-index"]))), 128))
-          ])
-        ]))), 128)),
-        r("div", U, [
-          s.isReadMode ? V("", !0) : (n(), p(g, {
+          ]);
+        }), 128)),
+        createElementVNode("div", _hoisted_4, [
+          !$options.isReadMode ? (openBlock(), createBlock(_component_a_button, {
             key: 0,
             block: "",
-            disabled: o.actionDisabled || o.insertDisabled,
+            disabled: $data.actionDisabled || $data.insertDisabled,
             shape: "round",
             type: "dashed",
             size: "small",
             class: "action-button",
-            onClick: s.addSubFormRow,
-            title: t.i18nt("render.hint.subFormAddActionHint")
+            onClick: $options.addSubFormRow,
+            title: _ctx.i18nt("render.hint.subFormAddActionHint")
           }, {
-            icon: l(() => [
-              h(w, { "icon-class": "el-plus" })
+            icon: withCtx(() => [
+              createVNode(_component_svg_icon, { "icon-class": "el-plus" })
             ]),
-            default: l(() => [
-              H(" " + L(t.i18nt("render.hint.subFormAddAction")), 1)
+            default: withCtx(() => [
+              createTextVNode(" " + toDisplayString(_ctx.i18nt("render.hint.subFormAddAction")), 1)
             ]),
             _: 1
-          }, 8, ["disabled", "onClick", "title"]))
+          }, 8, ["disabled", "onClick", "title"])) : createCommentVNode("", true)
         ])
       ])), [
-        [W, !i.widget.options.hidden]
+        [vShow, !$props.widget.options.hidden]
       ])
     ]),
     _: 1
   }, 8, ["widget"]);
 }
-const at = /* @__PURE__ */ j(x, [["render", q], ["__scopeId", "data-v-8ecf8547"]]);
+const gridSubFormItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-8ecf8547"]]);
 export {
-  at as default
+  gridSubFormItem as default
 };

package/src/components/form-render/container-item/index.js

@@ -1,23 +1,24 @@
-import * as o from "./container-item-wrapper.vue.js";
-import * as a from "./data-table-item.vue.js";
-import * as i from "./grid-col-item.vue.js";
-import * as s from "./grid-item.vue.js";
-import * as f from "./grid-sub-form-item.vue.js";
-import * as l from "./sub-form-item.vue.js";
-import * as p from "./tab-item.vue.js";
-import * as u from "./table-cell-item.vue.js";
-import * as v from "./table-item.vue2.js";
-import * as n from "./vf-collapse-item.vue.js";
-import * as d from "./vf-dialog-item.vue.js";
-import * as b from "./vf-drawer-item.vue.js";
-const e = /* @__PURE__ */ Object.assign({ "./container-item-wrapper.vue": o, "./data-table-item.vue": a, "./grid-col-item.vue": i, "./grid-item.vue": s, "./grid-sub-form-item.vue": f, "./sub-form-item.vue": l, "./tab-item.vue": p, "./table-cell-item.vue": u, "./table-item.vue": v, "./vf-collapse-item.vue": n, "./vf-dialog-item.vue": d, "./vf-drawer-item.vue": b }), I = {
-  install(m) {
-    for (const t in e) {
-      const r = e[t].default.name;
-      m.component(r, e[t].default);
+import * as containerItemWrapper from "./container-item-wrapper.vue.js";
+import * as dataTableItem from "./data-table-item.vue.js";
+import * as gridColItem from "./grid-col-item.vue.js";
+import * as gridItem from "./grid-item.vue.js";
+import * as gridSubFormItem from "./grid-sub-form-item.vue.js";
+import * as subFormItem from "./sub-form-item.vue.js";
+import * as tabItem from "./tab-item.vue.js";
+import * as tableCellItem from "./table-cell-item.vue.js";
+import * as tableItem from "./table-item.vue2.js";
+import * as vfCollapseItem from "./vf-collapse-item.vue.js";
+import * as vfDialogItem from "./vf-dialog-item.vue.js";
+import * as vfDrawerItem from "./vf-drawer-item.vue.js";
+const modules = /* @__PURE__ */ Object.assign({ "./container-item-wrapper.vue": containerItemWrapper, "./data-table-item.vue": dataTableItem, "./grid-col-item.vue": gridColItem, "./grid-item.vue": gridItem, "./grid-sub-form-item.vue": gridSubFormItem, "./sub-form-item.vue": subFormItem, "./tab-item.vue": tabItem, "./table-cell-item.vue": tableCellItem, "./table-item.vue": tableItem, "./vf-collapse-item.vue": vfCollapseItem, "./vf-dialog-item.vue": vfDialogItem, "./vf-drawer-item.vue": vfDrawerItem });
+const ContainerItems = {
+  install(app) {
+    for (const path in modules) {
+      const cname = modules[path].default.name;
+      app.component(cname, modules[path].default);
     }
   }
 };
 export {
-  I as default
+  ContainerItems as default
 };