super-page-runtime 0.0.2-tmp6 → 1.0.1

package/dist/lib/components/runtime/views/super-page.vue.d.ts

@@ -0,0 +1,91 @@
+import { PropType } from 'vue';
+import { PageDesign } from '../utils/interfaces/page-design-types';
+
+declare const _default: import('vue').DefineComponent<{
+    pageCode: {
+        type: StringConstructor;
+        required: false;
+    };
+    pageVersion: {
+        type: NumberConstructor;
+        required: false;
+    };
+    pageId: {
+        type: NumberConstructor;
+        required: false;
+    };
+    dataIds: {
+        type: StringConstructor;
+        required: false;
+    };
+    pageDesign: {
+        type: PropType<PageDesign>;
+        required: false;
+    };
+    isTest: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    publishVersion: {
+        type: NumberConstructor;
+        required: false;
+    };
+    taskId: {
+        type: NumberConstructor;
+        required: false;
+    };
+    pageRequest: {
+        type: ObjectConstructor;
+        required: false;
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+    open: (...args: any[]) => void;
+    closed: (...args: any[]) => void;
+    opened: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    pageCode: {
+        type: StringConstructor;
+        required: false;
+    };
+    pageVersion: {
+        type: NumberConstructor;
+        required: false;
+    };
+    pageId: {
+        type: NumberConstructor;
+        required: false;
+    };
+    dataIds: {
+        type: StringConstructor;
+        required: false;
+    };
+    pageDesign: {
+        type: PropType<PageDesign>;
+        required: false;
+    };
+    isTest: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    publishVersion: {
+        type: NumberConstructor;
+        required: false;
+    };
+    taskId: {
+        type: NumberConstructor;
+        required: false;
+    };
+    pageRequest: {
+        type: ObjectConstructor;
+        required: false;
+    };
+}>> & {
+    onClose?: (...args: any[]) => any;
+    onOpen?: (...args: any[]) => any;
+    onClosed?: (...args: any[]) => any;
+    onOpened?: (...args: any[]) => any;
+}, {
+    isTest: boolean;
+}, {}>;
+export default _default;

package/dist/lib/components/runtime/views/super-page.vue.js

@@ -0,0 +1,481 @@
+"use strict";
+const vue_runtime_esmBundler_js = require("D:/MyToolbox/ws-idea/agile-builder/dev-platform/agile-builder-super-design/node_modules/.pnpm/vue@3.4.21_typescript@5.4.5/node_modules/vue/dist/vue.runtime.esm-bundler.js");
+const objectRender_vue_vue_type_script_setup_true_lang = require("./assemblys/object-render.vue.js");
+const pageHelperUtil = require("../utils/page-helper-util.js");
+const pageInitUtil = require("../utils/page-init-util.js");
+const globalRefs = require("../utils/global-refs.js");
+const eventUtil = require("../utils/events/event-util.js");
+const exportFormReportDialog_vue_vue_type_script_setup_true_lang = require("./assemblys/common/export-form-report-dialog.vue.js");
+const taskInformitionDialog_vue_vue_type_script_setup_true_lang = require("./assemblys/common/task-informition-dialog.vue.js");
+const removeSignerDialog_vue_vue_type_script_setup_true_lang = require("./assemblys/common/remove-signer-dialog.vue.js");
+const eventBus = require("../utils/eventBus.js");
+const apiUtil = require("../utils/api/api-util.js");
+const standardEvent = require("../utils/events/standard-event.js");
+const index_mjs = require("D:/MyToolbox/ws-idea/agile-builder/dev-platform/agile-builder-super-design/node_modules/.pnpm/element-plus@2.6.2_vue@3.4.21/node_modules/element-plus/es/index.mjs");
+const vueI18n_mjs = require("D:/MyToolbox/ws-idea/agile-builder/dev-platform/agile-builder-super-design/node_modules/.pnpm/vue-i18n@9.10.2_vue@3.4.21/node_modules/vue-i18n/dist/vue-i18n.mjs");
+const superUi_js = require("D:/MyToolbox/ws-idea/agile-builder/dev-platform/agile-builder-super-design/node_modules/.pnpm/agilebuilder-ui@1.0.13_vue@3.4.21/node_modules/agilebuilder-ui/lib/super-ui.js");
+const validatorUtil = require("../utils/events/validator-util.js");
+const superPageDialog_vue_vue_type_script_setup_true_lang = require("../../super-page-dialog/super-page-dialog.vue.js");
+const vueRouter_mjs = require("D:/MyToolbox/ws-idea/agile-builder/dev-platform/agile-builder-super-design/node_modules/.pnpm/vue-router@4.3.0_vue@3.4.21/node_modules/vue-router/dist/vue-router.mjs");
+require("D:/MyToolbox/ws-idea/agile-builder/dev-platform/agile-builder-super-design/node_modules/.pnpm/agilebuilder-ui@1.0.13_vue@3.4.21/node_modules/agilebuilder-ui/src/utils/jump-page-utils.js");
+const _sfc_main = /* @__PURE__ */ vue_runtime_esmBundler_js.defineComponent({
+  __name: "super-page",
+  props: {
+    //页面编码
+    pageCode: {
+      type: String,
+      required: false
+    },
+    //页面版本
+    pageVersion: {
+      type: Number,
+      required: false
+    },
+    //页面ID
+    pageId: {
+      type: Number,
+      required: false
+    },
+    //表单数据ID
+    dataIds: {
+      type: String,
+      required: false
+    },
+    //测试对象
+    pageDesign: {
+      type: Object,
+      required: false
+    },
+    //是否测试
+    isTest: {
+      type: Boolean,
+      required: false
+    },
+    // 系统版本号
+    publishVersion: {
+      type: Number,
+      required: false
+    },
+    // 任务id。流程表单页面办理任务时任务id
+    taskId: {
+      type: Number,
+      required: false
+    },
+    // 页面跳转request参数
+    pageRequest: {
+      type: Object,
+      required: false
+    }
+  },
+  emits: ["open", "opened", "close", "closed"],
+  setup(__props, { emit: __emit }) {
+    const { t } = vueI18n_mjs.useI18n();
+    const props = __props;
+    const thisRef = vue_runtime_esmBundler_js.ref(null);
+    const pageItems = vue_runtime_esmBundler_js.ref([]);
+    const pageClass = vue_runtime_esmBundler_js.ref("");
+    const pageStyle = vue_runtime_esmBundler_js.ref({});
+    const pageDesignResult = vue_runtime_esmBundler_js.ref(null);
+    const buttonParams = vue_runtime_esmBundler_js.ref(null);
+    const showExportForm = vue_runtime_esmBundler_js.ref(false);
+    const selectAddSignerUser = vue_runtime_esmBundler_js.ref(false);
+    const selectCopyUser = vue_runtime_esmBundler_js.ref(false);
+    const selectAssignUser = vue_runtime_esmBundler_js.ref(false);
+    const isMulti = vue_runtime_esmBundler_js.ref(false);
+    const eventPageInfo = vue_runtime_esmBundler_js.ref(null);
+    const showTaskInformitions = vue_runtime_esmBundler_js.ref(false);
+    const taskInformitions = vue_runtime_esmBundler_js.ref([]);
+    const activeTasks = vue_runtime_esmBundler_js.ref([]);
+    const showRemoveSigner = vue_runtime_esmBundler_js.ref(false);
+    const taskIdVal = vue_runtime_esmBundler_js.ref(null);
+    const isShowPage = vue_runtime_esmBundler_js.ref(false);
+    const isShowDialog = vue_runtime_esmBundler_js.ref(false);
+    const jumpPageSetting = vue_runtime_esmBundler_js.ref(null);
+    const parentPageContext = vue_runtime_esmBundler_js.ref(null);
+    const parentConfigureObj = vue_runtime_esmBundler_js.ref(null);
+    const parentEventParams = vue_runtime_esmBundler_js.ref(null);
+    let pageContext;
+    const buttonConfigure = vue_runtime_esmBundler_js.ref(null);
+    const buttonPageContext = vue_runtime_esmBundler_js.ref(null);
+    function initPageDesign(pageDesign) {
+      console.log("pageDesign==", pageDesign);
+      pageContext = vue_runtime_esmBundler_js.reactive(pageInitUtil.convertToPageContext(pageDesign, props.pageRequest));
+      if (pageContext == null) {
+        return;
+      }
+      pageContext.isTest = props.isTest;
+      setTimeout(() => {
+        initOptionDatas(pageContext, pageDesign.initOptionConfigs);
+      }, 0);
+      pageContext.initDataSources = [];
+      globalRefs.initComponentRefState(pageContext);
+      pageItems.value = pageContext.items ? pageContext.items : [];
+      const runtime = pageContext.runtime ? pageContext.runtime : {};
+      pageClass.value = runtime.class;
+      pageStyle.value = runtime.style;
+      eventUtil.initPageEvents(pageDesign, pageContext);
+      validatorUtil.i18nValidateRulesMessage(pageContext.rules);
+      eventUtil.handleEvent(null, pageContext, pageDesign, "beforeload");
+      const myPageCode = pageContext.code;
+      eventPageInfo.value = myPageCode + "_";
+      eventBus.$on(eventPageInfo.value + "export-form-report", (params) => {
+        buttonParams.value = params;
+        buttonConfigure.value = params.configureObj;
+        buttonPageContext.value = params.pageContext;
+        showExportForm.value = true;
+      });
+      eventBus.$on(eventPageInfo.value + "import-file", (params) => {
+        buttonParams.value = params;
+        clickImport();
+      });
+      eventBus.$on(eventPageInfo.value + "assign-task", (params) => {
+        buttonParams.value = params;
+        selectAssignUser.value = true;
+        isMulti.value = false;
+      });
+      eventBus.$on(eventPageInfo.value + "copy-task", (params) => {
+        buttonParams.value = params;
+        selectCopyUser.value = true;
+        isMulti.value = true;
+      });
+      eventBus.$on(eventPageInfo.value + "add-signer", (params) => {
+        buttonParams.value = params;
+        selectAddSignerUser.value = true;
+        isMulti.value = true;
+      });
+      eventBus.$on(eventPageInfo.value + "choose-return-node", (params) => {
+        buttonParams.value = params;
+        standardEvent.getTaskInformitions(params).then((result) => {
+          taskInformitions.value = result;
+          showTaskInformitions.value = true;
+        }).catch((e) => {
+          console.log("显示可选的退回的环节集合异常", e);
+          showTaskInformitions.value = false;
+        });
+      });
+      eventBus.$on(eventPageInfo.value + "remove-signer", (params) => {
+        buttonParams.value = params;
+        standardEvent.getRemoveSigner(params).then((result) => {
+          taskIdVal.value = params.pageContext.completeTaskParam.taskId;
+          activeTasks.value = result;
+          showRemoveSigner.value = true;
+        }).catch((e) => {
+          console.log("显示可减签的环节集合异常", e);
+          showRemoveSigner.value = false;
+        });
+      });
+      eventBus.$on(eventPageInfo.value + "prohibit-edit", (data) => {
+      });
+      eventBus.$on(eventPageInfo.value + "open-dialog", (params) => {
+        parentPageContext.value = params.pageContext;
+        parentConfigureObj.value = params.configureObj;
+        parentEventParams.value = params.eventParams;
+        openDialog(params.configureObj);
+      });
+      eventBus.$on(eventPageInfo.value + "close-dialog", (pageContext2, configureObj) => {
+        parentPageContext.value = null;
+        parentConfigureObj.value = null;
+        parentEventParams.value = null;
+        closeDialog();
+      });
+      apiUtil.getData(pageContext).then((commonEntity) => {
+        const pageType = pageContext.pageType;
+        if (pageType && pageType === "form") {
+          changePermissionListToMap();
+          eventUtil.handleEvent(null, pageContext, pageDesign, "load");
+        }
+      });
+    }
+    function initOptionDatas(pageContext2, optionConfigs) {
+      if (!optionConfigs || optionConfigs.length == 0) {
+        console.log("无需要初始化的选项组数据");
+        return;
+      }
+      const initOptionConfigs = optionConfigs.filter((item) => {
+        return item.filterType != "remote";
+      });
+      console.log("pageContext.initOptionConfigs:", initOptionConfigs);
+      if (initOptionConfigs && initOptionConfigs.length > 0) {
+        pageHelperUtil.updateOptionDatasources(pageContext2, initOptionConfigs, void 0);
+      }
+    }
+    vue_runtime_esmBundler_js.onMounted(() => {
+      if (props.pageDesign != null) {
+        pageDesignResult.value = props.pageDesign;
+        setTimeout(() => {
+          initPageDesign(props.pageDesign);
+          if (props.pageDesign.tableRuntimes && Object.keys(props.pageDesign.tableRuntimes).length > 0) {
+            pageInitUtil.queryPageSuperGrids(props.pageDesign, pageContext, props.publishVersion).then((superGridItems) => {
+              pageContext.superGridItems = superGridItems;
+              isShowPage.value = true;
+            }).catch(() => {
+              isShowPage.value = true;
+            });
+          } else {
+            isShowPage.value = true;
+          }
+        }, 0);
+      } else if (props.pageCode) {
+        pageInitUtil.queryPageDesignByCode(props.pageCode).then((result) => {
+          pageDesignResult.value = result;
+          initPageDesign(result);
+          isShowPage.value = true;
+        });
+      }
+      if (thisRef.value) {
+        setTimeout(() => {
+          const parentNode = thisRef.value.parentNode ? thisRef.value.parentNode : thisRef.value;
+          const rect = parentNode.getBoundingClientRect();
+          const contentHeight = window.innerHeight - rect.y - 40;
+          parentNode.style.height = contentHeight + "px";
+          parentNode.style["overflow-y"] = "auto";
+        }, 10);
+      }
+    });
+    vue_runtime_esmBundler_js.onUpdated(() => {
+      vue_runtime_esmBundler_js.nextTick(() => {
+        if (pageContext && thisRef.value) {
+          globalRefs.addComponentRef(pageContext, "-1", thisRef);
+        }
+      });
+    });
+    vue_runtime_esmBundler_js.onUnmounted(() => {
+      globalRefs.removePageAllRef(pageContext);
+      if (pageDesignResult.value) {
+        eventUtil.removeCustomFuncFromWindow(pageDesignResult.value);
+      }
+      eventBus.$off(eventPageInfo.value + "export-form-report");
+      eventBus.$off(eventPageInfo.value + "import-file");
+      eventBus.$off(eventPageInfo.value + "assign-task");
+      eventBus.$off(eventPageInfo.value + "copy-task");
+      eventBus.$off(eventPageInfo.value + "add-signer");
+      eventBus.$off(eventPageInfo.value + "choose-return-node");
+      eventBus.$off(eventPageInfo.value + "remove-signer");
+      eventBus.$off(eventPageInfo.value + "prohibit-edit");
+    });
+    function closeExportFormDialog() {
+      showExportForm.value = false;
+      buttonParams.value = null;
+    }
+    function doExportFormReport(templateFile) {
+      const isPdf = false;
+      standardEvent.exportFormReport(
+        buttonParams.value.pageContext,
+        buttonParams.value.configureObj,
+        templateFile,
+        isPdf
+      );
+    }
+    const _selectFile_ = vue_runtime_esmBundler_js.ref(null);
+    function clickImport() {
+      _selectFile_.value.click();
+    }
+    function doImport() {
+      if (buttonParams.value) {
+        if (!_selectFile_.value) {
+          return;
+        }
+        if (_selectFile_.value.value === "" || _selectFile_.value.value === null)
+          return;
+        const fileObj = _selectFile_.value.files[0];
+        if (fileObj) {
+          _selectFile_.value.value = null;
+          standardEvent.doImportFinally(buttonParams.value, fileObj);
+        } else {
+          index_mjs.ElMessage({
+            showClose: true,
+            type: "warning",
+            message: t("superPageRuntimeMessage.noFileSelected")
+          });
+        }
+      }
+    }
+    function closeDeptUserTree(selectNodeInfo) {
+      if (selectAddSignerUser.value === true) {
+        selectAddSignerUser.value = false;
+        standardEvent.doAddSigner(buttonParams.value, selectNodeInfo);
+      }
+      if (selectCopyUser.value === true) {
+        selectCopyUser.value = false;
+        standardEvent.doCreateCopyTask(buttonParams.value, selectNodeInfo);
+      }
+      if (selectAssignUser.value === true) {
+        selectAssignUser.value = false;
+        standardEvent.doAssign(buttonParams.value, selectNodeInfo);
+      }
+    }
+    function myReturnTaskTo(selectTaskNode) {
+      taskInformitions.value = [];
+      showTaskInformitions.value = false;
+      standardEvent.doReturnTaskTo(buttonParams.value, selectTaskNode);
+    }
+    function myDoRemoveSigners(selectRemoveTasks) {
+      activeTasks.value = [];
+      showRemoveSigner.value = false;
+      standardEvent.doRemoveSigners(buttonParams.value, selectRemoveTasks);
+    }
+    function changePermissionListToMap() {
+      changeFieldPermissionToMap();
+      changeActionPermissionToMap();
+    }
+    function changeFieldPermissionToMap() {
+      let fieldPermissionMap = pageContext.fieldPermissionMap;
+      pageContext.actionPermissionMap;
+      const fieldPermissions = pageContext.fieldPermissions;
+      if (fieldPermissionMap === null) {
+        fieldPermissionMap = /* @__PURE__ */ new Map();
+      }
+      if (typeof fieldPermissions !== "undefined") {
+        for (let i = 0; i < fieldPermissions.length; i++) {
+          const prop = fieldPermissions[i].name;
+          if (prop) {
+            if (prop.indexOf("$") === 0 && prop.indexOf(".") > 0) {
+              const fieldPermissionOrg = fieldPermissions[i];
+              const fieldPermission = JSON.parse(JSON.stringify(fieldPermissionOrg));
+              const subModelName = prop.substring(1, prop.indexOf("."));
+              const subProp = prop.substring(prop.indexOf(".") + 1);
+              fieldPermission.name = subProp;
+              if (fieldPermission && fieldPermission.name === "all_fields") {
+                if (fieldPermission.canEdit === false) {
+                  if (fieldPermission.rowIndexes) {
+                    fieldPermissionMap.set(subModelName, [
+                      {
+                        name: "all_fields",
+                        canEdit: false,
+                        rowIndexes: fieldPermission.rowIndexes
+                      }
+                    ]);
+                  } else {
+                    fieldPermissionMap.set(subModelName, [{ name: "all_fields", canEdit: false }]);
+                  }
+                } else {
+                  if (fieldPermission.rowIndexes) {
+                    fieldPermissionMap.set(subModelName, [
+                      {
+                        name: "all_fields",
+                        canEdit: true,
+                        rowIndexes: fieldPermission.rowIndexes
+                      }
+                    ]);
+                  } else {
+                    fieldPermissionMap.set(subModelName, [{ name: "all_fields", canEdit: true }]);
+                  }
+                }
+              } else {
+                let subTableFieldPermission = fieldPermissionMap.get(subModelName);
+                if (subTableFieldPermission) {
+                  subTableFieldPermission.push(fieldPermission);
+                } else {
+                  subTableFieldPermission = [];
+                  subTableFieldPermission.push(fieldPermission);
+                }
+                fieldPermissionMap.set(subModelName, subTableFieldPermission);
+              }
+            } else {
+              fieldPermissionMap.set(prop, fieldPermissions[i]);
+            }
+          }
+        }
+      }
+      pageContext.fieldPermissionMap = fieldPermissionMap;
+    }
+    function changeActionPermissionToMap() {
+      let fieldPermissionMap = pageContext.fieldPermissionMap;
+      let actionPermissionMap = pageContext.actionPermissionMap;
+      const actionPermissions = pageContext.actionPermissions;
+      if (typeof actionPermissions !== "undefined" && actionPermissions !== null) {
+        const subModelNames = Object.keys(actionPermissions);
+        subModelNames.forEach((subModelName) => {
+          const oneTableActionPermission = actionPermissions[subModelName];
+          const subTableFieldPermission = fieldPermissionMap.get(subModelName);
+          if (subTableFieldPermission && subTableFieldPermission.length > 0 && subTableFieldPermission[0].name === "all_fields" && subTableFieldPermission[0].canEdit === false) {
+            oneTableActionPermission.canUpdate = false;
+            oneTableActionPermission.canAdd = false;
+          } else {
+            const canUpdate = oneTableActionPermission.canUpdate;
+            const updateRowIndexes = oneTableActionPermission.updateRowIndexes;
+            if (canUpdate !== void 0 && canUpdate === false && updateRowIndexes !== void 0 && updateRowIndexes !== null && updateRowIndexes.length > 0) {
+              fieldPermissionMap.set(subModelName, [
+                {
+                  name: "all_fields",
+                  canEdit: false,
+                  rowIndexes: updateRowIndexes
+                }
+              ]);
+            }
+          }
+          actionPermissionMap.set(subModelName, oneTableActionPermission);
+        });
+      }
+      pageContext.actionPermissionMap = actionPermissionMap;
+    }
+    vueRouter_mjs.useRouter();
+    function openDialog(configureObj) {
+      isShowDialog.value = true;
+    }
+    function closeDialog() {
+      isShowDialog.value = false;
+    }
+    return (_ctx, _cache) => {
+      return vue_runtime_esmBundler_js.openBlock(), vue_runtime_esmBundler_js.createElementBlock("div", null, [
+        isShowPage.value ? (vue_runtime_esmBundler_js.openBlock(), vue_runtime_esmBundler_js.createElementBlock("div", {
+          key: 0,
+          ref_key: "thisRef",
+          ref: thisRef,
+          class: vue_runtime_esmBundler_js.normalizeClass(pageClass.value),
+          style: vue_runtime_esmBundler_js.normalizeStyle(pageStyle.value)
+        }, [
+          (vue_runtime_esmBundler_js.openBlock(true), vue_runtime_esmBundler_js.createElementBlock(vue_runtime_esmBundler_js.Fragment, null, vue_runtime_esmBundler_js.renderList(pageItems.value, (element, itemIndex) => {
+            return vue_runtime_esmBundler_js.openBlock(), vue_runtime_esmBundler_js.createBlock(objectRender_vue_vue_type_script_setup_true_lang, {
+              key: element.uuid,
+              configure: element,
+              pageContext: vue_runtime_esmBundler_js.unref(pageContext)
+            }, null, 8, ["configure", "pageContext"]);
+          }), 128)),
+          showExportForm.value ? (vue_runtime_esmBundler_js.openBlock(), vue_runtime_esmBundler_js.createBlock(exportFormReportDialog_vue_vue_type_script_setup_true_lang, {
+            key: 0,
+            configure: buttonConfigure.value,
+            pageContext: buttonPageContext.value,
+            onClose: closeExportFormDialog,
+            onExport: doExportFormReport
+          }, null, 8, ["configure", "pageContext"])) : vue_runtime_esmBundler_js.createCommentVNode("", true),
+          vue_runtime_esmBundler_js.createElementVNode("input", {
+            ref_key: "_selectFile_",
+            ref: _selectFile_,
+            type: "file",
+            name: "_selectFile_",
+            style: { "display": "none" },
+            onChange: _cache[0] || (_cache[0] = ($event) => doImport())
+          }, null, 544),
+          selectAddSignerUser.value || selectCopyUser.value || selectAssignUser.value ? (vue_runtime_esmBundler_js.openBlock(), vue_runtime_esmBundler_js.createBlock(vue_runtime_esmBundler_js.unref(superUi_js.DepartmentUserTree), {
+            key: 1,
+            width: "60%",
+            multiple: isMulti.value,
+            onClose: closeDeptUserTree
+          }, null, 8, ["multiple"])) : vue_runtime_esmBundler_js.createCommentVNode("", true),
+          showTaskInformitions.value ? (vue_runtime_esmBundler_js.openBlock(), vue_runtime_esmBundler_js.createBlock(taskInformitionDialog_vue_vue_type_script_setup_true_lang, {
+            key: 2,
+            "task-informitions": taskInformitions.value,
+            onClose: _cache[1] || (_cache[1] = ($event) => showTaskInformitions.value = false),
+            onResult: myReturnTaskTo
+          }, null, 8, ["task-informitions"])) : vue_runtime_esmBundler_js.createCommentVNode("", true),
+          showRemoveSigner.value ? (vue_runtime_esmBundler_js.openBlock(), vue_runtime_esmBundler_js.createBlock(removeSignerDialog_vue_vue_type_script_setup_true_lang, {
+            key: 3,
+            "task-id": taskIdVal.value,
+            "active-tasks": activeTasks.value,
+            onClose: _cache[2] || (_cache[2] = ($event) => showRemoveSigner.value = false),
+            onResult: myDoRemoveSigners
+          }, null, 8, ["task-id", "active-tasks"])) : vue_runtime_esmBundler_js.createCommentVNode("", true),
+          isShowDialog.value ? (vue_runtime_esmBundler_js.openBlock(), vue_runtime_esmBundler_js.createBlock(superPageDialog_vue_vue_type_script_setup_true_lang, {
+            key: 4,
+            parentPageContext: parentPageContext.value,
+            parentPageEventParams: parentEventParams.value,
+            jumpPageSetting: jumpPageSetting.value,
+            onClose: _cache[3] || (_cache[3] = ($event) => closeDialog())
+          }, null, 8, ["parentPageContext", "parentPageEventParams", "jumpPageSetting"])) : vue_runtime_esmBundler_js.createCommentVNode("", true)
+        ], 6)) : vue_runtime_esmBundler_js.createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/super-page.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const superPage_vue_vue_type_script_setup_true_lang = require("./super-page.vue.js");
+module.exports = superPage_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/super-page-dialog/index.d.ts

@@ -0,0 +1,3 @@
+import { default as SuperPageDialog } from './super-page-dialog.vue';
+
+export default SuperPageDialog;

package/dist/lib/components/super-page-dialog/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const superPageDialog_vue_vue_type_script_setup_true_lang = require("./super-page-dialog.vue.js");
+module.exports = superPageDialog_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/super-page-dialog/super-page-dialog.vue.d.ts

@@ -0,0 +1,36 @@
+interface MyProps {
+    parentPageContext: {
+        type: Object;
+        default: null;
+    };
+    parentPageEventParams: {
+        type: Object;
+        default: null;
+    };
+    jumpPageSetting: {
+        type: Object;
+        default: null;
+    };
+    isTest?: boolean;
+}
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<MyProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+    open: (...args: any[]) => void;
+    closed: (...args: any[]) => void;
+    opened: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<MyProps>>> & {
+    onClose?: (...args: any[]) => any;
+    onOpen?: (...args: any[]) => any;
+    onClosed?: (...args: any[]) => any;
+    onOpened?: (...args: any[]) => any;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};