super-page-runtime 0.0.1-tmp2

package/lib/src/utils/common-util.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const commonUtil = require("agilebuilder-ui/src/utils/common-util");
+const util = require("agilebuilder-ui/src/utils/util");
+function isArrayFn(value) {
+  if (typeof Array.isArray === "function") {
+    return Array.isArray(value);
+  } else {
+    return Object.prototype.toString.call(value) === "[object Array]";
+  }
+}
+function getBaseUrl(system) {
+  let baseUrl = window["$vueApp"].config.globalProperties.baseURL;
+  if (system) {
+    baseUrl = commonUtil.getSystemBackendUrl(system.backendUrl);
+  }
+  return baseUrl;
+}
+function getRealRestApiPath(orgRestApiPath, system) {
+  let path = orgRestApiPath;
+  if (orgRestApiPath) {
+    if (system && !isFullPath(orgRestApiPath)) {
+      const baseUrl = getBaseUrl(system);
+      if (system.standard === false) {
+        path = baseUrl + "/" + system.code + orgRestApiPath;
+      } else {
+        path = baseUrl + orgRestApiPath;
+      }
+    }
+  }
+  return path;
+}
+function isFullPath(path) {
+  return path.indexOf("http:") === 0 || path.indexOf("https:") === 0;
+}
+function packageTemplateFiles(templateFiles) {
+  if (!templateFiles) {
+    return templateFiles;
+  }
+  const currentLocale = util.getLanguageWithLocale();
+  if (Array.isArray(templateFiles)) {
+    let templateFilesResult = [];
+    let fileCodes = [];
+    const fileSeperate = "~-~-";
+    templateFiles.forEach((template) => {
+      let showName = template.templateShowPath;
+      if (showName.indexOf(fileSeperate) > 0) {
+        const fileCode = showName.substring(0, showName.indexOf(fileSeperate));
+        const fileLanguage = showName.substring(
+          showName.indexOf(fileSeperate) + fileSeperate.length,
+          showName.lastIndexOf(fileSeperate)
+        );
+        const fileName = showName.substring(
+          showName.lastIndexOf(fileSeperate) + fileSeperate.length
+        );
+        if (currentLocale === fileLanguage && fileCodes.indexOf(fileCode) < 0) {
+          templateFilesResult.push({
+            templateUUID: template.templateUUID,
+            templateShowPath: fileName
+          });
+          fileCodes.push(fileCode);
+        }
+      } else {
+        templateFilesResult.push(template);
+      }
+    });
+    return templateFilesResult;
+  }
+}
+function upperFirstCase(str) {
+  return str.toLowerCase().replace(/( |^)[a-z]/g, (L) => L.toUpperCase());
+}
+function getListCode(pageCode, pageVersion, tableUuid) {
+  return pageCode + ":V" + pageVersion + ":" + tableUuid;
+}
+exports.getBaseUrl = getBaseUrl;
+exports.getListCode = getListCode;
+exports.getRealRestApiPath = getRealRestApiPath;
+exports.isArrayFn = isArrayFn;
+exports.packageTemplateFiles = packageTemplateFiles;
+exports.upperFirstCase = upperFirstCase;

package/lib/src/utils/events/event-util.d.ts

