super-page-runtime 2.3.17 → 2.3.18-tmp1

package/dist/lib/components/runtime/views/assemblys/object-render.vue.d.ts

@@ -0,0 +1,17 @@
+import { PageContext, Component } from '../../utils/interfaces/page-design-types';
+
+interface MyProps {
+    pageContext: PageContext;
+    configure: Component;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<MyProps>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<MyProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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;
+    };
+};

package/dist/lib/components/runtime/views/assemblys/object-render.vue.js

@@ -0,0 +1,265 @@
+"use strict";
+const Vue = require("vue");
+const errorRender_vue_vue_type_script_setup_true_lang = require("./error-render.vue.js");
+const assemblysConfig = require("../../utils/assemblys-config.js");
+const pageDesignTypes = require("../../utils/interfaces/page-design-types.js");
+const globalRefs = require("../../utils/global-refs.js");
+const pageInitUtil = require("../../utils/page-init-util.js");
+const pageHelperUtil = require("../../utils/page-helper-util.js");
+const commonUtil = require("../../utils/common-util.js");
+const eventUtil = require("../../utils/events/event-util.js");
+const pageStore = require("../../utils/page-store.js");
+const tableUtils = require("../../utils/table-utils.js");
+const permission = require("../../../../node_modules/.pnpm/agilebuilder-ui@1.1.58_@vue_29e6d749740d5c0a82211de8e577b320/node_modules/agilebuilder-ui/src/utils/permission.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "object-render",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    var _a, _b;
+    const props = __props;
+    if (props.configure.style == void 0) {
+      props.configure.style = {};
+    }
+    const permissionCodes = pageInitUtil.getPermissionCodes(props.configure, props.pageContext);
+    if (props.configure && props.configure.props && props.configure.props.base) {
+      props.configure.props.base.functionCode = permissionCodes;
+    }
+    const isHasPermission = permission.default(permissionCodes ? permissionCodes : "true", props.pageContext.systemCode);
+    const isHasBranchFieldAuth = tableUtils.isHasFieldAuth(props.pageContext, props.configure);
+    const isHasBranchFieldAuthAndPermission = isHasPermission && isHasBranchFieldAuth;
+    if (props.configure && props.configure.props && props.configure.props.base) {
+      props.configure.props.base.isHasFieldAuthPermission = isHasBranchFieldAuthAndPermission;
+    }
+    pageInitUtil.packageFormRules(props.pageContext, props.configure, isHasBranchFieldAuthAndPermission);
+    let handleShowFlag = Vue.ref(null);
+    let showFlag = Vue.ref(true);
+    let editFlag = Vue.ref("");
+    if (props.configure && props.configure.props) {
+      let showConditions = [];
+      if ((_a = props.configure.props.base) == null ? void 0 : _a.showConditions) {
+        if (typeof props.configure.props.base.showConditions === "string") {
+          showConditions = JSON.parse(props.configure.props.base.showConditions);
+        } else {
+          showConditions = props.configure.props.base.showConditions;
+        }
+      }
+      showFlag = Vue.computed(() => {
+        var _a2;
+        let dynamicShowFlag = true;
+        if (!isHasBranchFieldAuthAndPermission) {
+          dynamicShowFlag = false;
+        } else {
+          if (handleShowFlag.value && handleShowFlag.value !== null) {
+            dynamicShowFlag = handleShowFlag.value === "show" ? true : false;
+          } else {
+            if (!eventUtil.isShowMobileEvent(props.pageContext, props.configure)) {
+              dynamicShowFlag = false;
+            } else {
+              if (showConditions && showConditions.length > 0) {
+                dynamicShowFlag = pageHelperUtil.caculateShowCondition(props.pageContext, showConditions);
+              } else {
+                const state = (_a2 = props.configure.props.base) == null ? void 0 : _a2.state;
+                if (state && state === "hidden") {
+                  dynamicShowFlag = false;
+                }
+              }
+            }
+          }
+        }
+        return dynamicShowFlag;
+      });
+      const propConfigure = props.configure;
+      propConfigure._dynamicShowFlag = showFlag;
+      if ((_b = props.configure.props.base) == null ? void 0 : _b.editConditions) {
+        const editConditions = props.configure.props.base.editConditions;
+        if (editConditions.length > 0) {
+          const runtime = props.configure.runtime ? props.configure.runtime : {};
+          const property = runtime.props ? runtime.props : {};
+          property.rawSate = property.state;
+          if (commonUtil.isWorkflowPage(props.pageContext) && props.pageContext.fieldPermissionMap) {
+            const propsBase = props.configure.props.base;
+            if (propsBase && propsBase.prop) {
+              let propName = propsBase.prop;
+              propName = pageHelperUtil.getFormPropName(propName);
+              const propEditPermission = props.pageContext.fieldPermissionMap.get(propName);
+              if (propEditPermission) {
+                if (propEditPermission["canEdit"] === false) {
+                  editFlag.value = "disabled";
+                }
+              }
+            }
+          }
+          property.state = Vue.computed({
+            get() {
+              if (editFlag.value === "disabled") {
+                return editFlag.value;
+              }
+              const canEdit = pageHelperUtil.caculateShowCondition(props.pageContext, editConditions);
+              return canEdit ? "" : "disabled";
+            },
+            set() {
+            }
+          });
+        }
+      }
+    }
+    const dynamicComponent = Vue.ref({});
+    dynamicComponent.value = Vue.markRaw(assemblysConfig.getRuntimeComponentByName(props.configure.name));
+    const showCopy = Vue.ref(true);
+    if (dynamicComponent.value == null) {
+      dynamicComponent.value = errorRender_vue_vue_type_script_setup_true_lang;
+      showCopy.value = false;
+    }
+    const thisRef = Vue.ref(null);
+    const runtimeStyle = Vue.ref({});
+    const runtimeClass = Vue.ref("");
+    const propClassName = commonUtil.getPropClassName(props.configure);
+    if (propClassName) {
+      runtimeClass.value = propClassName;
+    }
+    const commonRuntime = props.configure.runtime && props.configure.runtime.common ? props.configure.runtime.common : {};
+    if (commonRuntime.class) {
+      runtimeClass.value += " " + commonRuntime.class;
+    }
+    if (commonRuntime.style) {
+      Object.assign(runtimeStyle.value, commonRuntime.style);
+      const pageDimensions = props.pageContext && props.pageContext.dimensions ? props.pageContext.dimensions : pageDesignTypes.PageDimensions.PC;
+      const sizeStyle = commonRuntime.style[pageDimensions + "_style"];
+      if (sizeStyle) {
+        Object.assign(runtimeStyle.value, sizeStyle);
+      }
+      const sizeClass = commonRuntime.style[pageDimensions + "_class"];
+      if (sizeClass) {
+        runtimeClass.value += " " + sizeClass;
+      }
+    }
+    const pageContextUtil = pageStore.usePageContextStore();
+    function setComponentRef(el) {
+      thisRef.value = el;
+      if (el && !el.show) {
+        el.show = function() {
+          handleShowFlag.value = "show";
+        };
+      }
+      if (el && !el.hide) {
+        el.hide = function() {
+          handleShowFlag.value = "hide";
+        };
+      }
+      if (el && !el.getConfigure) {
+        el.getConfigure = function() {
+          return props.configure;
+        };
+      }
+      if (props.configure.uuid) {
+        globalRefs.addComponentRef(props.pageContext, props.configure.uuid, thisRef);
+      }
+      if (props.configure.code) {
+        globalRefs.addComponentRefByCode(props.pageContext, props.configure.code, thisRef);
+      } else if (props.configure.name === "table") {
+        globalRefs.addComponentRefByCode(props.pageContext, props.configure.uuid, thisRef);
+      } else if (props.configure.props && props.configure.props.base) {
+        const propsBase2 = props.configure.props.base;
+        if (propsBase2.prop) {
+          let propName = propsBase2.prop;
+          if (propName.startsWith("${")) {
+            propName = propName.substring(2, propName.length - 1);
+          }
+          if (propName.includes(".")) {
+            propName = propName.substring(propName.indexOf(".") + 1);
+          }
+          globalRefs.addComponentRefByCode(props.pageContext, propName, thisRef);
+        }
+      }
+      const propsBase = props.configure.props ? props.configure.props.base : null;
+      if (propsBase && propsBase.prop) {
+        let propName = propsBase.prop;
+        propName = pageHelperUtil.getFormPropName(propName);
+        pageInitUtil.controlObjectRenderState(props.pageContext, propName);
+        props.pageContext.propTitleMap = props.pageContext.propTitleMap || {};
+        props.pageContext.propTitleMap[propName] = propsBase.title ? propsBase.title : propName;
+      }
+      setComponentHeight();
+    }
+    let timer;
+    Vue.onMounted(() => {
+      dynamicallyCalculatePosition();
+      pageContextUtil.countComponentsLoadedNumber();
+      timer = setTimeout(() => {
+        if (pageContextUtil.componentsTotalNmber === pageContextUtil.componentsLoadedNumber && !pageContextUtil.pageComponentsLoaded) {
+          pageContextUtil.setPageComponentsLoaded(true);
+        }
+      }, 30);
+    });
+    Vue.onUnmounted(() => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    });
+    function setComponentHeight() {
+      if (!thisRef.value) {
+        return;
+      }
+      const sizeConfig = pageHelperUtil.getSizeConfig(props.pageContext, props.configure);
+      if (props.configure.name !== "table" && sizeConfig && sizeConfig["isCalcHeight"]) {
+        Vue.nextTick(() => {
+          let thisRefDom = thisRef.value.$el;
+          if (!thisRefDom) {
+            thisRefDom = thisRef.value;
+          }
+          const parentNode = thisRefDom.parentNode;
+          if (!thisRefDom || !parentNode) {
+            return;
+          }
+          const rect = thisRefDom.getBoundingClientRect();
+          let contentHeight = window.innerHeight - rect.y - 80;
+          let heightStyle = contentHeight + "";
+          if (commonUtil.isNumber(contentHeight)) {
+            heightStyle = contentHeight + "px";
+          }
+          runtimeStyle.value["height"] = heightStyle;
+          runtimeStyle.value["overflow-y"] = "auto";
+          runtimeStyle.value["overflow-x"] = "hidden";
+          if (!props.configure.sytle) {
+            props.configure.sytle = {};
+          }
+          props.configure.sytle._heightStyle = heightStyle;
+        });
+      }
+    }
+    const dynamicallyCalculatePosition = () => {
+      if (!thisRef.value) {
+        return;
+      }
+      let thisRefDom = thisRef.value.$el;
+      if (!thisRefDom) {
+        thisRefDom = thisRef.value;
+      }
+      const parentNode = thisRefDom.parentNode;
+      if (!thisRefDom || !parentNode) {
+        return;
+      }
+      const thisProps = props.configure.props ? props.configure.props : {};
+      const thisStyle = props.configure.style ? props.configure.style : {};
+      const position = thisProps.position;
+      if (position == "top" || position == "bottom") ;
+      else if (thisStyle.position) ;
+    };
+    return (_ctx, _cache) => {
+      return Vue.unref(isHasBranchFieldAuthAndPermission) && Vue.unref(eventUtil.isShowComponent)(_ctx.configure) ? Vue.withDirectives((Vue.openBlock(), Vue.createBlock(Vue.resolveDynamicComponent(dynamicComponent.value), {
+        key: 0,
+        ref: setComponentRef,
+        style: Vue.normalizeStyle(runtimeStyle.value),
+        class: Vue.normalizeClass(runtimeClass.value),
+        configure: _ctx.configure,
+        pageContext: _ctx.pageContext
+      }, null, 8, ["style", "class", "configure", "pageContext"])), [
+        [Vue.vShow, Vue.unref(showFlag)]
+      ]) : Vue.createCommentVNode("", true);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/object-render.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const objectRender_vue_vue_type_script_setup_true_lang = require("./object-render.vue.js");
+module.exports = objectRender_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/workflow/extract-workflow/extract-workflow-runtime.vue.js

@@ -0,0 +1,6 @@
+"use strict";
+const extractWorkflowRuntime_vue_vue_type_script_setup_true_lang = require("./extract-workflow-runtime.vue2.js");
+;/* empty css                               */
+const _pluginVue_exportHelper = require("../../../../../../_virtual/_plugin-vue_export-helper.js");
+const extractWorkflowRuntime = /* @__PURE__ */ _pluginVue_exportHelper(extractWorkflowRuntime_vue_vue_type_script_setup_true_lang, [["__scopeId", "data-v-51207a9f"]]);
+module.exports = extractWorkflowRuntime;

package/dist/lib/components/runtime/views/assemblys/workflow/extract-workflow/extract-workflow-runtime.vue2.js

@@ -0,0 +1,209 @@
+"use strict";
+const Vue = require("vue");
+const eventUtil = require("../../../../utils/events/event-util.js");
+const i18nUtil = require("../../../../utils/i18n-util.js");
+const index39f4c2e9 = require("../../../../../../node_modules/.pnpm/agilebuilder-ui@1.1.58_@vue_29e6d749740d5c0a82211de8e577b320/node_modules/agilebuilder-ui/lib/index-39f4c2e9.js");
+const index = require("../../../../../../node_modules/.pnpm/@element-plus_icons-vue@2.3.2_vue@3.5.18_typescript@5.4.5_/node_modules/@element-plus/icons-vue/dist/index.js");
+const _hoisted_1 = { class: "page-runtime-header-btn" };
+const _hoisted_2 = { class: "dialog-footer" };
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "extract-workflow-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const ruleFormRef = Vue.ref();
+    const showOrganizationTreeFlag = Vue.ref(false);
+    const dialogVisible = Vue.ref(false);
+    const formData = Vue.ref({});
+    const rules = Vue.ref({
+      loginName: [],
+      opinion: []
+    });
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const designProperty = Vue.ref(runtimeInfo.props ? runtimeInfo.props : {});
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    if (runtimeInfo.props) {
+      if (runtimeInfo.props.requireExtractTransactor === true) {
+        rules.value.loginName = [{ required: true, message: "请选择办理人", trigger: "blur" }];
+      }
+      if (runtimeInfo.props.isMustOpinion === true) {
+        rules.value.opinion = [{ required: true, message: "请输入意见", trigger: "change" }];
+      }
+    }
+    function isButtongLoading() {
+      return props.pageContext.canClick !== void 0 && props.pageContext.clickUuid !== void 0 ? !props.pageContext.canClick && props.pageContext.clickUuid === props.configure.uuid : false;
+    }
+    const componentRef = Vue.ref(null);
+    Vue.onMounted(() => {
+      Vue.nextTick(() => {
+        eventUtil.handleAfterInitEvent(null, props.pageContext, props.configure, {
+          componentRef: componentRef.value,
+          entity: props.pageContext.entity.data,
+          pageData: props.pageContext.entity.page
+        });
+      });
+    });
+    function triggerButtonClick() {
+      if (componentRef.value) {
+        componentRef.value.$el.click();
+      }
+    }
+    function showOrganizationTree() {
+      showOrganizationTreeFlag.value = true;
+    }
+    function emptyOrganizationResult() {
+      formData.value.loginName = "";
+      formData.value.name = "";
+    }
+    function closeDeptUserTree(selectedData) {
+      showOrganizationTreeFlag.value = false;
+      formData.value.loginName = selectedData ? selectedData.loginName : "";
+      formData.value.name = selectedData ? selectedData.name : "";
+    }
+    function initiateExtract() {
+      ruleFormRef.value.validate((valid, fields) => {
+        if (valid) {
+          const params = { loginName: formData.value.loginName, opinion: formData.value.opinion };
+          eventUtil.handleEvent(params, props.pageContext, props.configure, "click");
+        }
+      });
+    }
+    __expose({
+      click: triggerButtonClick
+    });
+    return (_ctx, _cache) => {
+      const _component_el_button = Vue.resolveComponent("el-button");
+      const _component_el_icon = Vue.resolveComponent("el-icon");
+      const _component_el_input = Vue.resolveComponent("el-input");
+      const _component_el_form_item = Vue.resolveComponent("el-form-item");
+      const _component_el_form = Vue.resolveComponent("el-form");
+      const _component_el_dialog = Vue.resolveComponent("el-dialog");
+      return Vue.openBlock(), Vue.createElementBlock("span", _hoisted_1, [
+        Vue.createVNode(_component_el_button, {
+          ref_key: "componentRef",
+          ref: componentRef,
+          disabled: isButtongLoading(),
+          class: Vue.normalizeClass(Vue.unref(runtimeClass)),
+          style: Vue.normalizeStyle(Vue.unref(runtimeStyle)),
+          type: designProperty.value.type,
+          size: designProperty.value.size,
+          round: designProperty.value.round,
+          plain: designProperty.value.plain,
+          loading: isButtongLoading(),
+          onClick: _cache[0] || (_cache[0] = ($event) => dialogVisible.value = true)
+        }, {
+          default: Vue.withCtx(() => [
+            Vue.createTextVNode(Vue.toDisplayString(Vue.unref(i18nUtil.$t)(designProperty.value.title)), 1)
+          ]),
+          _: 1
+        }, 8, ["disabled", "class", "style", "type", "size", "round", "plain", "loading"]),
+        Vue.createVNode(_component_el_dialog, {
+          modelValue: dialogVisible.value,
+          "onUpdate:modelValue": _cache[6] || (_cache[6] = ($event) => dialogVisible.value = $event),
+          title: "选择办理人",
+          width: "500"
+        }, {
+          footer: Vue.withCtx(() => [
+            Vue.createElementVNode("div", _hoisted_2, [
+              Vue.createVNode(_component_el_button, {
+                onClick: _cache[5] || (_cache[5] = ($event) => dialogVisible.value = false)
+              }, {
+                default: Vue.withCtx(() => _cache[7] || (_cache[7] = [
+                  Vue.createTextVNode("取消", -1)
+                ])),
+                _: 1,
+                __: [7]
+              }),
+              Vue.createVNode(_component_el_button, {
+                type: "primary",
+                onClick: initiateExtract
+              }, {
+                default: Vue.withCtx(() => _cache[8] || (_cache[8] = [
+                  Vue.createTextVNode(" 确定 ", -1)
+                ])),
+                _: 1,
+                __: [8]
+              })
+            ])
+          ]),
+          default: Vue.withCtx(() => [
+            Vue.createVNode(_component_el_form, {
+              ref_key: "ruleFormRef",
+              ref: ruleFormRef,
+              style: { "max-width": "600px" },
+              model: formData.value,
+              rules: rules.value,
+              "label-width": "auto"
+            }, {
+              default: Vue.withCtx(() => [
+                Vue.createVNode(_component_el_form_item, {
+                  label: "办理人",
+                  prop: "loginName"
+                }, {
+                  default: Vue.withCtx(() => [
+                    Vue.createVNode(_component_el_input, {
+                      "model-value": formData.value.name,
+                      readonly: true,
+                      type: "text",
+                      placeholder: "选择办理人",
+                      onClick: _cache[3] || (_cache[3] = ($event) => showOrganizationTree())
+                    }, {
+                      append: Vue.withCtx(() => [
+                        Vue.createVNode(_component_el_icon, {
+                          class: "el-input__icon",
+                          onClick: _cache[1] || (_cache[1] = ($event) => showOrganizationTree())
+                        }, {
+                          default: Vue.withCtx(() => [
+                            Vue.createVNode(Vue.unref(index.Search))
+                          ]),
+                          _: 1
+                        }),
+                        Vue.createVNode(_component_el_icon, {
+                          class: "el-input__icon",
+                          onClick: _cache[2] || (_cache[2] = ($event) => emptyOrganizationResult())
+                        }, {
+                          default: Vue.withCtx(() => [
+                            Vue.createVNode(Vue.unref(index.Delete))
+                          ]),
+                          _: 1
+                        })
+                      ]),
+                      _: 1
+                    }, 8, ["model-value"])
+                  ]),
+                  _: 1
+                }),
+                Vue.createVNode(_component_el_form_item, {
+                  label: "意见",
+                  prop: "opinion"
+                }, {
+                  default: Vue.withCtx(() => [
+                    Vue.createVNode(_component_el_input, {
+                      modelValue: formData.value.opinion,
+                      "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => formData.value.opinion = $event),
+                      type: "textarea"
+                    }, null, 8, ["modelValue"])
+                  ]),
+                  _: 1
+                }),
+                showOrganizationTreeFlag.value ? (Vue.openBlock(), Vue.createBlock(Vue.unref(index39f4c2e9.am), {
+                  key: 0,
+                  width: "60%",
+                  multiple: false,
+                  onClose: closeDeptUserTree
+                })) : Vue.createCommentVNode("", true)
+              ]),
+              _: 1
+            }, 8, ["model", "rules"])
+          ]),
+          _: 1
+        }, 8, ["modelValue"])
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/workflow/picture-flow/pictureflow-runtime.vue.js

@@ -0,0 +1,3 @@
+"use strict";
+const pictureflowRuntime_vue_vue_type_script_setup_true_lang = require("./pictureflow-runtime.vue2.js");
+module.exports = pictureflowRuntime_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/workflow/picture-flow/pictureflow-runtime.vue2.js

@@ -0,0 +1,47 @@
+"use strict";
+const Vue = require("vue");
+const commonUtil = require("../../../../utils/common-util.js");
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "pictureflow-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    var _a;
+    const props = __props;
+    const maxHeight = Vue.ref(null);
+    const heightStyle = (_a = props.configure.sytle) == null ? void 0 : _a._heightStyle;
+    if (heightStyle && (heightStyle + "").indexOf("px") > 0) {
+      const contentHeight = heightStyle.substring(0, heightStyle.lastIndexOf("px"));
+      maxHeight.value = Number(contentHeight) - 20;
+    } else {
+      maxHeight.value = window.innerHeight - 120;
+    }
+    const historyGraphRef = Vue.ref(null);
+    const workflowId = commonUtil.getWorkflowId(props.pageContext);
+    if (props.pageContext.entity && props.pageContext.entity.task) {
+      Vue.watch(
+        props.pageContext.entity.task.id,
+        () => {
+          if (workflowId && historyGraphRef.value) {
+            historyGraphRef.value.refresh();
+          }
+        },
+        { immediate: true }
+      );
+    }
+    return (_ctx, _cache) => {
+      const _component_workflow_history = Vue.resolveComponent("workflow-history");
+      return !Vue.unref(workflowId) ? (Vue.openBlock(), Vue.createElementBlock("span", _hoisted_1, Vue.toDisplayString(_ctx.$t("superPageRuntimeMessage.flowNotStart")), 1)) : (Vue.openBlock(), Vue.createBlock(_component_workflow_history, {
+        key: 1,
+        id: Vue.unref(workflowId),
+        ref_key: "historyGraphRef",
+        ref: historyGraphRef,
+        style: Vue.normalizeStyle({ maxHeight: maxHeight.value + "px" })
+      }, null, 8, ["id", "style"]));
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/workflow/text-history/textflow-runtime.vue.js

@@ -0,0 +1,3 @@
+"use strict";
+const textflowRuntime_vue_vue_type_script_setup_true_lang = require("./textflow-runtime.vue2.js");
+module.exports = textflowRuntime_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/workflow/text-history/textflow-runtime.vue2.js

@@ -0,0 +1,50 @@
+"use strict";
+const Vue = require("vue");
+const commonUtil = require("../../../../utils/common-util.js");
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "textflow-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    var _a;
+    const props = __props;
+    const maxHeight = Vue.ref(null);
+    const heightStyle = (_a = props.configure.sytle) == null ? void 0 : _a._heightStyle;
+    if (heightStyle && (heightStyle + "").indexOf("px") > 0) {
+      const contentHeight = heightStyle.substring(0, heightStyle.lastIndexOf("px"));
+      maxHeight.value = Number(contentHeight) - 20;
+    } else {
+      maxHeight.value = window.innerHeight - 120;
+    }
+    const historyList = Vue.ref(null);
+    const workflowId = commonUtil.getWorkflowId(props.pageContext);
+    if (props.pageContext.entity && props.pageContext.entity.task) {
+      Vue.watch(
+        () => {
+          var _a2;
+          return (_a2 = props.pageContext.entity.task) == null ? void 0 : _a2.id;
+        },
+        () => {
+          if (workflowId && historyList.value && props.pageContext.entity.task) {
+            historyList.value.refresh();
+          }
+        },
+        { immediate: true }
+      );
+    }
+    return (_ctx, _cache) => {
+      const _component_workflow_history_list = Vue.resolveComponent("workflow-history-list");
+      return !Vue.unref(workflowId) ? (Vue.openBlock(), Vue.createElementBlock("span", _hoisted_1, Vue.toDisplayString(_ctx.$t("superPageRuntimeMessage.flowNotStart")), 1)) : (Vue.openBlock(), Vue.createBlock(_component_workflow_history_list, {
+        key: 1,
+        ref_key: "historyList",
+        ref: historyList,
+        "workflow-id": Vue.unref(workflowId),
+        style: Vue.normalizeStyle({ maxHeight: maxHeight.value + "px" })
+      }, null, 8, ["workflow-id", "style"]));
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/workflow/workflow-button/workflowbutton-runtime.vue.js

@@ -0,0 +1,6 @@
+"use strict";
+const workflowbuttonRuntime_vue_vue_type_script_setup_true_lang = require("./workflowbutton-runtime.vue2.js");
+;/* empty css                             */
+const _pluginVue_exportHelper = require("../../../../../../_virtual/_plugin-vue_export-helper.js");
+const workflowbuttonRuntime = /* @__PURE__ */ _pluginVue_exportHelper(workflowbuttonRuntime_vue_vue_type_script_setup_true_lang, [["__scopeId", "data-v-3078f246"]]);
+module.exports = workflowbuttonRuntime;