@ibiz-template/vue3-components 0.4.8-dev.0 → 0.4.9

package/lib/control/tree/tree.cjs

@@ -0,0 +1,407 @@
+'use strict';
+
+var vue = require('vue');
+var vue3Util = require('@ibiz-template/vue3-util');
+var qxUtil = require('qx-util');
+var lodashEs = require('lodash-es');
+var runtime = require('@ibiz-template/runtime');
+require('./tree.css');
+var core = require('@ibiz-template/core');
+var elTreeUtil = require('./el-tree-util.cjs');
+
+"use strict";
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+}
+const TreeControl = /* @__PURE__ */ vue.defineComponent({
+  name: "IBizTreeControl",
+  props: {
+    modelData: {
+      type: Object,
+      required: true
+    },
+    context: {
+      type: Object,
+      required: true
+    },
+    params: {
+      type: Object,
+      default: () => ({})
+    },
+    provider: {
+      type: Object
+    },
+    /**
+     * 部件行数据默认激活模式
+     * - 0 不激活
+     * - 1 单击激活
+     * - 2 双击激活(默认值)
+     *
+     * @type {(number | 0 | 1 | 2)}
+     */
+    mdctrlActiveMode: {
+      type: Number,
+      default: void 0
+    },
+    /**
+     * 是否为单选
+     * - true 单选
+     * - false 多选
+     *
+     * @type {(Boolean)}
+     */
+    singleSelect: {
+      type: Boolean,
+      default: void 0
+    },
+    navigational: {
+      type: Boolean,
+      default: void 0
+    },
+    defaultExpandedKeys: {
+      type: Array
+    },
+    loadDefault: {
+      type: Boolean,
+      default: true
+    }
+  },
+  setup() {
+    const c = vue3Util.useControlController((...args) => new runtime.TreeController(...args));
+    const ns = vue3Util.useNamespace(`control-${c.model.controlType.toLowerCase()}`);
+    const treeRef = vue.ref(null);
+    const {
+      updateUI,
+      triggerNodeExpand
+    } = elTreeUtil.useElTreeUtil(treeRef, c);
+    const toElNodes = (nodes) => {
+      return nodes.map((node) => ({
+        id: node.id,
+        leaf: node.leaf
+      }));
+    };
+    c.evt.on("onAfterRefreshParent", (event) => {
+      if (treeRef.value) {
+        const {
+          parentNode,
+          children
+        } = event;
+        treeRef.value.updateKeyChildren(parentNode.id, toElNodes(children));
+        updateUI();
+      }
+    });
+    const treeData = vue.computed(() => {
+      if (!c.state.isLoaded) {
+        return [];
+      }
+      return c.model.rootVisible ? c.state.rootNodes : c.state.rootNodes.reduce((result, nodeData) => {
+        if (nodeData.children) {
+          return result.concat(nodeData.children);
+        }
+        return result;
+      }, []);
+    });
+    const treeRefreshKey = vue.ref("");
+    vue.watch(treeData, (newVal, oldVal) => {
+      if (newVal !== oldVal) {
+        treeRefreshKey.value = qxUtil.createUUID();
+      }
+    });
+    const loadData = async (item, callback) => {
+      let nodes;
+      if (item.level === 0) {
+        nodes = treeData.value;
+        ibiz.log.debug("\u521D\u59CB\u52A0\u8F7D");
+      } else {
+        const nodeData = elTreeUtil.findNodeData(item.data.id, c);
+        if (nodeData.children) {
+          ibiz.log.debug("\u8282\u70B9\u5C55\u5F00\u52A0\u8F7D-\u672C\u5730", nodeData);
+          nodes = nodeData.children;
+        } else {
+          ibiz.log.debug("\u8282\u70B9\u5C55\u5F00\u52A0\u8F7D-\u8FDC\u7A0B", nodeData);
+          nodes = await c.loadNodes(nodeData);
+        }
+      }
+      ibiz.log.debug("\u7ED9\u6811\u8FD4\u56DE\u503C", nodes);
+      callback(toElNodes(nodes));
+      updateUI();
+    };
+    let selectionWait = false;
+    c.evt.on("onLoadSuccess", () => {
+      selectionWait = true;
+      setTimeout(() => {
+        selectionWait = false;
+      }, 200);
+    });
+    c.evt.on("onSelectionChange", async () => {
+      var _a;
+      if (selectionWait) {
+        await vue.nextTick();
+      }
+      if (c.state.singleSelect) {
+        treeRef.value.setCurrentKey(((_a = c.state.selectedData[0]) == null ? void 0 : _a.id) || null);
+      } else {
+        treeRef.value.setCheckedKeys(c.state.selectedData.map((item) => item.id));
+      }
+    });
+    const onCheck = (nodeData, opts) => {
+      const {
+        checkedNodes
+      } = opts;
+      c.setSelection(checkedNodes);
+    };
+    let forbidClick = false;
+    const onNodeClick = (nodeData, evt) => {
+      evt.stopPropagation();
+      if (forbidClick) {
+        return;
+      }
+      if (c.state.navigational) {
+        const nodeModel = c.getNodeModel(nodeData.nodeId);
+        if (!(nodeModel == null ? void 0 : nodeModel.navAppViewId)) {
+          const expanded = triggerNodeExpand(nodeData.id);
+          c.onExpandChange(nodeData, expanded);
+          return;
+        }
+      }
+      c.onTreeNodeClick(nodeData);
+      forbidClick = true;
+      setTimeout(() => {
+        forbidClick = false;
+      }, 200);
+    };
+    const onNodeDbClick = (nodeData, evt) => {
+      evt.stopPropagation();
+      c.onDbTreeNodeClick(nodeData);
+    };
+    let ContextMenu;
+    c.evt.on("onMounted", () => {
+      if (Object.values(c.contextMenus).length > 0) {
+        const importMenu = () => import('@imengyu/vue3-context-menu');
+        importMenu().then((value) => {
+          ContextMenu = value.default;
+          if (ContextMenu.default && !ContextMenu.showContextMenu) {
+            ContextMenu = ContextMenu.default;
+          }
+        });
+      }
+    });
+    const iBizRawItem = vue.resolveComponent("IBizRawItem");
+    const iBizIcon = vue.resolveComponent("IBizIcon");
+    const calcContextMenuItems = (toolbarItems, nodeData, evt, menuState) => {
+      const result = [];
+      toolbarItems.forEach((item) => {
+        var _a;
+        if (item.itemType === "SEPERATOR") {
+          result.push({
+            divided: "self"
+          });
+          return;
+        }
+        const buttonState = menuState[item.id];
+        if (buttonState && !buttonState.visible) {
+          return;
+        }
+        const menuItem = {};
+        if (item.showCaption && item.caption) {
+          menuItem.label = item.caption;
+        }
+        if (item.sysImage && item.showIcon) {
+          menuItem.icon = vue.createVNode(iBizIcon, {
+            "icon": item.sysImage
+          }, null);
+        }
+        if (item.itemType === "DEUIACTION") {
+          menuItem.disabled = buttonState.disabled;
+          menuItem.clickClose = true;
+          const {
+            uiactionId
+          } = item;
+          if (uiactionId) {
+            menuItem.onClick = () => {
+              c.doUIAction(uiactionId, nodeData, evt, item.appId);
+            };
+          }
+        } else if (item.itemType === "RAWITEM") {
+          const {
+            rawItem
+          } = item;
+          if (rawItem) {
+            menuItem.label = vue.createVNode(iBizRawItem, {
+              "rawItem": item
+            }, null);
+          }
+        } else if (item.itemType === "ITEMS") {
+          if ((_a = item.detoolbarItems) == null ? void 0 : _a.length) {
+            menuItem.children = calcContextMenuItems(item.detoolbarItems, nodeData, evt, menuState);
+          }
+        }
+        result.push(menuItem);
+      });
+      return result;
+    };
+    const onNodeContextmenu = async (nodeData, evt) => {
+      evt.preventDefault();
+      evt.stopPropagation();
+      const nodeModel = c.getNodeModel(nodeData.nodeId);
+      if (!(nodeModel == null ? void 0 : nodeModel.decontextMenu)) {
+        return;
+      }
+      const contextMenuC = c.contextMenus[nodeModel.decontextMenu.id];
+      if (!contextMenuC.model.detoolbarItems) {
+        return;
+      }
+      await contextMenuC.calcButtonState(nodeData.deData || (nodeData.srfkey ? nodeData : void 0), nodeModel.appDataEntityId);
+      const menuState = contextMenuC.state.buttonsState;
+      const menus = calcContextMenuItems(contextMenuC.model.detoolbarItems, nodeData, evt, menuState);
+      if (!menus.length) {
+        return;
+      }
+      ContextMenu.showContextMenu({
+        x: evt.x,
+        y: evt.y,
+        customClass: ns.b("context-menu"),
+        items: menus
+      });
+    };
+    const renderContextMenu = (nodeModel, nodeData) => {
+      var _a, _b;
+      if (!((_b = (_a = nodeModel == null ? void 0 : nodeModel.decontextMenu) == null ? void 0 : _a.detoolbarItems) == null ? void 0 : _b.length)) {
+        return;
+      }
+      return vue.createVNode("div", {
+        "class": ns.b("context-menu-trigger"),
+        "onClick": (evt) => onNodeContextmenu(nodeData, evt)
+      }, [vue.createVNode("ion-icon", {
+        "class": ns.be("context-menu-trigger", "caption-icon"),
+        "name": "ellipsis-horizontal"
+      }, null)]);
+    };
+    const updateNodeExpand = (data, expanded) => {
+      const nodeData = elTreeUtil.findNodeData(data.id, c);
+      if (!nodeData) {
+        throw new core.RuntimeError(`\u6CA1\u6709\u627E\u5230id\u4E3A${data.id}\u7684\u8282\u70B9`);
+      }
+      c.onExpandChange(nodeData, expanded);
+    };
+    const debounceSearch = lodashEs.debounce(() => {
+      c.load();
+    }, 500);
+    const onInput = (value) => {
+      c.state.query = value;
+      debounceSearch();
+    };
+    return {
+      c,
+      ns,
+      treeRef,
+      treeData,
+      treeRefreshKey,
+      findNodeData: elTreeUtil.findNodeData,
+      onCheck,
+      onNodeClick,
+      onNodeDbClick,
+      onNodeContextmenu,
+      loadData,
+      renderContextMenu,
+      updateNodeExpand,
+      onInput
+    };
+  },
+  render() {
+    const slots = {
+      searchbar: () => {
+        if (!this.c.enableQuickSearch) {
+          return null;
+        }
+        return vue.createVNode(vue.resolveComponent("el-input"), {
+          "model-value": this.c.state.query,
+          "class": [this.ns.b("quick-search"), this.ns.b("quick-search")],
+          "placeholder": this.c.state.placeHolder,
+          "onInput": this.onInput
+        }, {
+          prefix: () => {
+            return vue.createVNode("ion-icon", {
+              "class": this.ns.e("search-icon"),
+              "name": "search"
+            }, null);
+          }
+        });
+      }
+    };
+    const key = this.c.controlPanel ? "tree" : "default";
+    slots[key] = () => {
+      if (this.c.state.isLoaded && this.treeRefreshKey) {
+        return vue.createVNode(vue.resolveComponent("el-tree"), {
+          "ref": "treeRef",
+          "key": this.treeRefreshKey,
+          "node-key": "id",
+          "highlight-current": true,
+          "expand-on-click-node": false,
+          "auto-expand-parent": false,
+          "show-checkbox": !this.c.state.singleSelect,
+          "check-strictly": true,
+          "default-expanded-keys": this.c.state.expandedKeys,
+          "props": {
+            label: "text",
+            children: "children",
+            isLeaf: "leaf"
+          },
+          "lazy": true,
+          "load": this.loadData,
+          "onCheck": this.onCheck,
+          "onNodeExpand": (data) => {
+            this.updateNodeExpand(data, true);
+          },
+          "onNodeCollapse": (data) => {
+            this.updateNodeExpand(data, false);
+          }
+        }, {
+          default: ({
+            data
+          }) => {
+            var _a;
+            const nodeData = this.findNodeData(data.id, this.c);
+            if (!nodeData) {
+              return null;
+            }
+            const nodeModel = this.c.getNodeModel(nodeData.nodeId);
+            const layoutPanel = runtime.getControlPanel(nodeModel);
+            let content;
+            if (layoutPanel) {
+              content = vue.createVNode(vue.resolveComponent("iBizControlShell"), {
+                "data": nodeData,
+                "modelData": layoutPanel,
+                "context": this.c.context,
+                "params": this.c.params
+              }, null);
+            } else {
+              content = [nodeData.icon ? vue.createVNode(vue.resolveComponent("iBizIcon"), {
+                "class": this.ns.be("node", "icon"),
+                "icon": nodeData.icon
+              }, null) : null, nodeData.textHtml ? vue.createVNode("span", {
+                "class": this.ns.be("node", "label"),
+                "innerHTML": nodeData.textHtml
+              }, null) : vue.createVNode("span", {
+                "class": this.ns.be("node", "label")
+              }, [nodeData.text])];
+            }
+            return vue.createVNode("div", {
+              "onDblclick": (evt) => this.onNodeDbClick(nodeData, evt),
+              "onClick": (evt) => this.onNodeClick(nodeData, evt),
+              "onContextmenu": (evt) => this.onNodeContextmenu(nodeData, evt),
+              "class": [this.ns.b("node"), (_a = nodeModel.sysCss) == null ? void 0 : _a.cssName]
+            }, [content, this.renderContextMenu(nodeModel, nodeData)]);
+          }
+        });
+      }
+    };
+    return vue.withDirectives(vue.createVNode(vue.resolveComponent("iBizControlBase"), {
+      "controller": this.c
+    }, _isSlot(slots) ? slots : {
+      default: () => [slots]
+    }), [[vue.resolveDirective("loading"), this.c.state.isLoading]]);
+  }
+});
+
+exports.TreeControl = TreeControl;