@@ -0,0 +1,48 @@
+import { Component, PageContext, PageDesign } from '../../utils/interfaces/page-design-types';
+
+/**
+ * 缓存页面事件，并转为Function对象，并绑定自定义方法到window对象上
+ * @param pageDesign
+ */
+export declare function initPageEvents(pageDesign: PageDesign, pageContext: PageContext): void;
+/**
+ * 页面销毁时，将window上注册的函数移除掉
+ * @param pageDesign
+ */
+export declare function removeCustomFuncFromWindow(pageDesign: PageDesign): void;
+export declare function handleEvent($event: any, pageContext: PageContext, configure: Component, eventType: string, otherParams?: object): any;
+export declare function getHandleEvent($event: any, pageContext: PageContext, configure: Component, eventType: string, otherParams?: object): any;
+export declare function doBeforeClickEvent(pageContext: PageContext, configure: Component, otherParams?: object): any;
+export declare function doAfterClickEvent(pageContext: PageContext, configure: Component, otherParams?: object): void;
+/**
+ * 获得事件Function对象
+ * @param events 该组件所有事件集合
+ * @param eventType change、click等事件类型
+ */
+export declare function getEventFuncByType(pageContext: PageContext, events: Array<any>, eventType: string): any;
+/**
+ * 获得事件Function对象
+ * @param events 该组件所有事件集合
+ * @param eventType change、click等事件类型
+ */
+export declare function getClickEventFuncByType(pageContext: PageContext, events: Array<any>, eventType: string): {
+    func: any;
+    isStandard: boolean;
+    event: any;
+};
+/**
+ * 按钮是否可执行条件解析
+ * @param params
+ * @returns
+ */
+export declare function canExecuteButton(params: any): Promise<unknown>;
+export declare function canVisibleComponent(params: any): Promise<unknown>;
+export declare function setTableEvents(options: any, tableEvents: any, pageContext: any, configureObj: any): void;
+export declare function gridSelectRecord(pageContext: any, configureObj: any, params: any): any;
+export declare function gridSelectAllRecords(pageContext: any, configureObj: any, params: any): any;
+export declare function gridSelectionChange(pageContext: any, configureObj: any, params: any): any;
+export declare function cellClick(pageContext: any, configureObj: any, params: any): any;
+export declare function cellDblClick(pageContext: any, configureObj: any, params: any): any;
+export declare function rowClick(pageContext: any, configureObj: any, params: any): any;
+export declare function rowDblClick(pageContext: any, configureObj: any, params: any): any;
+export declare function headerClick(pageContext: any, configureObj: any, params: any): any;

package/lib/src/utils/events/event-util.js

