super-page-runtime 2.3.17 → 2.3.18-tmp1

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

@@ -0,0 +1,943 @@
+"use strict";
+const Vue = require("vue");
+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.1.58_@vue_29e6d749740d5c0a82211de8e577b320/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 pageHelperUtil = require("../../../../utils/page-helper-util.js");
+const globalRefs = require("../../../../utils/global-refs.js");
+const chartTableUtil = require("../../chart/table/chart-table-util.js");
+const _hoisted_1 = ["id"];
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "main-table-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  emits: ["setSafeDeleteTableCode"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const pageContext = props.pageContext;
+    let configure = props.configure;
+    const runtimeInfo = Vue.ref({});
+    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 runtimeStyle = runtimeInfo.value.style;
+    const runtimeClass = runtimeInfo.value.class;
+    const systemCode = pageContext.systemCode;
+    const backendUrl = pageContext.backendUrl;
+    const tableName = configure.props && configure.props.dataOrigin && configure.props.dataOrigin.tableName;
+    let baseURL = commonUtil.getBaseUrl(pageContext.backendUrl, pageContext.isTest);
+    if (!baseURL) {
+      baseURL = window["$vueApp"].config.globalProperties.baseURL;
+    }
+    const operationButtonObj = Vue.ref({});
+    const linkageVariable = [];
+    const listOptions = Vue.ref({});
+    listOptions.value = getOptions();
+    const tableDivRef = Vue.ref();
+    const gridRef = Vue.ref();
+    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);
+    const isCanShowMobileSearch = Vue.ref(false);
+    const $emit = __emit;
+    Vue.onMounted(() => {
+      const distanceToAppContainer = getDistanceToAppContainer();
+      if (gridRef.value && distanceToAppContainer && distanceToAppContainer.distanceToBottom) {
+        gridRef.value.tableHeight = distanceToAppContainer.distanceToBottom - 110;
+      }
+      if (props.pageContext.pageRuntimeStyle) {
+        console.log("pageContext.pageHeight:", props.pageContext.pageRuntimeStyle.height);
+      }
+      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");
+      });
+      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);
+      });
+      listOptions.value["formSetMaxHeight"] = getComponentHeight();
+      if (listOptions.value && listOptions.value.configureObj.props.base && listOptions.value.configureObj.props.base.isSafeDelete) {
+        $emit("setSafeDeleteTableCode", listOptions.value.extraParam.tableName);
+      }
+    });
+    function gridOnMounted() {
+      if (configure.props.linkages && configure.props.linkages.length > 0) {
+        configure.props.linkages.forEach((linkage) => {
+          const variablePath = pageHelperUtil.decomposeVariable(linkage.fieldName);
+          if (variablePath && variablePath.length > 1) {
+            linkageVariable.push(variablePath[1]);
+          }
+        });
+        if (linkageVariable.length > 0) {
+          addLinkageWatch();
+        }
+      }
+    }
+    Vue.watch(
+      () => props.pageContext.searchFormData,
+      (searchFormData) => {
+        searchFormInfo.value.data = searchFormData;
+      }
+    );
+    Vue.watch(
+      () => props.pageContext.entity.data,
+      (searchFormData) => {
+        searchGridData(props.pageContext.entity.data);
+      }
+    );
+    Vue.onUnmounted(() => {
+      window.removeEventListener("message", recieveMessage);
+      eventBus.$off(eventPageInfo + "-close-component-page-dialog");
+      eventBus.$off(eventPageInfo + "_close-dialog-get-entity");
+      eventBus.$off(listCode + "-pickFileDone");
+      eventBus.$off(listCode + "-scanDone");
+    });
+    function getUrlToListData() {
+      let urlToListData2 = baseURL + "/dsc/commons/list";
+      if (urlToListData2) {
+        urlToListData2 = commonUtil.getRealRestApiPath(urlToListData2, systemCode, backendUrl, pageContext.isTest);
+      }
+      return urlToListData2;
+    }
+    function getOptions() {
+      var _a;
+      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 rowKeyProp = (_a = configure.props) == null ? void 0 : _a.dataOrigin.principalLinkage;
+      const options = {
+        isSql: true,
+        optionTableHeight: 0,
+        rowKeyProp,
+        extraParam: {
+          beanName: pageContext.beanName,
+          functionCode: permissionPrefix + ".listData",
+          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.dataOrigin.initializationQuery === false ? false : 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: commonUtil.isWorkflowPage(pageContext),
+        tableClass: runtimeClass,
+        tableStyle: runtimeStyle,
+        pageContext,
+        configureObj: configure,
+        backendUrl: baseURL,
+        cellStyleRender: getCellStyle,
+        rowStyleRender: getRowStyle,
+        titleStyleRender: getTitleStyle,
+        validateEitConditions
+      };
+      setMergeFields(options);
+      setOperationButtons(options);
+      setSortInfo(options);
+      setTreeSetting(options);
+      setGridEvents(options);
+      return options;
+    }
+    function setSortInfo(options) {
+      if (configure.props && configure.props.dataOrigin && configure.props.dataOrigin.sortField) {
+        options.initSortInfo = [];
+        configure.props.dataOrigin.sortField.forEach((item) => {
+          const sortInfo = {
+            order: item.type === "desc" ? "desc" : "asc"
+          };
+          sortInfo["prop"] = item.name;
+          options.initSortInfo.push(sortInfo);
+        });
+      }
+    }
+    function setOperationButtons(options) {
+      const operationButtons = [];
+      if (!options.operations) {
+        options.operations = {};
+      }
+      tableUtils.getOperationButtons(pageContext, configure, operationButtons, getOperationButtonClickEvent);
+      options.operations.operation = operationButtons;
+    }
+    function setMergeFields(options) {
+      var _a;
+      if (((_a = configure.props.highOrder) == null ? void 0 : _a.mergeFields) && configure.props.highOrder.mergeFields.length > 0) {
+        options.mergeFields = configure.props.highOrder.mergeFields.join(",");
+      }
+    }
+    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 (dataOrigin.checkStrictly) {
+          options.checkStrictly = dataOrigin.checkStrictly;
+        }
+        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;
+      }
+    }
+    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) {
+      if (!buttonConfigure) {
+        return;
+      }
+      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;
+        }
+        if (!onClick) {
+          const eventFunc = eventUtil.getEventFuncByType(pageContext, buttonConfigure.events, "click");
+          onClick = eventFunc;
+        }
+      } else {
+        operationButtonObj.value[buttonConfigure.uuid] = buttonConfigure;
+        onClick = customButtonClick;
+      }
+      return {
+        onClick,
+        eventName
+      };
+    }
+    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) => {
+        const otherParams = { tableName: tableConfigure.props.dataOrigin.tableName };
+        standardEvent.getSaveFormRequestWithRow(
+          pageContext,
+          buttonConfigure,
+          "/dsc/commons",
+          false,
+          mainDefaultValueColumns,
+          dynamicColumnInfo,
+          row,
+          otherParams
+        ).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"]) {
+        console.log("!pageContext['dataTypeMaps'] || !pageContext['dataTypeMaps'][tableName]");
+        return;
+      }
+      const dataTypeObj = pageContext["dataTypeMaps"];
+      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;
+              setToolsDateFormatType(fieldParam, key);
+              fieldParam["rightBracket"] = ")";
+              fieldParam["joinSign"] = "and";
+              toolbarFieldParam.push(fieldParam);
+            }
+          }
+        }
+      }
+      console.log("toolbarRefresh");
+      gridRef.value.toolbarRefresh(null, null, toolbarFieldParam);
+    }
+    function resizeListHeight(params) {
+      const contentHeight = getComponentHeight();
+      if (contentHeight) {
+        let searchHeight = 0;
+        if (params.searchHeight) {
+          searchHeight = params.searchHeight;
+        }
+        return contentHeight - 10 - searchHeight;
+      }
+    }
+    function getComponentHeight() {
+      if (!gridRef.value) {
+        return;
+      }
+      const sizeConfig = pageHelperUtil.getSizeConfig(props.pageContext, props.configure);
+      if (sizeConfig) {
+        if (sizeConfig["isCalcHeight"]) {
+          let thisRefDom = gridRef.value.$el;
+          if (!thisRefDom) {
+            thisRefDom = gridRef.value;
+          }
+          if (!thisRefDom) {
+            return;
+          }
+          const rect = thisRefDom.getBoundingClientRect();
+          return window.innerHeight - rect.y - 90;
+        } else {
+          if (sizeConfig.fixHeight) {
+            if (gridRef.value) {
+              gridRef.value.tableHeight = sizeConfig.fixHeight;
+            }
+          }
+          if (sizeConfig.maxHeight) {
+            return sizeConfig.maxHeight;
+          }
+        }
+      }
+    }
+    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);
+    }
+    function recieveMessage(event) {
+      if (event.data === "close_open_win") {
+        if (gridRef.value) {
+          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(parentRowIds, isLineEdit, toolbarFieldParam, isDeleteSubTableData) {
+      return gridRef.value.refresh(parentRowIds, isLineEdit, toolbarFieldParam, isDeleteSubTableData);
+    }
+    function createRow() {
+      return gridRef.value.createRow(listCode, {}, { getDefaultValueFunc: pageInitUtil.getDefaultValue });
+    }
+    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);
+    }
+    function showMobileSearch() {
+      if (isCanShowMobileSearch.value) {
+        gridRef.value.showMobileSearch();
+      }
+    }
+    function canShowMobileSearchFunc(listCode2) {
+      isCanShowMobileSearch.value = true;
+    }
+    function getRowStyle(data) {
+      return chartTableUtil.getRowStyleUtil(data, [], props);
+    }
+    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 getLinkageVariableValues() {
+      const values = {};
+      linkageVariable.forEach((variable) => {
+        values[variable] = props.pageContext.entity.page[variable];
+      });
+      return values;
+    }
+    function addLinkageWatch() {
+      let waitComponentRenderProps = [];
+      if (props.pageContext.toolsInputComponents && props.pageContext.toolsInputComponents.length > 0) {
+        props.pageContext.toolsInputComponents.forEach((componentItem) => {
+          const isLinkComponent = configure.props.linkages.some((linkage) => linkage.fieldName === componentItem.prop);
+          if (isLinkComponent && componentItem.defaultValue) {
+            const variablePath = pageHelperUtil.decomposeVariable(componentItem.prop);
+            if (variablePath && variablePath.length > 1) {
+              waitComponentRenderProps.push(variablePath[1]);
+            }
+          }
+        });
+      }
+      if (waitComponentRenderProps.length === 0) {
+        linkageVariableWatch();
+      } else {
+        const values = getLinkageVariableValues();
+        waitComponentRenderProps = waitComponentRenderProps.filter((unsetVariable) => {
+          return commonUtil.isVariableInvalidValue(values, unsetVariable);
+        });
+        if (waitComponentRenderProps.length === 0) {
+          searchGridData(values);
+          linkageVariableWatch();
+        } else {
+          linkageVariable.forEach((variable) => {
+            Vue.watch(
+              () => props.pageContext.entity.page[variable],
+              () => {
+                const values2 = getLinkageVariableValues();
+                if (waitComponentRenderProps.length === 0) {
+                  searchGridData(values2);
+                } else {
+                  waitComponentRenderProps = waitComponentRenderProps.filter((unsetVariable) => {
+                    return commonUtil.isVariableInvalidValue(values2, unsetVariable);
+                  });
+                  if (waitComponentRenderProps.length === 0) {
+                    searchGridData(values2);
+                  }
+                }
+              },
+              { immediate: true }
+            );
+          });
+        }
+      }
+    }
+    function linkageVariableWatch() {
+      linkageVariable.forEach((variable) => {
+        Vue.watch(
+          () => props.pageContext.entity.page[variable],
+          () => {
+            const values = getLinkageVariableValues();
+            searchGridData(values);
+          }
+        );
+      });
+    }
+    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);
+      }
+    }
+    const getDistanceToAppContainer = () => {
+      if (!tableDivRef.value) return null;
+      let appContainer = tableDivRef.value.closest(".app-container");
+      if (!appContainer) {
+        console.warn("未找到.app-container元素");
+        return null;
+      }
+      const currentRect = tableDivRef.value.getBoundingClientRect();
+      const containerRect = appContainer.getBoundingClientRect();
+      const scrollY = window.scrollY;
+      const distanceToTop = currentRect.top + scrollY - containerRect.top;
+      const distanceToBottom = containerRect.bottom - currentRect.top;
+      return {
+        distanceToTop,
+        distanceToBottom
+      };
+    };
+    function changeOperationAddState(value) {
+    }
+    function validateEitConditions({ row, editConditions }) {
+      let result = true;
+      if (editConditions && editConditions.length > 0) {
+        result = pageHelperUtil.caculateShowCondition(props.pageContext, editConditions, row);
+      }
+      return result;
+    }
+    function setToolsDateFormatType(fieldParam, key) {
+      const componentRef = globalRefs.getComponentRefByCode(props.pageContext, key);
+      if (componentRef) {
+        const config = componentRef.getConfigure();
+        if (config.name === "datePicker") {
+          const type = config.runtime.props.dateType;
+          if (type === "year") {
+            fieldParam["dateFormatType"] = "YEAR";
+          } else if (type === "month") {
+            fieldParam["dateFormatType"] = "MONTH";
+          } else {
+            fieldParam["dateFormatType"] = "DAY";
+          }
+        }
+      }
+    }
+    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(index) {
+      var _a;
+      (_a = gridRef.value) == null ? void 0 : _a.setCurrentRowIndex(index);
+    }
+    function setScrollTopByRowIndex(rowIndex) {
+      var _a;
+      (_a = gridRef.value) == null ? void 0 : _a.setScrollTopByRowIndex(rowIndex);
+    }
+    function getTableData() {
+      var _a;
+      return (_a = gridRef.value) == null ? void 0 : _a.getTableData();
+    }
+    function handleSearch(searchableColumns, searchData) {
+      var _a;
+      return (_a = gridRef.value) == null ? void 0 : _a.handleSearch(searchableColumns, searchData);
+    }
+    __expose({
+      refresh,
+      createRow,
+      clearSelections,
+      getSelections,
+      getSelectionIds,
+      getTableConfigure,
+      isDeleteChange,
+      validatorSunTableListData,
+      showMobileSearch,
+      getTableSelectOptions,
+      dynamicControlTableEdit,
+      doLayout,
+      changeOperationAddState,
+      scrollTo,
+      setScrollTop,
+      setScrollLeft,
+      getSuperGridRef,
+      getSuperGridTableRef,
+      setCurrentRowIndex,
+      setScrollTopByRowIndex,
+      getTableData,
+      handleSearch
+    });
+    return (_ctx, _cache) => {
+      const _component_super_grid = Vue.resolveComponent("super-grid");
+      return Vue.openBlock(), Vue.createElementBlock("div", {
+        ref_key: "tableDivRef",
+        ref: tableDivRef,
+        id: Vue.unref(listCode) + "_tableDiv"
+      }, [
+        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),
+          onCanShowMobileSearch: canShowMobileSearchFunc,
+          onGridOnmounted: gridOnMounted
+        }, null, 8, ["url", "options", "code", "settings", "search-form-info", "list-toolbar-form-data", "onNewOpenGridDialog"])
+      ], 8, _hoisted_1);
+    };
+  }
+});
+module.exports = _sfc_main;