super-page-runtime 2.0.39 → 2.0.40-beta1

package/dist/lib/components/runtime/views/assemblys/data/table/main-table-runtime.vue.js

@@ -0,0 +1,673 @@
+"use strict";
+const Vue = require("vue");
+require("../../../../../../node_modules/.pnpm/agilebuilder-ui@1.0.28_vue@3.4.21/node_modules/agilebuilder-ui/lib/super-ui.js");
+const eventUtil = require("../../../../utils/events/event-util.js");
+const commonUtil = require("../../../../utils/common-util.js");
+const standardEvent = require("../../../../utils/events/standard-event.js");
+const commonUtil$1 = require("../../../../../../node_modules/.pnpm/agilebuilder-ui@1.0.28_vue@3.4.21/node_modules/agilebuilder-ui/src/utils/common-util.js");
+const tableUtils = require("../../../../utils/table-utils.js");
+const eventBus = require("../../../../utils/eventBus.js");
+const pageInitUtil = require("../../../../utils/page-init-util.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "main-table-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const pageContext = props.pageContext;
+    const configure = props.configure;
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const systemCode = pageContext.systemCode;
+    const backendUrl = pageContext.backendUrl;
+    const tableName = configure.props && configure.props.dataOrigin && configure.props.dataOrigin.tableName;
+    let baseURL = pageContext.backendUrl;
+    if (!baseURL) {
+      baseURL = window["$vueApp"].config.globalProperties.baseURL;
+    }
+    const operationButtonObj = Vue.ref({});
+    const listOptions = Vue.ref({});
+    listOptions.value = getOptions();
+    const gridRef = Vue.ref(null);
+    const urlToListData = getUrlToListData();
+    const listCode = commonUtil.getListCode(pageContext.code, pageContext.version, configure.uuid);
+    const myPageCode = pageContext.code;
+    const eventPageInfo = myPageCode + "_" + listCode;
+    const selections = Vue.ref([]);
+    const listToolbarFormData = pageContext.entity.page;
+    const searchFormInfo = Vue.ref({ data: [] });
+    const superGridItems = pageContext.superGridItems;
+    const superGridSetting = superGridItems ? superGridItems[configure.uuid] : null;
+    console.log("superGridSetting1111===", superGridItems, superGridSetting);
+    Vue.onMounted(() => {
+      window.addEventListener("message", recieveMessage);
+      eventBus.$on(
+        eventPageInfo + "-close-component-page-dialog",
+        function({ jumpInfo, popEntity, popPageCode }) {
+          gridRef.value.closePageDialog({
+            entity: popEntity,
+            pageCode: popPageCode,
+            jumpInfo
+          });
+        }
+      );
+      eventBus.$on(eventPageInfo + "_close-dialog-get-entity", () => {
+        eventBus.$emit(eventPageInfo + "_close-super-dialog");
+      });
+    });
+    Vue.watch(
+      () => props.pageContext.searchFormData,
+      (searchFormData) => {
+        searchFormInfo.value.data = searchFormData;
+      }
+    );
+    Vue.watch(
+      () => props.pageContext.entity.data,
+      (searchFormData) => {
+        searchGridData(props.pageContext.entity.data);
+      }
+    );
+    Vue.watch(
+      () => props.pageContext.entity.page,
+      (searchFormData) => {
+        searchGridData(props.pageContext.entity.page);
+      }
+    );
+    Vue.onUnmounted(() => {
+      eventBus.$off(eventPageInfo + "-close-component-page-dialog");
+      eventBus.$off(eventPageInfo + "_close-dialog-get-entity");
+    });
+    function getUrlToListData() {
+      let urlToListData2 = baseURL + "/dsc/commons/list";
+      if (urlToListData2) {
+        urlToListData2 = commonUtil.getRealRestApiPath(urlToListData2, systemCode, backendUrl);
+      }
+      return urlToListData2;
+    }
+    function getOptions() {
+      const systemCode2 = pageContext.systemCode;
+      const permissionPrefix = pageContext.code;
+      let initSearchForm = configure.props && configure.props.dataOrigin && configure.props.dataOrigin.sqlFilterCondition !== "[]" ? configure.props.dataOrigin.sqlFilterCondition : null;
+      if (typeof initSearchForm === "undefined" || initSearchForm === null) {
+        initSearchForm = [];
+      }
+      const options = {
+        isSql: true,
+        extraParam: {
+          beanName: pageContext.beanName,
+          functionCode: permissionPrefix + ".list",
+          tableName,
+          systemCode: systemCode2,
+          // 系统编码传给列表数据后台请求
+          pageCode: pageContext.code,
+          pageVersion: pageContext.version
+        },
+        initSearchForm,
+        lineEditOptions: {
+          aftersaveIsCreateRow: false,
+          autoSave: false,
+          enter: enterSave,
+          esc: escRestorRow
+        },
+        indexContinuous: configure.props && configure.props.otherSettings ? configure.props.otherSettings.serialNumberContinuous : false,
+        initSearch: configure.props && configure.props.base.initializationQuery ? configure.props.base.initializationQuery : true,
+        // 初始化时是否查询，默认是查询
+        resizeHeight: resizeListHeight,
+        pageCode: pageContext.code,
+        pageVersion: pageContext.version,
+        // pageHeight: pageHeight, // 页面的高度 //TODO: pageHeight如何获得，页面高度，计算列表高度应该会用
+        additionalParamMap: standardEvent.getAdditionalParamMap(pageContext),
+        // 将路由参数传给列表组件
+        showOverflowTooltip: !!(configure.props && configure.props.otherSettings && (configure.props.otherSettings.isBreakLine === void 0 || configure.props.otherSettings.isBreakLine === false)),
+        // 单元格内容是否换行显示
+        isEnableEnterEvent: configure.props && configure.props.otherSettings && configure.props.otherSettings.isEnableEnterEvent,
+        // 是否启用回车事件
+        isWithDataPermission: configure.props && configure.props.otherSettings && configure.props.otherSettings.isWithDataPermission ? configure.props.otherSettings.isWithDataPermission : false,
+        pageDevMode: false,
+        isWorkflowEntity: pageContext.workflowCode ? true : false,
+        tableClass: runtimeClass,
+        tableStyle: runtimeStyle,
+        pageContext,
+        configureObj: configure
+      };
+      setOperationButtons(options);
+      setSortInfo(options);
+      myGetDataTypeMap();
+      setTreeSetting(options);
+      setGridEvents(options);
+      return options;
+    }
+    function setSortInfo(options) {
+      if (configure.props && configure.props.dataOrigin && configure.props.dataOrigin.sortFields) {
+        options.initSortInfo = [];
+        this.colSetting.options.sortFields.forEach((item) => {
+          const sortInfo = {
+            order: item.sortOrder
+          };
+          sortInfo["prop"] = item.propDbName;
+          options.initSortInfo.push(sortInfo);
+        });
+      }
+    }
+    function myGetDataTypeMap(options) {
+      if (!backendUrl && !tableName) {
+        return;
+      }
+      tableUtils.getDataTypeMapRequest(backendUrl, tableName).then((result) => {
+        if (!pageContext["dataTypeMaps"]) {
+          pageContext["dataTypeMaps"] = {};
+        }
+        pageContext["dataTypeMaps"][tableName] = result["dataTypeMap"];
+      });
+    }
+    function setOperationButtons(options) {
+      const showOperation = configure.props && configure.props.base ? configure.props.base.showOperation : false;
+      const operationButtonSettings = configure.btnList;
+      console.log("configure.btnList===", configure.btnList, "configure====", configure);
+      if (showOperation && operationButtonSettings) {
+        const operationButtons = [];
+        operationButtonSettings.forEach((buttonConfigure) => {
+          const myButtonSet = {};
+          const myButtonProps = Object.assign({}, buttonConfigure.props.base);
+          myButtonProps.elementType = "el-button";
+          if (buttonConfigure.isPermission === void 0 || buttonConfigure.isPermission + "" === "true") {
+            const functionCodes = pageInitUtil.getPermissionCodes(buttonConfigure, props.pageContext);
+            if (functionCodes) {
+              myButtonProps.permission = functionCodes;
+            }
+          }
+          myButtonProps.label = myButtonProps.title;
+          myButtonSet["props"] = myButtonProps;
+          myButtonSet["onClick"] = getOperationButtonClickEvent(buttonConfigure);
+          operationButtons.push(myButtonSet);
+        });
+        if (!options.operations) {
+          options.operations = {};
+        }
+        options.operations.operation = operationButtons;
+      }
+    }
+    function setTreeSetting(options) {
+      const dataOrigin = configure.props ? configure.props.dataOrigin : {};
+      if (dataOrigin.treeTable) {
+        let parentPropDbName;
+        const parentPropInfo = dataOrigin.rowKey;
+        if (parentPropInfo && parentPropInfo.indexOf("~~") > 0) {
+          parentPropDbName = parentPropInfo.substring(parentPropInfo.indexOf("~~") + 2);
+        } else {
+          parentPropDbName = parentPropInfo;
+        }
+        options.parentProp = parentPropDbName;
+        if (options.parentProp) {
+          const isLazy = dataOrigin.lazy;
+          const defaultExpandAll = dataOrigin.defaultExpandAll;
+          if (isLazy === void 0 || isLazy === null) {
+            options.lazy = true;
+          } else {
+            options.lazy = isLazy;
+          }
+          if (defaultExpandAll === void 0 || defaultExpandAll === null) {
+            options.defaultExpandAll = false;
+          } else {
+            options.defaultExpandAll = defaultExpandAll;
+          }
+          const listViewTreeTableSetting = {
+            parentProp: parentPropDbName,
+            lazy: options.lazy,
+            defaultExpandAll: options.defaultExpandAll
+          };
+          options.extraParam.listViewTreeSetting = JSON.stringify(listViewTreeTableSetting);
+          options.subRowUrl = baseURL + "/dsc/commons/list-subs";
+        }
+      }
+    }
+    function setGridEvents(options) {
+      const tableEvents = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+      eventUtil.setTableEvents(options, tableEvents, pageContext, configure);
+      const customEvents = pageContext.customEvents;
+      if (customEvents) {
+        options.eventCallBack = customEvents;
+        const rowStyleEvent = eventUtil.getEventFuncByType(pageContext, tableEvents, "rowStyle");
+        if (rowStyleEvent) {
+          options.rowStyleRender = rowStyleEvent;
+        }
+      }
+    }
+    function enterSave({ rowIndex, column, row, orgRow }) {
+      saveRow(null, null, row, column, rowIndex);
+    }
+    function saveRow(originalValue, formatValue, row, column, rowIndex) {
+      const buttonConfigure = operationButtonObj.value["lineEditSave"];
+      const tableConfigure = configure;
+      buttonConfigure.props.base.tableUuid = tableConfigure.uuid;
+      listOptions.value["lineEditOptions"]["beforeSave"] = beforeSaveRow;
+      pageContext.editData = row;
+      eventUtil.canExecuteButton({ pageContext, configureObj: buttonConfigure }).then((result) => {
+        if (result["canExecute"] === true) {
+          listOptions.value["lineEditOptions"]["saveRow"] = saveLineEditRow;
+          gridRef.value.saveRow(rowIndex, listCode).then(() => {
+            const otherParams = {
+              originalValue,
+              formatValue,
+              row,
+              column,
+              rowIndex
+            };
+            eventUtil.doAfterClickEvent(pageContext, buttonConfigure, otherParams);
+          });
+        }
+      }).finally(() => {
+        pageContext.editData = null;
+      });
+    }
+    function getOperationButtonClickEvent(buttonConfigure) {
+      let onClick;
+      const eventName = eventUtil.getEventNameByType(buttonConfigure.events, "click");
+      if (eventName) {
+        operationButtonObj.value[eventName] = buttonConfigure;
+        if (eventName === "lineEditSave") {
+          onClick = saveRow;
+        } else if (eventName === "restoreEdit") {
+          onClick = restoreRow;
+        } else if (eventName === "lineEditUpdate") {
+          onClick = editRow;
+        } else if (eventName === "lineEditDelete") {
+          onClick = deleteRow;
+        } else {
+          onClick = customButtonClick;
+        }
+        if (!onClick) {
+          onClick = function() {
+          };
+        }
+      }
+      return onClick;
+    }
+    function beforeSaveRow({
+      row,
+      columns,
+      additionalParamMap
+    }) {
+      const buttonConfigure = operationButtonObj.value["lineEditSave"];
+      const tableConfigure = configure;
+      buttonConfigure.props.base.tableUuid = tableConfigure.uuid;
+      const otherParams = {
+        row,
+        columns
+      };
+      return eventUtil.doBeforeClickEvent(pageContext, buttonConfigure, otherParams);
+    }
+    function saveLineEditRow({
+      row,
+      columns,
+      dataTypeMap,
+      dynamicColumnInfo,
+      additionalParamMap,
+      mainDefaultValueColumns
+    }) {
+      const buttonConfigure = operationButtonObj.value["lineEditSave"];
+      const tableConfigure = configure;
+      buttonConfigure.props.base.tableUuid = tableConfigure.uuid;
+      return new Promise((resolve, reject) => {
+        standardEvent.getSaveFormRequestWithRow(
+          pageContext,
+          buttonConfigure,
+          "/dsc/commons",
+          false,
+          mainDefaultValueColumns,
+          dynamicColumnInfo,
+          row
+        ).then((commonEntity) => {
+          if (commonEntity) {
+            resolve(commonEntity.entity);
+          } else {
+            resolve({});
+          }
+        }).catch((error) => {
+          reject(error);
+        });
+      });
+    }
+    function escRestorRow({ rowIndex, column, row, orgRow }) {
+      restoreRow(null, null, row, column, rowIndex);
+    }
+    function restoreRow(originalValue, formatValue, row, column, rowIndex) {
+      const buttonConfigure = operationButtonObj.value["restoreEdit"];
+      const tableConfigure = configure;
+      buttonConfigure.props.base.tableUuid = tableConfigure.uuid;
+      const otherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex
+      };
+      const beforeClickResult = eventUtil.doBeforeClickEvent(pageContext, buttonConfigure, otherParams);
+      if (!beforeClickResult) {
+        return;
+      }
+      if (commonUtil$1.isPromise(beforeClickResult)) {
+        beforeClickResult.then((result) => {
+          if (result) {
+            gridRef.value.restoreRow(rowIndex, listCode);
+          }
+        });
+      } else {
+        gridRef.value.restoreRow(rowIndex, listCode);
+      }
+      const afterOtherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex
+      };
+      eventUtil.doAfterClickEvent(pageContext, configure, afterOtherParams);
+    }
+    function editRow(originalValue, formatValue, row, column, rowIndex) {
+      const buttonConfigure = operationButtonObj.value["lineEditUpdate"];
+      const tableConfigure = configure;
+      buttonConfigure.props.base.tableUuid = tableConfigure.uuid;
+      const otherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex
+      };
+      const beforeClickResult = eventUtil.doBeforeClickEvent(pageContext, buttonConfigure, otherParams);
+      if (!beforeClickResult) {
+        return;
+      }
+      if (commonUtil$1.isPromise(beforeClickResult)) {
+        beforeClickResult.then((result) => {
+          if (result) {
+            editRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure);
+          }
+        });
+      } else {
+        editRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure);
+      }
+    }
+    function editRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure) {
+      pageContext.editData = row;
+      eventUtil.canExecuteButton({ pageContext, configureObj: buttonConfigure }).then((result) => {
+        if (result["canExecute"] === true) {
+          gridRef.value.editRow(rowIndex, listCode);
+          const afterOtherParams = {
+            originalValue,
+            formatValue,
+            row,
+            column,
+            rowIndex
+          };
+          eventUtil.doAfterClickEvent(pageContext, configure, afterOtherParams);
+        }
+      }).finally(() => {
+        pageContext.editData = null;
+      });
+    }
+    function deleteRow(originalValue, formatValue, row, column, rowIndex) {
+      const buttonConfigure = operationButtonObj.value["lineEditDelete"];
+      const tableConfigure = configure;
+      buttonConfigure.props.base.tableUuid = tableConfigure.uuid;
+      const otherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex
+      };
+      const beforeClickResult = eventUtil.doBeforeClickEvent(pageContext, buttonConfigure, otherParams);
+      if (!beforeClickResult) {
+        return;
+      }
+      if (commonUtil$1.isPromise(beforeClickResult)) {
+        beforeClickResult.then((result) => {
+          if (result) {
+            deleteRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure);
+          }
+        });
+      } else {
+        deleteRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure);
+      }
+    }
+    function deleteRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure) {
+      if (row.id || row.ID) {
+        pageContext.editData = row;
+        eventUtil.canExecuteButton({ pageContext, configureObj: buttonConfigure }).then((result) => {
+          if (result["canExecute"] === true) {
+            const ids = [];
+            if (row.id) {
+              ids.push(row.id);
+            } else {
+              ids.push(row.ID);
+            }
+            standardEvent.standardEvents.delete({
+              pageContext,
+              configureObj: buttonConfigure,
+              ids
+            });
+          }
+        }).finally(() => {
+          pageContext.editData = null;
+        });
+      } else {
+        restoreRow(originalValue, formatValue, row, column, rowIndex);
+        const afterOtherParams = {
+          originalValue,
+          formatValue,
+          row,
+          column,
+          rowIndex
+        };
+        eventUtil.doAfterClickEvent(pageContext, configure, afterOtherParams);
+      }
+    }
+    function searchGridData(data) {
+      if (!pageContext["dataTypeMaps"] || !pageContext["dataTypeMaps"][tableName]) {
+        return;
+      }
+      const dataTypeObj = pageContext["dataTypeMaps"][tableName];
+      let toolbarFieldParam = [];
+      if (data) {
+        for (var key in data) {
+          const value = data[key];
+          if (value !== null && value !== void 0 && value !== "") {
+            if (value instanceof Array) {
+              if (value.length > 0) {
+                const multipleFieldParam = [];
+                for (var i = 0; i < value.length; i++) {
+                  const fieldParam = {};
+                  if (i === 0) {
+                    fieldParam["leftBracket"] = "((";
+                  } else {
+                    fieldParam["leftBracket"] = "(";
+                  }
+                  fieldParam["propName"] = key;
+                  fieldParam["propDbName"] = key;
+                  fieldParam["dataType"] = dataTypeObj[key] ? dataTypeObj[key] : "TEXT";
+                  fieldParam["operator"] = "EQ";
+                  fieldParam["propValue"] = value[i];
+                  if (i === value.length - 1) {
+                    fieldParam["rightBracket"] = "))";
+                    fieldParam["joinSign"] = "and";
+                  } else {
+                    fieldParam["rightBracket"] = ")";
+                    fieldParam["joinSign"] = "or";
+                  }
+                  multipleFieldParam.push(fieldParam);
+                }
+                toolbarFieldParam = toolbarFieldParam.concat(multipleFieldParam);
+              }
+            } else {
+              const fieldParam = {};
+              fieldParam["leftBracket"] = "(";
+              fieldParam["propName"] = key;
+              fieldParam["propDbName"] = key;
+              fieldParam["dataType"] = dataTypeObj[key] ? dataTypeObj[key] : "TEXT";
+              fieldParam["operator"] = "EQ";
+              fieldParam["propValue"] = value;
+              fieldParam["rightBracket"] = ")";
+              fieldParam["joinSign"] = "and";
+              toolbarFieldParam.push(fieldParam);
+            }
+          }
+        }
+      }
+      gridRef.value.toolbarRefresh(null, null, toolbarFieldParam);
+    }
+    function resizeListHeight(params) {
+    }
+    function customButtonClick(originalValue, formatValue, row, column, rowIndex, button) {
+      const otherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex,
+        button
+      };
+      const buttonConfigure = operationButtonObj.value["xxx"];
+      const tableConfigure = configure;
+      buttonConfigure.props.base.tableUuid = tableConfigure.uuid;
+      eventUtil.getHandleEvent(null, pageContext, buttonConfigure, "click", otherParams);
+    }
+    function recieveMessage(event) {
+      if (event.data === "close_open_win") {
+        gridRef.value.refresh();
+      }
+    }
+    function select(selection, row) {
+      selections.value = selection;
+      const params = {
+        selection,
+        row
+      };
+      eventUtil.gridSelectRecord(pageContext, configure, params);
+    }
+    function selectAll(selection) {
+      selections.value = selection;
+      const params = {
+        selection
+      };
+      eventUtil.gridSelectAllRecords(pageContext, configure, params);
+    }
+    function selectionChange(newSelection) {
+      const params = {
+        newSelection
+      };
+      eventUtil.gridSelectionChange(pageContext, configure, params);
+    }
+    function cellClickEvent(row, column, cell, event) {
+      const params = {
+        row,
+        column,
+        cell,
+        event
+      };
+      eventUtil.cellClick(pageContext, configure, params);
+    }
+    function cellDblClickEvent(row, column, cell, event) {
+      const params = {
+        row,
+        column,
+        cell,
+        event
+      };
+      eventUtil.cellDblClick(pageContext, configure, params);
+    }
+    function rowClickEvent(row, column, event) {
+      const params = {
+        row,
+        column,
+        event
+      };
+      eventUtil.rowClick(pageContext, configure, params);
+    }
+    function rowDblClickEvent(row, column, event) {
+      const params = {
+        row,
+        column,
+        event
+      };
+      eventUtil.rowDblClick(pageContext, configure, params);
+    }
+    function headerClickEvent(column, event) {
+      const params = {
+        column,
+        event
+      };
+      eventUtil.headerClick(pageContext, configure, params);
+    }
+    function validatorSunTableListData() {
+      return gridRef.value.validatorSunTableListData();
+    }
+    function clearSelections() {
+      selections.value = [];
+    }
+    function refresh() {
+      return gridRef.value.refresh();
+    }
+    function createRow() {
+      return gridRef.value.createRow(listCode);
+    }
+    function getSelections() {
+      return selections.value;
+    }
+    function getSelectionIds() {
+      const dataIds = [];
+      if (selections.value !== null) {
+        selections.value.forEach((item) => {
+          dataIds.push(item.id ? item.id : item.ID ? item.ID : null);
+        });
+      }
+      return dataIds;
+    }
+    function getTableConfigure() {
+      return configure;
+    }
+    function isDeleteChange(value) {
+      gridRef.value.isDeleteChange(value);
+    }
+    __expose({
+      refresh,
+      createRow,
+      clearSelections,
+      getSelections,
+      getSelectionIds,
+      getTableConfigure,
+      isDeleteChange,
+      validatorSunTableListData
+    });
+    return (_ctx, _cache) => {
+      const _component_super_grid = Vue.resolveComponent("super-grid");
+      return Vue.openBlock(), Vue.createElementBlock("div", null, [
+        Vue.createVNode(_component_super_grid, {
+          ref_key: "gridRef",
+          ref: gridRef,
+          url: Vue.unref(urlToListData),
+          options: listOptions.value,
+          code: Vue.unref(listCode),
+          settings: Vue.unref(superGridSetting),
+          "search-form-info": searchFormInfo.value,
+          "list-toolbar-form-data": Vue.unref(listToolbarFormData),
+          onSelect: select,
+          onSelectAll: selectAll,
+          onSelectionChange: selectionChange,
+          onCellClick: cellClickEvent,
+          onCellDblclick: cellDblClickEvent,
+          onRowClick: rowClickEvent,
+          onRowDblclick: rowDblClickEvent,
+          onHeaderClick: headerClickEvent,
+          onRefresh: clearSelections,
+          onNewOpenGridDialog: Vue.unref(tableUtils.popupToPage)
+        }, null, 8, ["url", "options", "code", "settings", "search-form-info", "list-toolbar-form-data", "onNewOpenGridDialog"])
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/data/table/main-table-runtime.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const mainTableRuntime_vue_vue_type_script_setup_true_lang = require("./main-table-runtime.vue.js");
+module.exports = mainTableRuntime_vue_vue_type_script_setup_true_lang;