super-page-runtime 2.3.17 → 2.3.18-tmp2

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

@@ -0,0 +1,718 @@
+"use strict";
+const Vue = require("vue");
+const eventUtil = require("../../../../utils/events/event-util.js");
+const pageHelperUtil = require("../../../../utils/page-helper-util.js");
+const pageInitUtil = require("../../../../utils/page-init-util.js");
+const eventBus = require("../../../../utils/eventBus.js");
+const tableUtils = require("../../../../utils/table-utils.js");
+const commonUtil = require("../../../../utils/common-util.js");
+const standardEvent = require("../../../../utils/events/standard-event.js");
+const chartTableUtil = require("../../chart/table/chart-table-util.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "sub-table-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  emits: ["setSafeDeleteTableCode"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    var _a;
+    const props = __props;
+    const pageContext = props.pageContext;
+    let configure = props.configure;
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    if (pageContext.isTest) {
+      runtimeInfo.value = props.configure.runtime ? props.configure.runtime : {};
+    } else {
+      if (pageContext.tableRuntimes && pageContext.tableRuntimes[configure.uuid]) {
+        configure = JSON.parse(pageContext.tableRuntimes[configure.uuid].configure);
+        runtimeInfo.value = configure.runtime ? configure.runtime : {};
+      }
+    }
+    const listCode = commonUtil.getListCode(pageContext.code, pageContext.version, configure.uuid);
+    const dataModel = pageContext.entity.data;
+    const prop = configure.code ? configure.code : listCode;
+    const additionalParamMap = standardEvent.getAdditionalParamMap(pageContext);
+    const tableEvents = runtimeInfo && runtimeInfo.events ? runtimeInfo.events : [];
+    const selections = Vue.ref([]);
+    const superGridItems = pageContext.superGridItems;
+    const superGridSetting = superGridItems ? superGridItems[configure.uuid] : null;
+    console.log("superGridSetting===", superGridItems, superGridSetting);
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const entity = props.pageContext.entity ? props.pageContext.entity : {};
+    let dynamicFields = pageInitUtil.getModelFields(props.configure, prop);
+    let baseURL = commonUtil.getBaseUrl(pageContext.backendUrl, pageContext.isTest);
+    if (!baseURL) {
+      baseURL = window["$vueApp"].config.globalProperties.baseURL;
+    }
+    const listViewShowFlag = Vue.ref(false);
+    let componentKey = Vue.ref(0);
+    const rowKeyProp = (_a = configure.props) == null ? void 0 : _a.dataOrigin.principalLinkage;
+    const listViewOptions = Vue.ref({
+      title: (configure == null ? void 0 : configure.title) || null,
+      isSql: true,
+      subTableData: null,
+      rowKeyProp,
+      extraParam: {},
+      operations: {},
+      hiddenColumns: [],
+      pageCode: pageContext.code,
+      pageVersion: pageContext.version,
+      pageContext,
+      configureObj: configure,
+      showPageArea: false,
+      showRowForm: false,
+      showOverflowTooltip: !!(configure.props && configure.props.otherSettings && (configure.props.otherSettings.isBreakLine === void 0 || configure.props.otherSettings.isBreakLine === false)),
+      // 单元格内容是否换行显示
+      backendUrl: baseURL,
+      cellStyleRender: getCellStyle,
+      rowStyleRender: getRowStyle,
+      titleStyleRender: getTitleStyle
+    });
+    const $emit = __emit;
+    if (runtimeStyle) {
+      listViewOptions.value["tableStyle"] = runtimeStyle;
+    }
+    if (runtimeClass) {
+      listViewOptions.value["tableClass"] = runtimeClass;
+    }
+    if (configure.props && configure.props.base && configure.props.base.subPaging === true) {
+      listViewOptions.value.showPageArea = true;
+    } else {
+      listViewOptions.value.showPageArea = false;
+    }
+    if (configure.props.base.showRowForm) {
+      listViewOptions.value.showRowForm = configure.props.base.showRowForm;
+    }
+    const gridRef = Vue.ref(null);
+    Vue.onMounted(() => {
+      const tableUuid = configure.uuid;
+      const subTableWatchProps = pageContext.subTableWatchProps;
+      eventBus.$on("_refreshSubTable_" + tableUuid, (params) => {
+        console.log("-_refreshSubTable--tableUuid=", tableUuid, "params=", params);
+        const propName = params.propName;
+        if (subTableWatchProps && subTableWatchProps[tableUuid] && subTableWatchProps[tableUuid].length > 0) {
+          const mainFormProps = subTableWatchProps[tableUuid];
+          if (mainFormProps.indexOf(propName) >= 0) {
+            reloadSubTableData();
+          }
+        }
+      });
+      eventBus.$on("_refreshSubTableHandle_" + tableUuid, (params) => {
+        console.log("-_refreshSubTableHandle_--tableUuid=", tableUuid, "params=", params);
+        reloadSubTableData();
+      });
+      eventBus.$on("_refreshChildData_" + tableUuid, (gridData) => {
+        console.log("-_refreshChildData_--tableUuid=", tableUuid);
+        refreshChildTableData(gridData);
+      });
+      eventBus.$on(listCode + "-pickFileDone", (data) => {
+        console.log("superPage5555---listCode---pickFileDone--listCode=", listCode, "data=", data);
+        gridRef.value.pickFileDone(data);
+      });
+      eventBus.$on(listCode + "-scanDone", (data) => {
+        console.log("superPage5555---listCode---scanDone--listCode=", listCode, "data=", data);
+        gridRef.value.scanDone(data);
+      });
+      if (listViewOptions.value && listViewOptions.value.configureObj.props.base && listViewOptions.value.configureObj.props.base.isSafeDelete) {
+        $emit("setSafeDeleteTableCode", listViewOptions.value.extraParam.tableName);
+      }
+    });
+    function reloadSubTableData() {
+      if (gridRef.value) {
+        listViewOptions.value["subTableData"] = null;
+        gridRef.value.reloadSubTableData(listCode);
+      }
+    }
+    Vue.onUnmounted(() => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      if (timer2) {
+        clearTimeout(timer2);
+      }
+      const tableUuid = configure.uuid;
+      eventBus.$off("_refreshSubTable_" + tableUuid);
+      eventBus.$off("_refreshSubTableHandle_" + tableUuid);
+      eventBus.$off("_refreshChildData_" + tableUuid);
+      eventBus.$off(listCode + "-pickFileDone");
+      eventBus.$off(listCode + "-scanDone");
+    });
+    function currencyListViewSetting(canRrefreshSubtableData) {
+      if (canRrefreshSubtableData === void 0) {
+        canRrefreshSubtableData = judgeInitializationSubTable();
+      }
+      listViewOptions.value["isPageInfo"] = false;
+      listViewOptions.value["isFormSubTable"] = true;
+      listViewOptions.value["canRrefreshSubtableData"] = canRrefreshSubtableData;
+      listViewOptions.value["getFormData"] = getParentFormData;
+      listViewOptions.value["getGridData"] = getGridData;
+      listViewOptions.value.extraParam["subTableListViewCode"] = listCode;
+      listViewOptions.value.extraParam["beanName"] = pageContext.beanName;
+      listViewOptions.value.extraParam["subtableSetting"] = configure.props && configure.props.otherSettings ? JSON.stringify(configure.props.otherSettings) : null;
+      listViewOptions.value.extraParam["additionalParamMap"] = additionalParamMap;
+      listViewOptions.value.extraParam["entityMap"] = pageContext.entity.data;
+      listViewOptions.value.extraParam["contextMap"] = pageContext.entity.context;
+      listViewOptions.value.extraParam["taskMap"] = pageContext.entity.task;
+      if (!(configure.props && configure.props.base && configure.props.base.showOperation)) {
+        let hiddenColumns = listViewOptions.value.hiddenColumns;
+        if (!hiddenColumns) {
+          hiddenColumns = ["operation"];
+        } else {
+          hiddenColumns.push("operation");
+        }
+        listViewOptions.value["hiddenColumns"] = hiddenColumns;
+      }
+      listViewOptions.value["showOperationButton"] = configure.props && configure.props.base ? configure.props.base.showOperation : false;
+      listViewOptions.value["isPdfEditor"] = false;
+      listViewOptions.value["tableRecordMaxNum"] = configure.props && configure.props.otherSettings ? configure.props.otherSettings.tableRecordMaxNum : null;
+      let sizeConfig = pageHelperUtil.getSizeConfig(pageContext, configure);
+      if (sizeConfig && sizeConfig.fixHeight) {
+        listViewOptions.value["formSetHeight"] = sizeConfig.fixHeight;
+      }
+      if (sizeConfig && sizeConfig.maxHeight) {
+        listViewOptions.value["formSetMaxHeight"] = sizeConfig.maxHeight;
+      }
+      listViewOptions.value["validateEitConditions"] = validateEitConditions;
+    }
+    function judgeInitializationSubTable() {
+      if (!configure.props || !configure.props.otherSettings) {
+        return;
+      }
+      if (configure.props.otherSettings.sourceQueryTableData && configure.props.otherSettings.timeToInitializeSubTable && configure.props.otherSettings.timeToInitializeSubTable.length > 0) {
+        let flag = false;
+        if (configure.props.otherSettings.timeToInitializeSubTable.indexOf("create") !== -1) {
+          if (dataModel.id || dataModel.ID) {
+            flag = false;
+          } else {
+            flag = true;
+          }
+        }
+        if (configure.props.otherSettings.timeToInitializeSubTable.indexOf("noData") !== -1) {
+          const tableData = dataModel[prop];
+          if (!tableData || tableData.length <= 0) {
+            flag = true;
+          }
+        }
+        return flag;
+      } else {
+        return false;
+      }
+    }
+    function getParentFormData() {
+      return pageContext.entity.data;
+    }
+    function getGridData() {
+      return pageHelperUtil.getVariableValue(entity, dynamicFields);
+    }
+    function initializationSubTable() {
+      const canRrefreshSubtableData = judgeInitializationSubTable();
+      if (canRrefreshSubtableData) {
+        changeInitializationSubTable(canRrefreshSubtableData);
+      } else {
+        currencyListViewSetting(canRrefreshSubtableData);
+        listViewOptions.value["isPageInfo"] = false;
+        listViewOptions.value["subTableData"] = getValue();
+        setGridDataEventOptions();
+      }
+    }
+    let timer;
+    let timer2;
+    function changeInitializationSubTable(canRrefreshSubtableData) {
+      currencyListViewSetting(canRrefreshSubtableData);
+      listViewOptions.value["subTableData"] = null;
+      setGridDataEventOptions();
+      listViewShowFlag.value = false;
+      timer = setTimeout(() => {
+        listViewShowFlag.value = true;
+        componentKey.value = componentKey.value + 1;
+        setGridToStore();
+      }, 10);
+    }
+    function setGridDataEventOptions() {
+      setSubTableValidateInfo();
+      eventUtil.setTableEvents(listViewOptions.value, tableEvents, pageContext, configure);
+      const customEvents = pageContext.customEvents;
+      if (customEvents) {
+        listViewOptions.value["eventCallBack"] = customEvents;
+      }
+      listViewShowFlag.value = true;
+      setGridToStore();
+    }
+    function setSubTableValidateInfo() {
+      const fieldPermissionMap = pageContext.fieldPermissionMap;
+      const actionPermissionMap = pageContext.actionPermissionMap;
+      if (fieldPermissionMap && fieldPermissionMap != null) {
+        let validateRules = fieldPermissionMap.get(prop);
+        if (!validateRules) {
+          const allValidateRules = fieldPermissionMap.get("all_fields");
+          if (allValidateRules) {
+            validateRules = [allValidateRules];
+          }
+        }
+        if (validateRules) {
+          listViewOptions.value["validateRules"] = validateRules;
+        } else {
+          listViewOptions.value["validateRules"] = null;
+        }
+      }
+      if (actionPermissionMap && actionPermissionMap != null) {
+        let actionPermission = actionPermissionMap.get(prop);
+        if (!actionPermission) {
+          actionPermission = actionPermissionMap.get("all_sub_tables");
+        }
+        listViewOptions.value["actionPermission"] = actionPermission;
+      }
+      if (!listViewOptions.value["operations"]) {
+        listViewOptions.value["operations"] = {};
+      }
+      const subTableOperations = getOperations();
+      listViewOptions.value["operations"]["operation"] = subTableOperations;
+      listViewOptions.value["subTableCanAdd"] = isShowSubHeaderButtonWf(null, null, null, null, null, true, "canAdd");
+      listViewOptions.value["subTableCanDelete"] = isShowSubHeaderButtonWf(null, null, null, null, null, true, "canDelete");
+    }
+    function setGridToStore() {
+      if (!pageContext.tableUuids) {
+        pageContext.tableUuids = [];
+      }
+      if (pageContext.tableUuids.indexOf(configure.uuid) < 0) {
+        pageContext.tableUuids.push(configure.uuid);
+      }
+    }
+    function getOperations() {
+      let operations = [];
+      let isShowOperation = pageHelperUtil.caculateShowCondition(props.pageContext, configure.props.base.showOperationCondition);
+      if (isShowOperation && isShowSubHeaderButtonWf(null, null, null, null, null, true, "canAdd")) {
+        const addButton = {
+          props: {
+            elementType: "el-button",
+            icon: "Plus",
+            type: "primary",
+            circle: true,
+            size: "mini",
+            permission: "true"
+          },
+          onClick: addSubTableData,
+          isShow: isShowAdd
+        };
+        operations.push(addButton);
+      }
+      if (isShowOperation && isShowDeleteWf(null, null, null, null, null, true)) {
+        const removeButton = {
+          props: {
+            elementType: "el-button",
+            icon: "Minus",
+            type: "danger",
+            circle: true,
+            size: "mini",
+            permission: "true"
+          },
+          onClick: removeSubTableData,
+          isShow: isShowDelete
+        };
+        operations.push(removeButton);
+      }
+      tableUtils.getOperationButtons(pageContext, configure, operations, getOperationButtonClickEvent);
+      return operations;
+    }
+    const operationButtonObj = Vue.ref({});
+    function getOperationButtonClickEvent(buttonConfigure) {
+      if (!buttonConfigure) {
+        return;
+      }
+      operationButtonObj.value[buttonConfigure.uuid] = buttonConfigure;
+      let onClick = customButtonClick;
+      return onClick;
+    }
+    function customButtonClick(originalValue, formatValue, row, column, rowIndex, button) {
+      const otherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex,
+        button,
+        id: row.ID ? row.ID : row.id
+      };
+      const buttonConfigure = operationButtonObj.value[button.sourceButton.uuid];
+      const tableConfigure = configure;
+      buttonConfigure.props.base.tableUuid = tableConfigure.uuid;
+      eventUtil.getHandleEvent(null, pageContext, buttonConfigure, "click", otherParams);
+    }
+    initializationSubTable();
+    function getEntityId(row) {
+      if (row && row.id) {
+        return row.id;
+      } else if (row && row.ID) {
+        return row.ID;
+      }
+    }
+    function isShowSubHeaderButtonWf(originalValue, formatValue, row, column, rowIndex, isFormJudge, type) {
+      if (!type) {
+        type = "canAdd";
+      }
+      const isShowOperation = pageHelperUtil.caculateShowCondition(props.pageContext, configure.props.base.showOperationCondition);
+      if (!isShowOperation) {
+        return false;
+      }
+      const fieldPermissionMap = pageContext.fieldPermissionMap;
+      const actionPermissionMap = pageContext.actionPermissionMap;
+      let canShow = true;
+      if (fieldPermissionMap && fieldPermissionMap !== null) {
+        const allFieldPermission = fieldPermissionMap.get("all_fields");
+        if (typeof allFieldPermission !== "undefined" && allFieldPermission.canEdit === false && (allFieldPermission.rowIndexes === void 0 || allFieldPermission.rowIndexes === null || allFieldPermission.rowIndexes.length === 0)) {
+          canShow = false;
+        }
+      }
+      if (canShow === true && prop && actionPermissionMap && actionPermissionMap !== null) {
+        let oneTableActionPermission = actionPermissionMap.get(prop);
+        if (!oneTableActionPermission) {
+          oneTableActionPermission = actionPermissionMap.get("all_sub_tables");
+        }
+        if (oneTableActionPermission && oneTableActionPermission[type] !== void 0 && oneTableActionPermission[type] === false) {
+          canShow = false;
+        }
+      }
+      return canShow;
+    }
+    function isShowAdd(originalValue, formatValue, row, column, rowIndex, isFormJudge) {
+      let canAdd = isShowSubHeaderButtonWf(originalValue, formatValue, row, column, rowIndex, isFormJudge, "canAdd");
+      if (canAdd === true) {
+        canAdd = pageHelperUtil.caculateShowCondition(props.pageContext, configure.props.base.showAddBtnCondition, row);
+      }
+      return canAdd;
+    }
+    function isShowDeleteWf(originalValue, formatValue, row, column, rowIndex, isFormJudge) {
+      const fieldPermissionMap = pageContext.fieldPermissionMap;
+      const actionPermissionMap = pageContext.actionPermissionMap;
+      let canDelete = true;
+      if (fieldPermissionMap && fieldPermissionMap !== null) {
+        const allFieldPermission = fieldPermissionMap.get("all_fields");
+        if (typeof allFieldPermission !== "undefined" && allFieldPermission.canEdit === false && (allFieldPermission.rowIndexes === void 0 || allFieldPermission.rowIndexes === null || allFieldPermission.rowIndexes.length === 0)) {
+          canDelete = false;
+        }
+      }
+      if (canDelete === true && prop && actionPermissionMap && actionPermissionMap !== null) {
+        let oneTableActionPermission = actionPermissionMap.get(prop);
+        if (!oneTableActionPermission) {
+          oneTableActionPermission = actionPermissionMap.get("all_sub_tables");
+        }
+        if (oneTableActionPermission && oneTableActionPermission.canDelete !== void 0 && oneTableActionPermission.canDelete === false) {
+          canDelete = false;
+        }
+        if (oneTableActionPermission && oneTableActionPermission.canDelete !== void 0 && oneTableActionPermission.canDelete === true) {
+          if (oneTableActionPermission.deleteRowIndexes) {
+            if (oneTableActionPermission.deleteRowIndexes.length > 0) {
+              if (isFormJudge) {
+                canDelete = true;
+              } else {
+                const rowId = getEntityId(row);
+                if (rowId !== void 0 && oneTableActionPermission.deleteRowIndexes.indexOf(rowId) >= 0) {
+                  canDelete = true;
+                } else {
+                  canDelete = false;
+                }
+              }
+            } else {
+              canDelete = false;
+            }
+          }
+        }
+      }
+      return canDelete;
+    }
+    function isShowDelete(originalValue, formatValue, row, column, rowIndex, isFormJudge) {
+      let canDelete = isShowDeleteWf(originalValue, formatValue, row, column, rowIndex, isFormJudge);
+      if (canDelete === true) {
+        canDelete = pageHelperUtil.caculateShowCondition(props.pageContext, configure.props.base.showDeleteBtnCondition, row);
+      }
+      return canDelete;
+    }
+    function addSubTableData(originalValue, formatValue, row, column, rowIndex) {
+      gridRef.value.createRow(
+        listCode,
+        {},
+        { getDefaultValueFunc: pageInitUtil.getDefaultValue },
+        { originalValue, formatValue, row, column, rowIndex }
+      );
+    }
+    function removeSubTableData(originalValue, formatValue, row, column, rowIndex) {
+      gridRef.value.deleteRow(rowIndex, listCode, false);
+    }
+    function changeGridData(gridData) {
+      pageHelperUtil.setVariableValue(entity, dynamicFields, gridData);
+    }
+    function changeRowsPerpage(pageSize) {
+      console.log("表单组件--Item--changeRowsPerpage==pageSize=", pageSize);
+      if (!pageContext.subTablePageInfo) {
+        pageContext.subTablePageInfo = {};
+      }
+      if (!pageContext.subTablePageInfo[prop]) {
+        pageContext.subTablePageInfo[prop] = {};
+      }
+      pageContext.subTablePageInfo[prop].pageSize = pageSize;
+    }
+    function setSelectOptions(valueSetOptions) {
+      const propName = valueSetOptions.key;
+      const options = valueSetOptions.value;
+      if (!pageContext.selectOptions) {
+        pageContext.selectOptions = {};
+      }
+      pageContext.selectOptions[propName] = options;
+    }
+    function fnProhibitToEdit(data) {
+      const myPageCode = pageContext.code;
+      const eventPageInfo = myPageCode + "_";
+      eventBus.$emit(eventPageInfo + "prohibit-edit", data);
+    }
+    function refresMainTableFields(entity2) {
+      const dataModel2 = pageContext.entity.data;
+      if (entity2) {
+        for (const key in entity2) {
+          dataModel2[key] = entity2[key];
+        }
+      }
+    }
+    function select(selection, row) {
+      if (row !== void 0) {
+        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 changeFormData(formData) {
+      pageContext.entity.data = formData;
+    }
+    function validatorSunTableListData() {
+      return gridRef.value.validatorSunTableListData();
+    }
+    function createRow() {
+      return gridRef.value.createRow(listCode);
+    }
+    function getSelections() {
+      return selections.value;
+    }
+    function getSelectionIds() {
+      const dataIds = [];
+      if (selections.value) {
+        selections.value.forEach((item) => {
+          dataIds.push(item.id ? item.id : item.ID ? item.ID : null);
+        });
+      }
+      return dataIds;
+    }
+    function clearSelections() {
+      selections.value = [];
+    }
+    function getTableConfigure() {
+      return configure;
+    }
+    function getValue() {
+      return pageHelperUtil.getVariableValue(entity, dynamicFields);
+    }
+    function setValue(value) {
+      return pageHelperUtil.setVariableValue(entity, dynamicFields, value);
+    }
+    function refreshChildTableData(gridData) {
+      setValue(gridData);
+      timer2 = setTimeout(() => {
+        if (gridRef.value) {
+          gridRef.value.refreshChildData(
+            listCode,
+            gridData,
+            configure.props && configure.props.base && configure.props.base.subPaging === true
+          );
+          listViewOptions.value.extraParam["entityMap"] = pageContext.entity.data;
+        }
+      }, 10);
+    }
+    function getRowStyle(data) {
+      const style = chartTableUtil.getRowStyleUtil(data, null, props);
+      return style;
+    }
+    function getCellStyle(data) {
+      return chartTableUtil.getCellStyleUtil(data, data.cellStyle, props);
+    }
+    function getTitleStyle(data) {
+      const cellTitleStyle = data.titleStyle;
+      const rowTitleStyle = props.configure.style.titleStyle;
+      return chartTableUtil.getHeaderCellStyleUtil(data, { cellTitleStyle, titleStyle: rowTitleStyle }, props);
+    }
+    function getTableSelectOptions() {
+      if (gridRef.value) {
+        return gridRef.value.getTableSelectOptions(listCode);
+      }
+    }
+    function dynamicControlTableEdit(pageContext2, customRules, listCode2) {
+      if (gridRef.value) {
+        gridRef.value.dynamicControlTableEdit(pageContext2, customRules, listCode2);
+      }
+    }
+    function doLayout(hiddenColumns) {
+      if (gridRef.value) {
+        gridRef.value.doLayout(hiddenColumns);
+      }
+    }
+    function changeOperationAddState(value) {
+      if (gridRef.value) {
+        gridRef.value.changeOperationAddState(value);
+      }
+    }
+    function validateEitConditions({ row, editConditions }) {
+      let result = true;
+      if (editConditions && editConditions.length > 0) {
+        result = pageHelperUtil.caculateShowCondition(props.pageContext, editConditions, row);
+      }
+      return result;
+    }
+    function scrollTo(options, yCoord) {
+      if (gridRef.value) {
+        gridRef.value.scrollTo(options, yCoord);
+      }
+    }
+    function setScrollTop(top) {
+      if (gridRef.value) {
+        gridRef.value.setScrollTop(top);
+      }
+    }
+    function setScrollLeft(left) {
+      if (gridRef.value) {
+        gridRef.value.setScrollLeft(left);
+      }
+    }
+    function getSuperGridRef() {
+      return gridRef.value;
+    }
+    function getSuperGridTableRef() {
+      return gridRef.value.getSuperGridTableRef();
+    }
+    function setCurrentRowIndex(rowIndex) {
+      var _a2;
+      (_a2 = gridRef.value) == null ? void 0 : _a2.setCurrentRowIndex(rowIndex);
+    }
+    function setScrollTopByRowIndex(rowIndex) {
+      var _a2;
+      (_a2 = gridRef.value) == null ? void 0 : _a2.setScrollTopByRowIndex(rowIndex);
+    }
+    function getTableData() {
+      var _a2;
+      return (_a2 = gridRef.value) == null ? void 0 : _a2.getTableData();
+    }
+    function addRequiredClass(fieldName, rowIndex, pageNum) {
+      var _a2;
+      (_a2 = gridRef.value) == null ? void 0 : _a2.addRequiredClass(fieldName, listCode, rowIndex, pageNum);
+    }
+    __expose({
+      createRow,
+      getSelections,
+      getSelectionIds,
+      clearSelections,
+      getTableConfigure,
+      validatorSunTableListData,
+      getValue,
+      setValue,
+      getTableSelectOptions,
+      dynamicControlTableEdit,
+      doLayout,
+      changeOperationAddState,
+      scrollTo,
+      setScrollTop,
+      setScrollLeft,
+      getSuperGridRef,
+      getSuperGridTableRef,
+      setCurrentRowIndex,
+      setScrollTopByRowIndex,
+      getTableData,
+      addRequiredClass
+    });
+    return (_ctx, _cache) => {
+      const _component_super_grid = Vue.resolveComponent("super-grid");
+      return Vue.openBlock(), Vue.createElementBlock("div", null, [
+        listViewShowFlag.value ? (Vue.openBlock(), Vue.createBlock(_component_super_grid, {
+          key: 0,
+          ref_key: "gridRef",
+          ref: gridRef,
+          url: Vue.unref(baseURL) + "/dsc/commons/sub-table",
+          options: listViewOptions.value,
+          code: Vue.unref(listCode),
+          settings: Vue.unref(superGridSetting),
+          onSelect: select,
+          onSelectAll: selectAll,
+          onSelectionChange: selectionChange,
+          onCellClick: cellClickEvent,
+          onCellDblclick: cellDblClickEvent,
+          onRowClick: rowClickEvent,
+          onRowDblclick: rowDblClickEvent,
+          onHeaderClick: headerClickEvent,
+          onFnProhibitToEdit: fnProhibitToEdit,
+          onChangeGridData: changeGridData,
+          onReloadGrid: changeInitializationSubTable,
+          onRefresMainTableFields: refresMainTableFields,
+          onSetSelectOptions: setSelectOptions,
+          onChangeRowsPerPage: changeRowsPerpage,
+          onNewOpenGridDialog: Vue.unref(tableUtils.popupToPage),
+          onChangeFormData: changeFormData
+        }, null, 8, ["url", "options", "code", "settings", "onNewOpenGridDialog"])) : Vue.createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;