super-page-runtime 2.3.17 → 2.3.18-tmp2

package/dist/lib/components/runtime/utils/events/event-util.js

@@ -0,0 +1,752 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const commonUtil = require("../../../../node_modules/.pnpm/agilebuilder-ui@1.1.58_@vue_29e6d749740d5c0a82211de8e577b320/node_modules/agilebuilder-ui/src/utils/common-util.js");
+const standardEvent = require("./standard-event.js");
+const validatorUtil = require("./validator-util.js");
+const globalRefs = require("../global-refs.js");
+const util = require("../../../../node_modules/.pnpm/agilebuilder-ui@1.1.58_@vue_29e6d749740d5c0a82211de8e577b320/node_modules/agilebuilder-ui/src/utils/util.js");
+const commonUtil$1 = require("../common-util.js");
+const eventBus = require("../eventBus.js");
+const pageHelperUtil = require("../page-helper-util.js");
+const tableUtils = require("../table-utils.js");
+const index = require("../../../../node_modules/.pnpm/element-plus@2.10.5_vue@3.5.18_typescript@5.4.5_/node_modules/element-plus/es/components/message/index.js");
+const skipValidateEvents = ["downloadTemplate", "back", "exportForm", "exportPDF", "lineEditCreate", "workflowSave"];
+const exportEvents = ["downloadTemplate", "exportForm", "exportPDF", "export", "exportCharts"];
+const importEvents = ["import"];
+function initPageEvents(pageDesign, pageContext) {
+  if (pageDesign && pageDesign.customEvents) {
+    const customEvents = transferToFunction(pageDesign.customEvents);
+    appendDefaultMethod(pageContext, customEvents);
+    console.log("initPage  customEvents", customEvents);
+    pageContext.customEvents = customEvents;
+  }
+}
+function getCustomFunc(pageContext, funcName) {
+  if (pageContext.customEvents) {
+    return pageContext.customEvents[funcName];
+  }
+}
+function appendDefaultMethod(pageContext, customEvents) {
+  if (!customEvents) {
+    return;
+  }
+  for (const pro in customEvents) {
+    const func = customEvents[pro];
+    appendDefaultMethods(func, pageContext);
+  }
+}
+function appendDefaultMethods(func, pageContext) {
+  func.get = function(code) {
+    if (code) {
+      return globalRefs.getComponentRefByCode(pageContext, code);
+    } else {
+      return void 0;
+    }
+  };
+  func.getByUuid = function(uuid) {
+    if (uuid) {
+      return globalRefs.getComponentRef(pageContext, uuid);
+    } else {
+      return void 0;
+    }
+  };
+  func.getPageContext = function() {
+    return pageContext;
+  };
+  func.getContextValue = function(fieldName) {
+    let contextData = pageContext && pageContext.entity ? pageContext.entity.context : null;
+    contextData = contextData ? contextData : {};
+    return pageHelperUtil.getValueFromSource(contextData, fieldName, "context");
+  };
+  func.getContext = function() {
+    return pageContext && pageContext.entity ? pageContext.entity.context : {};
+  };
+  func.getSystem = function() {
+    return pageContext && pageContext.entity ? pageContext.entity.system : {};
+  };
+  func.getTask = function() {
+    return pageContext && pageContext.entity ? pageContext.entity.task : {};
+  };
+  func.getRequest = function() {
+    return pageContext && pageContext.entity ? pageContext.entity.request : {};
+  };
+  func.getPage = function() {
+    return pageContext && pageContext.entity ? pageContext.entity.page : {};
+  };
+  func.getCustomFunc = function(funcName) {
+    return getCustomFunc(pageContext, funcName);
+  };
+}
+function removeCustomFuncFromWindow(pageDesign) {
+  if (pageDesign && pageDesign.customEvents) {
+    const customEvents = pageDesign.customEvents;
+    const customFuncs = customEvents.filter((item) => item.name === "customFunc" && item.jsContent);
+    if (customFuncs && customFuncs.length > 0) {
+      customFuncs.forEach((event) => {
+        delete window["$page_" + event.eventName];
+      });
+    }
+  }
+}
+function handleEvent($event, pageContext, configure, eventType, otherParams) {
+  return handleEventUtil($event, pageContext, configure, eventType, true, otherParams, false);
+}
+function handleFormEvent($event, pageContext, configure, eventType, otherParams) {
+  var _a, _b;
+  if (eventType && eventType === "change") {
+    const subTableWatchProps = pageContext.subTableWatchProps;
+    if (subTableWatchProps) {
+      for (const tableUuid in subTableWatchProps) {
+        const mainFormProps = subTableWatchProps[tableUuid];
+        const propName = (_b = (_a = configure.props) == null ? void 0 : _a.base) == null ? void 0 : _b.prop;
+        if (mainFormProps && mainFormProps.indexOf(propName) >= 0) {
+          eventBus.$emit("_refreshSubTable_" + tableUuid, { propName });
+        }
+      }
+    }
+  }
+  return handleEventUtil($event, pageContext, configure, eventType, true, otherParams, true);
+}
+function handleAfterInitEvent($event, pageContext, configure, otherParams) {
+  return handleFormEvent($event, pageContext, configure, "afterInit", otherParams);
+}
+function getHandleEvent($event, pageContext, configure, eventType, otherParams) {
+  return handleEventUtil($event, pageContext, configure, eventType, false, otherParams, false);
+}
+function handleEventUtil($event, pageContext, configure, eventType, isExecute, otherParams, skipValidate) {
+  const events = configure && configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  let eventFun;
+  if (!skipValidate && isClickEvent(eventType)) {
+    const eventParams = getDefaultEventParams($event, pageContext, configure, otherParams);
+    buttonClickEvent(pageContext, configure, eventParams);
+  } else {
+    eventFun = getEventFuncByType(pageContext, events, eventType);
+    if (isExecute) {
+      const eventParams = packageEventParams(pageContext, configure, $event, otherParams);
+      return callItemEvent(pageContext, configure, eventFun, eventParams);
+    } else {
+      return eventFun;
+    }
+  }
+}
+const clickEvents = ["click", "suffixClick", "prefixClick", "menuClick"];
+function isClickEvent(eventType) {
+  return eventType && clickEvents.indexOf(eventType) >= 0;
+}
+function getTableUuid(pageContext, configure) {
+  return configure.props.base.tableUuid ? configure.props.base.tableUuid : pageContext.tableUuids && pageContext.tableUuids.length > 0 ? pageContext.tableUuids[0] : null;
+}
+function packageEventParams(pageContext, configureObj, $event, otherParams) {
+  const params = {};
+  if (otherParams) {
+    for (const key in otherParams) {
+      params[key] = otherParams[key];
+    }
+  }
+  if ($event !== void 0 && $event !== null) {
+    params["_value"] = $event;
+  }
+  if (pageContext) {
+    params["pageContext"] = pageContext;
+  }
+  if (configureObj) {
+    params["configureObj"] = configureObj;
+  }
+  return params;
+}
+function buttonClickEvent(pageContext, configure, eventParams) {
+  const judgeFlag = standardEvent.judgeDataNumber(configure, eventParams["ids"]);
+  if (!judgeFlag) {
+    return;
+  }
+  if (pageContext.canClick !== void 0 && pageContext.canClick === false) {
+    console.log("不能重复点击");
+    return;
+  }
+  canExecuteButton(eventParams).then((result) => {
+    if (result["canExecute"] === true) {
+      pageContext.clickUuid = configure.uuid;
+      pageContext.canClick = false;
+      const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+      const beforeValidateFormFunc = getEventFuncByType(pageContext, events, "beforeValidateForm");
+      let beforeValidateFormResult;
+      if (beforeValidateFormFunc) {
+        beforeValidateFormResult = callItemEvent(pageContext, configure, beforeValidateFormFunc, eventParams);
+      }
+      if (beforeValidateFormResult === void 0) {
+        beforeValidateFormResult = true;
+      }
+      if (!beforeValidateFormResult) {
+        pageContext.canClick = true;
+        return;
+      }
+      if (commonUtil.isPromise(beforeValidateFormResult)) {
+        beforeValidateFormResult.then((result2) => {
+          if (result2 && result2 === true) {
+            doValidateForm(pageContext, configure, eventParams);
+          } else {
+            pageContext.canClick = true;
+          }
+        }).catch((error) => {
+          console.log(error);
+          pageContext.canClick = true;
+        });
+      } else {
+        doValidateForm(pageContext, configure, eventParams);
+      }
+    }
+  });
+}
+function doValidateForm(pageContext, configure, eventParams) {
+  const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  let isEnableRequired = true;
+  console.log("doValidateForm---eventParams=", eventParams);
+  if (eventParams == null ? void 0 : eventParams.skipValidate) {
+    isEnableRequired = false;
+  }
+  const clickEventFunObj = getClickEventFuncByType(pageContext, events, "click");
+  if (clickEventFunObj) {
+    const isStandardEvent = clickEventFunObj.isStandard;
+    const event = clickEventFunObj.event;
+    const isNotNeedValidate = isNotNeedValidateRequired(isStandardEvent, event);
+    if (isNotNeedValidate) {
+      isEnableRequired = false;
+    }
+  }
+  validatorUtil.validateDataModelFunc(pageContext, configure, isEnableRequired).then((validateReslut) => {
+    if (!validateReslut) {
+      pageContext.canClick = true;
+      return;
+    }
+    const beforeClickResult = doBeforeClickEvent(pageContext, configure, eventParams);
+    if (!beforeClickResult) {
+      pageContext.canClick = true;
+      return;
+    }
+    if (commonUtil.isPromise(beforeClickResult)) {
+      beforeClickResult.then((result) => {
+        if (result) {
+          doClickEvent(pageContext, configure, clickEventFunObj, eventParams);
+        } else {
+          pageContext.canClick = true;
+        }
+      }).catch((error) => {
+        console.error(error);
+        pageContext.canClick = true;
+      });
+    } else {
+      doClickEvent(pageContext, configure, clickEventFunObj, eventParams);
+    }
+  }).catch((error) => {
+    console.error(error);
+    pageContext.canClick = true;
+  });
+}
+function doSuffixOrPrefixClickEvent($event, pageContext, configure, eventType, otherParams) {
+  const eventParams = getDefaultEventParams($event, pageContext, configure, otherParams);
+  const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  const clickEventFunObj = getClickEventFuncByType(pageContext, events, eventType);
+  doClickEvent(pageContext, configure, clickEventFunObj, eventParams);
+}
+function getDefaultEventParams($event, pageContext, configure, otherParams) {
+  const pageCode = pageContext.code;
+  const pageVersion = pageContext.version;
+  const tableUuid = getTableUuid(pageContext, configure);
+  if (tableUuid) {
+    const gridRef = globalRefs.getComponentRef(pageContext, tableUuid);
+    const selections = gridRef ? gridRef.getSelections() : null;
+    const selectionIds = gridRef ? gridRef.getSelectionIds() : null;
+    if (!otherParams) {
+      otherParams = {};
+    }
+    otherParams["tableUuid"] = tableUuid;
+    otherParams["listCode"] = commonUtil$1.getListCode(pageCode, pageVersion, tableUuid);
+    const isListButton = isListPage(pageContext);
+    if (isListButton) {
+      otherParams["selections"] = selections;
+      otherParams["id"] = selectionIds && selectionIds.length > 0 ? selectionIds[0] : null;
+      otherParams["ids"] = selectionIds;
+    }
+    const tableConfigure = gridRef ? gridRef.getTableConfigure() : null;
+    otherParams["tableConfigure"] = tableConfigure;
+  }
+  return packageEventParams(pageContext, configure, $event, otherParams);
+}
+function doBeforeClickEvent(pageContext, configure, otherParams) {
+  const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  const beforeClickFunc = getEventFuncByType(pageContext, events, "beforeClick");
+  let beforeClickResult;
+  if (beforeClickFunc) {
+    beforeClickResult = callItemEvent(pageContext, configure, beforeClickFunc, null, otherParams);
+  }
+  if (beforeClickResult === void 0) {
+    return true;
+  }
+  return beforeClickResult;
+}
+function doClickJumpPageEvent(pageContext, configure, eventParams) {
+  const myPageCode = pageContext.code;
+  const eventPageInfo = myPageCode + "_";
+  eventBus.$emit(eventPageInfo + "open-dialog", {
+    pageContext,
+    configureObj: configure,
+    eventParams
+  });
+}
+function isListPage(pageContext, configure) {
+  return pageContext.pageType && pageContext.pageType === "list" ? true : false;
+}
+function doClickCustomEvent(pageContext, configure, clickEventFuncObj, eventParams) {
+  const eventFunObj = clickEventFuncObj;
+  const isListButton = isListPage(pageContext);
+  if (eventFunObj) {
+    const eventFun = eventFunObj["func"];
+    const isStandardEvent = eventFunObj["isStandard"];
+    const event = eventFunObj["event"];
+    const clickResult = callItemEvent(pageContext, configure, eventFun, eventParams);
+    if (isNotDoAfterClick(isStandardEvent, event)) {
+      pageContext.canClick = true;
+      return;
+    }
+    if (commonUtil.isPromise(clickResult)) {
+      clickResult.then((result) => {
+        if (result) {
+          doAfterClickFunc(pageContext, configure, eventParams, isStandardEvent, result, isListButton);
+        } else {
+          pageContext.canClick = true;
+        }
+      }).catch((error) => {
+        console.error(error);
+        pageContext.canClick = true;
+      });
+    } else {
+      doAfterClickFunc(pageContext, configure, eventParams, isStandardEvent, clickResult, isListButton);
+    }
+  } else {
+    doAfterClickFunc(pageContext, configure, eventParams, false, null, isListButton);
+  }
+}
+function isNotDoAfterClick(isStandardEvent, clickEvent) {
+  return isStandardEvent && (clickEvent.eventName === "exportForm" || clickEvent.eventName === "exportPDF" || clickEvent.eventName === "import" || clickEvent.eventName === "assign" || clickEvent.eventName === "copyTask" || clickEvent.eventName === "addSigner" || clickEvent.eventName === "returnTaskTo" || clickEvent.eventName === "removeSigner" || clickEvent.eventName === "saveQueryCharts" || clickEvent.eventName === "addTransactor" || clickEvent.eventName === "removeTransactor");
+}
+function isNotNeedValidateRequired(isStandardEvent, clickEvent) {
+  return isStandardEvent && skipValidateEvents.includes(clickEvent.eventName);
+}
+function doAfterClickEvent(pageContext, configure, otherParams) {
+  const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  const afterClickFunc = getEventFuncByType(pageContext, events, "afterClick");
+  if (afterClickFunc) {
+    const afterFunc = callItemEvent(pageContext, configure, afterClickFunc, null, otherParams);
+    if (commonUtil.isPromise(afterFunc)) {
+      afterFunc.finally(() => {
+        pageContext.canClick = true;
+      });
+    } else {
+      pageContext.canClick = true;
+    }
+  } else {
+    pageContext.canClick = true;
+  }
+}
+function doAfterClickFunc(pageContext, configure, eventParams, isStandardEvent, result, isListButton) {
+  if (!isStandardEvent) {
+    standardEvent.dealAfterOperate(
+      pageContext,
+      configure,
+      result,
+      "",
+      // superPageRuntimeMessage.successfulOperation 开发人员自己加事件
+      isListButton
+    );
+  } else {
+    pageContext.result = result;
+    pageContext.canClick = true;
+  }
+  const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  const afterClickFunc = getEventFuncByType(pageContext, events, "afterClick");
+  if (afterClickFunc) {
+    callItemEvent(pageContext, configure, afterClickFunc, eventParams);
+  }
+}
+function doClickEvent(pageContext, configure, clickEventFunObj, eventParams) {
+  let configureObj = configure;
+  let linkPage = configure.props.linkPage;
+  if (linkPage && linkPage instanceof Array) {
+    const row = getRowData(eventParams);
+    const result = tableUtils.expressJump(pageContext, configure, linkPage, row);
+    let show = false;
+    let toLinkPage;
+    if (result) {
+      show = result.show;
+      toLinkPage = show ? result.toPage : null;
+    }
+    linkPage = toLinkPage ? toLinkPage.linkPage : null;
+    if (linkPage) {
+      configureObj = commonUtil$1.deepCopy(configure);
+      configureObj.props.linkPage = linkPage;
+    }
+  }
+  if (linkPage && linkPage.jumpPageUrl) {
+    pageContext.canClick = true;
+    doClickJumpPageEvent(pageContext, configureObj, eventParams);
+  } else {
+    doClickCustomEvent(pageContext, configure, clickEventFunObj, eventParams);
+  }
+}
+function getRowData(eventParams) {
+  let row = eventParams ? eventParams.row : null;
+  if (!row) {
+    row = eventParams && eventParams.selections && eventParams.selections.length > 0 ? eventParams.selections[0] : null;
+  }
+  return row;
+}
+function getEventByEventName(pageContext, eventObj) {
+  const eventsObj = pageContext.customEvents;
+  if (eventsObj && eventObj) {
+    let key = "";
+    if (typeof eventObj === "object") {
+      key = eventObj.componentUuid + "_" + eventObj.name;
+    } else {
+      key = eventObj;
+    }
+    return eventsObj[key];
+  }
+}
+function getEventFuncByType(pageContext, events, eventType) {
+  if (events && eventType) {
+    const eventArr = events.filter((item) => item.name === eventType);
+    if (eventArr && eventArr.length > 0) {
+      const event = eventArr[0];
+      if (event.isStandard) {
+        return standardEvent.standardEvents[event.eventName];
+      } else {
+        return getEventByEventName(pageContext, event);
+      }
+    }
+  }
+}
+function getEventNameByType(events, eventType) {
+  if (events && eventType) {
+    const eventArr = events.filter((item) => item.name === eventType);
+    if (eventArr && eventArr.length > 0) {
+      const event = eventArr[0];
+      return event.eventName;
+    }
+  }
+}
+function getClickEventFuncByType(pageContext, events, eventType) {
+  if (events && eventType) {
+    const eventArr = events.filter((item) => item.name === eventType);
+    if (eventArr && eventArr.length > 0) {
+      const event = eventArr[0];
+      if (event.isStandard) {
+        return { func: standardEvent.standardEvents[event.eventName], isStandard: true, event };
+      } else {
+        return {
+          func: getEventByEventName(pageContext, event),
+          isStandard: false,
+          event
+        };
+      }
+    }
+  }
+}
+function callItemEvent(pageContext, configureObj, eventFun, eventParams, otherParams) {
+  if (!eventFun) {
+    return;
+  }
+  if (!eventParams) {
+    eventParams = {
+      pageContext,
+      configureObj
+      // 组件配置信息，包含如：跳转页面配置、判重配置等
+    };
+  }
+  if (otherParams && eventParams) {
+    for (const key in otherParams) {
+      eventParams[key] = otherParams[key];
+    }
+  }
+  return eventFun.apply(eventFun, [eventParams]);
+}
+function transferToFunction(customEvents) {
+  const eventsObj = {};
+  customEvents.forEach((event) => {
+    if (!event.isStandard && event.jsContent) {
+      if (event.name === "customFunc") {
+        let newFunc = null;
+        if (event.funcParam) {
+          const args = event.funcParam.split(",");
+          newFunc = new Function(args, event.jsContent);
+        } else {
+          newFunc = new Function(event.jsContent);
+        }
+        eventsObj[event.eventName] = newFunc;
+      } else {
+        let key = event.componentUuid + "_";
+        key += event.name;
+        eventsObj[key] = new Function("params", event.jsContent);
+      }
+    }
+  });
+  return eventsObj;
+}
+function canExecuteButton(params) {
+  const pageContext = params.pageContext;
+  const configureObj = params.configureObj;
+  const isListButton = isListPage(pageContext);
+  let entities = [];
+  if (isListButton) {
+    if (pageContext.editData) {
+      entities.push(pageContext.editData);
+    } else {
+      entities = params.selections;
+    }
+  } else {
+    const dataModel = pageContext.entity.data;
+    entities.push(dataModel);
+  }
+  const executableDataSetting = configureObj.props.base.condition;
+  return new Promise((resolve, reject) => {
+    if (executableDataSetting === void 0 || executableDataSetting === null || executableDataSetting === "" || entities === void 0 || entities === null || entities.length === 0) {
+      resolve({
+        canExecute: true
+      });
+    } else {
+      const contextParameter = pageContext.entity.context;
+      const additionalParamMap = standardEvent.getAdditionalParamMap(pageContext);
+      const isSql = true;
+      const tableName = pageContext.tableName;
+      let isCanExecute = true;
+      let failMessage;
+      let failEntity;
+      for (let i = 0; i < entities.length; i++) {
+        const entity = entities[i];
+        for (let n = 0; n < executableDataSetting.length; n++) {
+          const conditionSetting = executableDataSetting[n];
+          const message = conditionSetting.toolTips;
+          const conditionList = conditionSetting.conditionList;
+          const canExecute = util.analysisCondition(
+            conditionList,
+            entity,
+            additionalParamMap,
+            contextParameter,
+            isSql,
+            tableName,
+            null,
+            pageContext
+          );
+          if (!canExecute) {
+            isCanExecute = false;
+            failMessage = message;
+            failEntity = entity;
+            break;
+          }
+        }
+      }
+      if (!isCanExecute) {
+        if (failMessage) {
+          index.ElMessage({
+            showClose: true,
+            type: "warning",
+            message: failMessage
+          });
+        }
+        resolve({
+          canExecute: false,
+          message: failMessage,
+          failEntity
+        });
+      } else {
+        resolve({
+          canExecute: true
+        });
+      }
+    }
+  });
+}
+function setTableEvents(options, tableEvents, pageContext, configureObj) {
+  if (tableEvents) {
+    addTableEvent("loadBeforeSend", loadBeforeSend({ pageContext, configureObj }), options);
+    addTableEvent("beforeRequest", beforeRequest({ pageContext, configureObj }), options);
+    addTableEvent("gridDataLoaded", gridDataLoaded({ pageContext, configureObj }), options);
+    addTableEvent("gridComplete", gridComplete({ pageContext, configureObj }), options);
+    addTableEvent("resizeHeight", resizeTableHeight({ pageContext, configureObj }), options);
+    if (!options["lineEditOptions"]) {
+      options["lineEditOptions"] = {};
+    }
+    addTableEvent("beforeInsertRow", gridBeforeInsertRow({ pageContext, configureObj }), options["lineEditOptions"]);
+    addTableEvent("afterInsertRow", gridAfterInsertRow({ pageContext, configureObj }), options["lineEditOptions"]);
+    addTableEvent("beforeDelete", gridBeforeRemoveRow({ pageContext, configureObj }), options["lineEditOptions"]);
+    addTableEvent("afterDelete", gridAfterRemoveRow({ pageContext, configureObj }), options["lineEditOptions"]);
+    addTableEvent("beforeEdit", gridBeforeEdit({ pageContext, configureObj }), options["lineEditOptions"]);
+    addTableEvent("beforeRestore", beforeRestore({ pageContext, configureObj }), options["lineEditOptions"]);
+    addTableEvent(
+      "beforeRestoreValidate",
+      beforeRestoreValidate({ pageContext, configureObj }),
+      options["lineEditOptions"]
+    );
+    filterDataEvent(
+      "filterDataEvent",
+      getHandleEvent(null, pageContext, configureObj, "filter-data", {
+        pageContext,
+        configureObj
+      }),
+      options
+    );
+  }
+}
+function filterDataEvent(gridEventType, eventFunc, options) {
+  if (eventFunc) {
+    options[gridEventType] = eventFunc;
+  }
+}
+function addTableEvent(gridEventType, eventFunc, options) {
+  if (eventFunc) {
+    options[gridEventType] = eventFunc;
+  }
+}
+function loadBeforeSend(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeListLoad", params);
+}
+function beforeRequest(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeRequest", params);
+}
+function gridDataLoaded(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "onListLoad", params);
+}
+function gridComplete(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "afterListLoad", params);
+}
+function resizeTableHeight(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "resizeTableHeight", params);
+}
+function beforeRestoreValidate(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeRestoreValidate", params);
+}
+function beforeRestore(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeRestore", params);
+}
+function gridBeforeEdit(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeEdit", params);
+}
+function gridBeforeInsertRow(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeAddRow", params);
+}
+function gridAfterInsertRow(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "afterAddRow", params);
+}
+function gridBeforeRemoveRow(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeRemoveRow", params);
+}
+function gridAfterRemoveRow(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "afterRemoveRow", params);
+}
+function gridSelectRecord(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "select", params);
+}
+function gridSelectAllRecords(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "select-all", params);
+}
+function gridSelectionChange(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "selection-change", params);
+}
+function cellClick(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "cell-click", params);
+}
+function cellDblClick(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "cell-dblclick", params);
+}
+function rowClick(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "row-click", params);
+}
+function rowDblClick(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "row-dblclick", params);
+}
+function headerClick(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "header-click", params);
+}
+function fileUploadBeforeUpload(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "before-upload", params);
+}
+function isShowComponent(configure) {
+  let isShow = true;
+  const isMobile = commonUtil.isMobileBrowser();
+  if (!isMobile) {
+    const events = configure && configure.events ? configure.events : [];
+    if (events) {
+      const eventArr = events.filter(
+        (item) => item.name === "click" && item.isStandard && item.eventName && item.eventName === "showSearch"
+      );
+      if (eventArr && eventArr.length > 0) {
+        isShow = false;
+      }
+    }
+  }
+  return isShow;
+}
+function handleChartEvent(pageContext, configure, eventType, chartOption, otherParams) {
+  const events = configure && configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  const eventFun = getEventFuncByType(pageContext, events, eventType);
+  return callItemEvent(pageContext, configure, eventFun, {
+    configure,
+    pageContext,
+    chartOption,
+    ...otherParams
+  });
+}
+function isShowMobileEvent(pageContext, configure) {
+  let isShow = true;
+  const isMobile = commonUtil.isMobileBrowser();
+  if (isMobile) {
+    const events = configure && configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+    const clickEventFunObj = getClickEventFuncByType(pageContext, events, "click");
+    if (clickEventFunObj) {
+      const isStandardEvent = clickEventFunObj.isStandard;
+      const event = clickEventFunObj.event;
+      const userAgentOrg = navigator ? navigator.userAgent : null;
+      if (isStandardEvent && userAgentOrg) {
+        if (userAgentOrg.indexOf(" uni-app ") > 0) {
+          if (exportEvents.includes(event.eventName) || importEvents.includes(event.eventName)) {
+            isShow = false;
+          }
+        } else {
+          if (importEvents.includes(event.eventName)) {
+            isShow = false;
+          }
+        }
+      }
+    }
+  }
+  return isShow;
+}
+exports.appendDefaultMethods = appendDefaultMethods;
+exports.canExecuteButton = canExecuteButton;
+exports.cellClick = cellClick;
+exports.cellDblClick = cellDblClick;
+exports.doAfterClickEvent = doAfterClickEvent;
+exports.doBeforeClickEvent = doBeforeClickEvent;
+exports.doClickJumpPageEvent = doClickJumpPageEvent;
+exports.doSuffixOrPrefixClickEvent = doSuffixOrPrefixClickEvent;
+exports.fileUploadBeforeUpload = fileUploadBeforeUpload;
+exports.getClickEventFuncByType = getClickEventFuncByType;
+exports.getCustomFunc = getCustomFunc;
+exports.getEventFuncByType = getEventFuncByType;
+exports.getEventNameByType = getEventNameByType;
+exports.getHandleEvent = getHandleEvent;
+exports.getTableUuid = getTableUuid;
+exports.gridSelectAllRecords = gridSelectAllRecords;
+exports.gridSelectRecord = gridSelectRecord;
+exports.gridSelectionChange = gridSelectionChange;
+exports.handleAfterInitEvent = handleAfterInitEvent;
+exports.handleChartEvent = handleChartEvent;
+exports.handleEvent = handleEvent;
+exports.handleFormEvent = handleFormEvent;
+exports.headerClick = headerClick;
+exports.initPageEvents = initPageEvents;
+exports.isShowComponent = isShowComponent;
+exports.isShowMobileEvent = isShowMobileEvent;
+exports.removeCustomFuncFromWindow = removeCustomFuncFromWindow;
+exports.rowClick = rowClick;
+exports.rowDblClick = rowDblClick;
+exports.setTableEvents = setTableEvents;