@@ -0,0 +1,525 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const commonUtil$1 = require("agilebuilder-ui/src/utils/common-util");
+const standardEvent = require("./standard-event.js");
+const validatorUtil = require("./validator-util.js");
+const globalRefs = require("../global-refs.js");
+const elementPlus = require("element-plus");
+const util = require("agilebuilder-ui/src/utils/util");
+const commonUtil = require("../common-util.js");
+function initPageEvents(pageDesign, pageContext) {
+  if (pageDesign && pageDesign.customEvents) {
+    pageContext.customEvents = transferToFunction(pageDesign.customEvents);
+  }
+}
+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);
+}
+function getHandleEvent($event, pageContext, configure, eventType, otherParams) {
+  return handleEventUtil($event, pageContext, configure, eventType, false, otherParams);
+}
+function handleEventUtil($event, pageContext, configure, eventType, isExecute, otherParams) {
+  const pageCode = pageContext.code;
+  const pageVersion = pageContext.version;
+  const events = configure.events;
+  const componentType = configure.name;
+  let eventFun;
+  if (eventType && eventType === "click" && componentType === "button-detail") {
+    const tableUuid = configure.props.base.tableUuid ? configure.props.base.tableUuid : pageContext.tableUuids && pageContext.tableUuids.length > 0 ? pageContext.tableUuids[0] : null;
+    if (tableUuid) {
+      const gridRef = globalRefs.getComponentRef(pageContext, tableUuid);
+      const selections = gridRef.getSelections();
+      const selectionIds = gridRef.getSelectionIds();
+      if (!otherParams) {
+        otherParams = {};
+      }
+      otherParams["tableUuid"] = tableUuid;
+      otherParams["listCode"] = commonUtil.getListCode(pageCode, pageVersion, tableUuid);
+      const isListButton = isListPage(pageContext);
+      if (isListButton) {
+        otherParams["selections"] = selections;
+        otherParams["ids"] = selectionIds;
+      }
+      const tableConfigure = gridRef.getTableConfigure();
+      otherParams["tableConfigure"] = tableConfigure;
+    }
+    const eventParams = packageEventParams(pageContext, configure, $event, 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;
+    }
+  }
+}
+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;
+  }
+  params["pageContext"] = pageContext;
+  params["configureObj"] = configureObj;
+  return params;
+}
+function buttonClickEvent(pageContext, configure, eventParams) {
+  const judgeFlag = standardEvent.judgeDataNumber(configure, eventParams["ids"]);
+  if (!judgeFlag) {
+    return;
+  }
+  canExecuteButton(eventParams).then((result) => {
+    if (result["canExecute"] === true) {
+      const events = configure.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) {
+        return;
+      }
+      if (commonUtil$1.isPromise(beforeValidateFormResult)) {
+        beforeValidateFormResult.then((result2) => {
+          if (result2 && result2 === true) {
+            doValidateForm(pageContext, configure, eventParams);
+          }
+        });
+      } else {
+        doValidateForm(pageContext, configure, eventParams);
+      }
+    }
+  });
+}
+function doValidateForm(pageContext, configure, eventParams) {
+  const events = configure.events;
+  let isEnableRequired;
+  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(() => {
+    const beforeClickResult = doBeforeClickEvent(pageContext, configure, eventParams);
+    if (!beforeClickResult) {
+      return;
+    }
+    if (commonUtil$1.isPromise(beforeClickResult)) {
+      beforeClickResult.then((result) => {
+        if (result) {
+          doClickEvent(pageContext, configure, clickEventFunObj, eventParams);
+        }
+      });
+    } else {
+      doClickEvent(pageContext, configure, clickEventFunObj, eventParams);
+    }
+  });
+}
+function doBeforeClickEvent(pageContext, configure, otherParams) {
+  let result = true;
+  const events = configure.events;
+  const beforeClickFunc = getEventFuncByType(pageContext, events, "beforeClick");
+  let beforeClickResult;
+  if (beforeClickFunc) {
+    beforeClickResult = callItemEvent(pageContext, configure, beforeClickFunc, null, otherParams);
+  }
+  if (beforeClickResult === void 0) {
+    result = true;
+  }
+  return result;
+}
+function doClickJumpPageEvent(pageContext, configure, eventParams) {
+  const myPageCode = pageContext.code;
+  const eventPageInfo = myPageCode + "_";
+  window["$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;
+  if (eventFunObj) {
+    const eventFun = eventFunObj["func"];
+    const isStandardEvent = eventFunObj["isStandard"];
+    const event = eventFunObj["event"];
+    const clickResult = callItemEvent(pageContext, configure, eventFun, eventParams);
+    const isListButton = isListPage(pageContext);
+    if (isNotDoAfterClick(isStandardEvent, event)) {
+      return;
+    }
+    if (commonUtil$1.isPromise(clickResult)) {
+      clickResult.then((result) => {
+        if (result) {
+          doAfterClickFunc(
+            pageContext,
+            configure,
+            eventParams,
+            isStandardEvent,
+            result,
+            isListButton
+          );
+        }
+      });
+    } else {
+      doAfterClickFunc(
+        pageContext,
+        configure,
+        eventParams,
+        isStandardEvent,
+        clickResult,
+        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");
+}
+function isNotNeedValidateRequired(isStandardEvent, clickEvent) {
+  return isStandardEvent && (clickEvent.eventName === "downloadTemplate" || clickEvent.eventName === "back" || clickEvent.eventName === "exportForm" || clickEvent.eventName === "exportPDF" || clickEvent.eventName === "lineEditCreate");
+}
+function doAfterClickEvent(pageContext, configure, otherParams) {
+  const events = configure.events;
+  const afterClickFunc = getEventFuncByType(pageContext, events, "afterClick");
+  if (afterClickFunc) {
+    callItemEvent(pageContext, configure, afterClickFunc, null, otherParams);
+  }
+}
+function doAfterClickFunc(pageContext, configure, eventParams, isStandardEvent, result, isListButton) {
+  if (!isStandardEvent) {
+    standardEvent.dealAfterOperate(
+      pageContext,
+      configure,
+      result,
+      "superPageRuntimeMessage.successfulOperation",
+      isListButton
+    );
+  } else {
+    pageContext.result = result;
+  }
+  const events = configure.events;
+  const afterClickFunc = getEventFuncByType(pageContext, events, "afterClick");
+  if (afterClickFunc) {
+    callItemEvent(pageContext, configure, afterClickFunc, eventParams);
+  }
+}
+function doClickEvent(pageContext, configure, clickEventFunObj, eventParams) {
+  const linkPage = configure.props.linkPage;
+  if (linkPage && linkPage.jumpPageUrl) {
+    doClickJumpPageEvent(pageContext, configure, eventParams);
+  } else {
+    doClickCustomEvent(pageContext, configure, clickEventFunObj, eventParams);
+  }
+}
+function getEventByEventName(pageContext, eventName) {
+  const eventsObj = pageContext.customEvents;
+  if (eventsObj && eventsObj[eventName]) {
+    return eventsObj[eventName];
+  }
+}
+function getEventFuncByType(pageContext, events, eventType) {
+  if (events && eventType) {
+    const eventArr = events.filter((item) => item.name === eventType && item.eventName);
+    if (eventArr && eventArr.length > 0) {
+      const event = eventArr[0];
+      if (event.isStandard) {
+        return standardEvent.standardEvents[event.eventName];
+      } else {
+        return getEventByEventName(pageContext, event.eventName);
+      }
+    }
+  }
+}
+function getClickEventFuncByType(pageContext, events, eventType) {
+  if (events && eventType) {
+    const eventArr = events.filter((item) => item.name === eventType && item.eventName);
+    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.eventName),
+          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(eventParams);
+}
+function transferToFunction(customEvents) {
+  const eventsObj = {};
+  customEvents.forEach((event) => {
+    if (event.jsContent) {
+      eventsObj[event.eventName] = new Function("params", event.jsContent);
+      if (event.name === "customFunc") {
+        if (event.funcParam) {
+          window["$page_" + event.eventName] = new Function(event.funcParam, event.jsContent);
+        } else {
+          window["$page_" + event.eventName] = new Function(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 === "" || entities === void 0 || entities.length === 0) {
+      resolve({
+        canExecute: true
+      });
+    } else {
+      const contextParameter = pageContext.entity.context;
+      const additionalParamMap = pageContext.entity.request;
+      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
+          );
+          if (!canExecute) {
+            isCanExecute = false;
+            failMessage = message;
+            failEntity = entity;
+            break;
+          }
+        }
+      }
+      if (!isCanExecute) {
+        if (failMessage) {
+          elementPlus.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"]
+    );
+  }
+}
+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);
+}
+exports.canExecuteButton = canExecuteButton;
+exports.cellClick = cellClick;
+exports.cellDblClick = cellDblClick;
+exports.doAfterClickEvent = doAfterClickEvent;
+exports.doBeforeClickEvent = doBeforeClickEvent;
+exports.getClickEventFuncByType = getClickEventFuncByType;
+exports.getEventFuncByType = getEventFuncByType;
+exports.getHandleEvent = getHandleEvent;
+exports.gridSelectAllRecords = gridSelectAllRecords;
+exports.gridSelectRecord = gridSelectRecord;
+exports.gridSelectionChange = gridSelectionChange;
+exports.handleEvent = handleEvent;
+exports.headerClick = headerClick;
+exports.initPageEvents = initPageEvents;
+exports.removeCustomFuncFromWindow = removeCustomFuncFromWindow;
+exports.rowClick = rowClick;
+exports.rowDblClick = rowDblClick;
+exports.setTableEvents = setTableEvents;