package/lib/control/tree/tree.css

@@ -0,0 +1 @@
+.ibiz-control-treeview{--ibiz-control-treeview-padding:var(--ibiz-spacing-tight) var(--ibiz-spacing-base);height:100%;padding:var(--ibiz-control-treeview-padding)}.ibiz-control-treeview-node{display:flex;flex-grow:1;flex-shrink:1;align-items:center;min-width:1px;height:100%;line-height:26px}.ibiz-control-treeview-node__icon{min-width:var(--ibiz-spacing-base);margin-right:var(--ibiz-spacing-tight)}.ibiz-control-treeview-node__label{flex-grow:1;flex-shrink:1;min-width:1px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.ibiz-control-treeview-node:hover .ibiz-control-treeview-context-menu-trigger{display:inline-block}.ibiz-control-treeview-context-menu-trigger{display:none;flex-shrink:0;width:30px;text-align:center;cursor:pointer}.ibiz-control-treeview-context-menu-trigger__caption-icon{vertical-align:middle}.ibiz-control-treeview-context-menu.mx-context-menu{padding:var(--ibiz-spacing-extra-tight) 0}.ibiz-control-treeview-context-menu.mx-context-menu .mx-context-menu-item{padding:var(--ibiz-spacing-tight) var(--ibiz-spacing-base)}.ibiz-control-treeview-quick-search{margin-bottom:var(--ibiz-spacing-tight)}

package/lib/control/tree/tree.provider.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class TreeProvider {
+  constructor() {
+    __publicField(this, "component", "IBizTreeControl");
+  }
+}
+
+exports.TreeProvider = TreeProvider;

package/lib/control/tree-grid/index.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('@ibiz-template/runtime');
+var vue3Util = require('@ibiz-template/vue3-util');
+var treeGrid = require('./tree-grid.cjs');
+var treeGrid_provider = require('./tree-grid.provider.cjs');
+
+"use strict";
+const IBizTreeGridControl = vue3Util.withInstall(
+  treeGrid.TreeGridControl,
+  function(v) {
+    v.component(treeGrid.TreeGridControl.name, treeGrid.TreeGridControl);
+    runtime.registerControlProvider(runtime.ControlType.TREEGRID, () => new treeGrid_provider.TreeGridProvider());
+  }
+);
+
+exports.IBizTreeGridControl = IBizTreeGridControl;
+exports.default = IBizTreeGridControl;

package/lib/control/tree-grid/tree-grid.cjs

@@ -0,0 +1,214 @@
+'use strict';
+
+var vue = require('vue');
+var vue3Util = require('@ibiz-template/vue3-util');
+var runtime = require('@ibiz-template/runtime');
+var core = require('@ibiz-template/core');
+var useRowEditPopover = require('../grid/row-edit-popover/use-row-edit-popover.cjs');
+require('../grid/grid/index.cjs');
+var grid = require('../grid/grid/grid.cjs');
+var gridControl_util = require('../grid/grid/grid-control.util.cjs');
+
+"use strict";
+const TreeGridControl = /* @__PURE__ */ vue.defineComponent({
+  name: "IBizTreeGridControl",
+  props: {
+    modelData: {
+      type: Object,
+      required: true
+    },
+    context: {
+      type: Object,
+      required: true
+    },
+    params: {
+      type: Object,
+      default: () => ({})
+    },
+    provider: {
+      type: Object
+    },
+    /**
+     * 部件行数据默认激活模式
+     * - 0 不激活
+     * - 1 单击激活
+     * - 2 双击激活(默认值)
+     *
+     * @type {(number | 0 | 1 | 2)}
+     */
+    mdctrlActiveMode: {
+      type: Number,
+      default: void 0
+    },
+    singleSelect: {
+      type: Boolean,
+      default: void 0
+    },
+    rowEditOpen: {
+      type: Boolean,
+      default: void 0
+    },
+    isSimple: {
+      type: Boolean,
+      required: false
+    },
+    data: {
+      type: Array,
+      required: false
+    },
+    loadDefault: {
+      type: Boolean,
+      default: true
+    }
+  },
+  setup(props) {
+    const c = vue3Util.useControlController((...args) => new runtime.TreeGridController(...args));
+    const ns = vue3Util.useNamespace(`control-grid`);
+    const ns2 = vue3Util.useNamespace(`control-${c.model.controlType.toLowerCase()}`);
+    const {
+      tableRef,
+      onRowClick,
+      onDbRowClick,
+      onSelectionChange,
+      onSortChange,
+      handleRowClassName
+    } = gridControl_util.useITableEvent(c);
+    const {
+      onPageChange,
+      onPageRefresh,
+      onPageSizeChange
+    } = gridControl_util.useAppGridPagination(c);
+    const {
+      renderColumns,
+      defaultSort,
+      summaryMethod
+    } = gridControl_util.useAppGridBase(c, props);
+    const {
+      renderPopover
+    } = useRowEditPopover.useRowEditPopover(tableRef, c);
+    let treeGridValueField = "";
+    let treeGridParentField = "";
+    const initTreeGridField = () => {
+      var _a, _b;
+      const treeGridParent = (_a = c.model.degridColumns) == null ? void 0 : _a.find((item) => {
+        return item.treeColumnMode === 4 || item.treeColumnMode === 12;
+      });
+      const treeGridValue = (_b = c.model.degridColumns) == null ? void 0 : _b.find((item) => {
+        return item.treeColumnMode === 2 || item.treeColumnMode === 3;
+      });
+      if (!treeGridParent) {
+        throw new core.RuntimeModelError(c.model, "\u6811\u8868\u683C\u65E0\u503C\u5217\u6A21\u5F0F");
+      }
+      if (!treeGridValue) {
+        throw new core.RuntimeModelError(c.model, "\u6811\u8868\u683C\u65E0\u7236\u503C\u5217\u6A21\u5F0F");
+      }
+      treeGridValueField = treeGridValue.appDEFieldId.toLowerCase();
+      treeGridParentField = treeGridParent.appDEFieldId.toLowerCase();
+    };
+    initTreeGridField();
+    const getTreeGridDataItem = (data) => {
+      data.hasChildren = c.state.items.some((item) => data[treeGridValueField] === item[treeGridParentField]);
+      data.children = [];
+      return data;
+    };
+    const tableData = vue.computed(() => {
+      const state = c.state;
+      const items = state.rows.map((item) => getTreeGridDataItem(item.data));
+      const noParentData = items.filter((item) => !item[treeGridParentField]);
+      return noParentData;
+    });
+    const renderNoData = () => {
+      const {
+        isLoaded
+      } = c.state;
+      return isLoaded && vue.createVNode(vue.resolveComponent("iBizNoData"), {
+        "text": c.model.emptyText,
+        "emptyTextLanguageRes": c.model.emptyTextLanguageRes
+      }, null);
+    };
+    const loadData = async (item, row, callback) => {
+      const items = c.state.items.filter((data) => item[treeGridValueField] === data[treeGridParentField]);
+      callback(items);
+    };
+    return {
+      c,
+      ns,
+      ns2,
+      tableRef,
+      tableData,
+      renderColumns,
+      defaultSort,
+      onDbRowClick,
+      onRowClick,
+      onSelectionChange,
+      onSortChange,
+      onPageChange,
+      onPageSizeChange,
+      onPageRefresh,
+      handleRowClassName,
+      renderNoData,
+      loadData,
+      summaryMethod,
+      renderPopover
+    };
+  },
+  render() {
+    const state = this.c.state;
+    const {
+      hideHeader,
+      enablePagingBar
+    } = this.c.model;
+    return vue.createVNode(vue.resolveComponent("iBizControlBase"), {
+      "class": [this.ns.b(), this.ns2.b(), this.ns.is("show-header", !hideHeader), this.ns.is("enable-page", enablePagingBar), this.ns.is("enable-group", this.c.model.enableGroup)],
+      "controller": this.c
+    }, {
+      default: () => [this.c.state.isLoaded && vue.createVNode(vue.resolveComponent("el-table"), {
+        "ref": "tableRef",
+        "class": this.ns.e("table"),
+        "default-sort": this.defaultSort,
+        "border": true,
+        "show-header": !hideHeader,
+        "show-summary": this.c.enableAgg,
+        "summary-method": this.summaryMethod,
+        "highlight-current-row": state.singleSelect,
+        "row-class-name": this.handleRowClassName,
+        "row-key": "srfkey",
+        "data": this.tableData,
+        "onRowClick": this.onRowClick,
+        "onRowDblclick": this.onDbRowClick,
+        "onSelectionChange": this.onSelectionChange,
+        "onSortChange": this.onSortChange,
+        "tooltip-effect": "light",
+        "tree-props": {
+          children: "children",
+          hasChildren: "hasChildren"
+        },
+        "load": this.loadData,
+        "lazy": true
+      }, {
+        empty: this.renderNoData,
+        default: () => {
+          return [!state.singleSelect && vue.createVNode(vue.resolveComponent("el-table-column"), {
+            "class-name": this.ns.e("selection"),
+            "type": "selection",
+            "width": "55"
+          }, null), state.isCreated && this.renderColumns.map((model, index) => {
+            return grid.renderChildColumn(this.c, model, this.renderColumns, index);
+          })];
+        },
+        append: () => {
+          return this.renderPopover();
+        }
+      }), enablePagingBar && vue.createVNode(vue.resolveComponent("iBizPagination"), {
+        "total": state.total,
+        "curPage": state.curPage,
+        "size": state.size,
+        "onChange": this.onPageChange,
+        "onPageSizeChange": this.onPageSizeChange,
+        "onPageRefresh": this.onPageRefresh
+      }, null)]
+    });
+  }
+});
+
+exports.TreeGridControl = TreeGridControl;

package/lib/control/tree-grid/tree-grid.provider.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class TreeGridProvider {
+  constructor() {
+    __publicField(this, "component", "IBizTreeGridControl");
+  }
+}
+
+exports.TreeGridProvider = TreeGridProvider;

package/lib/control/tree-grid-ex/index.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('@ibiz-template/runtime');
+var vue3Util = require('@ibiz-template/vue3-util');
+var treeGridEx = require('./tree-grid-ex.cjs');
+var treeGridEx_provider = require('./tree-grid-ex.provider.cjs');
+
+"use strict";
+const IBizTreeGridExControl = vue3Util.withInstall(
+  treeGridEx.TreeGridExControl,
+  function(v) {
+    v.component(treeGridEx.TreeGridExControl.name, treeGridEx.TreeGridExControl);
+    runtime.registerControlProvider(
+      runtime.ControlType.TREE_GRIDEX,
+      () => new treeGridEx_provider.TreeGridExProvider()
+    );
+  }
+);
+
+exports.IBizTreeGridExControl = IBizTreeGridExControl;
+exports.default = IBizTreeGridExControl;