super-page-runtime 0.0.1-tmp2

package/lib/runtime/views/assemblys/form/select/select-runtime.vue2.js

@@ -0,0 +1,201 @@
+"use strict";
+const vue = require("vue");
+const pageHelperUtil = require("../../../../../src/utils/page-helper-util.js");
+const pageInitUtil = require("../../../../../src/utils/page-init-util.js");
+const _hoisted_1 = { style: { "float": "left" } };
+const _hoisted_2 = { style: { "float": "right", "color": "var(--el-text-color-secondary)", "font-size": "13px" } };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "select-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const entity = props.pageContext.entity ? props.pageContext.entity : {};
+    let dynamicFields = pageInitUtil.getFormModelFields(props.pageContext, props.configure);
+    const dynamicModelMethod = vue.computed({
+      get() {
+        return pageHelperUtil.getVariableValue(entity, dynamicFields);
+      },
+      set(value) {
+        pageHelperUtil.setVariableValue(entity, dynamicFields, value);
+      }
+    });
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const headerStyle = runtimeInfo.headerStyle;
+    const designProperty = runtimeInfo.props ? runtimeInfo.props : {};
+    const listOptions = vue.ref(designProperty.options ? designProperty.options : []);
+    const cacheOptions = pageHelperUtil.getOptionDatasFromPage(props.pageContext, props.configure);
+    if (cacheOptions.length > 0) {
+      listOptions.value = cacheOptions;
+    }
+    const queryLoadingFlag = vue.ref(false);
+    const dataOrigin = props.configure.props && props.configure.props.dataOrigin ? props.configure.props.dataOrigin : {};
+    const valueType = dataOrigin.optionValueSetType;
+    let autoSets = [];
+    const optionconfigInfo = designProperty.optionconfigInfo ? designProperty.optionconfigInfo : {};
+    if (valueType == "dynamicData" || valueType == "dataTable" || valueType == "service") {
+      if (dataOrigin.filterType == "remote") {
+        designProperty.filterable = true;
+        designProperty.remote = true;
+        designProperty.remoteShowSuffix = true;
+        let hisQuery = void 0;
+        designProperty.remoteMethod = function(query) {
+          if (hisQuery === query) {
+            return;
+          }
+          hisQuery = query;
+          queryLoadingFlag.value = true;
+          console.log("query", query);
+          pageHelperUtil.queryOptionDatasources(props.pageContext, optionconfigInfo, query).then((results) => {
+            queryLoadingFlag.value = false;
+          }).then((error) => {
+            console.log("查询失败!", error);
+            queryLoadingFlag.value = false;
+          });
+        };
+      }
+      if (dataOrigin.autoSets) {
+        for (let obj of dataOrigin.autoSets) {
+          if (obj.source) {
+            autoSets.push(obj);
+          }
+        }
+      }
+    }
+    if (props.configure && props.configure.props && props.configure.props.base && props.configure.props.base.optionProp) {
+      autoSets.push({
+        source: "label",
+        target: props.configure.props.base.optionProp
+      });
+    }
+    if (autoSets.length > 0) {
+      designProperty.changeMethod = optionChange;
+    }
+    const monitorFields = designProperty.monitorFields;
+    const monitorFieldInfos = [];
+    if (monitorFields) {
+      const preFields = [];
+      for (let propName of monitorFields) {
+        if (propName.startsWith("${")) {
+          propName = propName.substring(2, propName.length - 1);
+          const fields = propName.split(".");
+          if (fields[0] === "page" || fields[0] === "task" || fields[0] === "data") {
+            monitorFieldInfos.push(fields);
+            if (!preFields.includes(fields[0])) {
+              preFields.push(fields[0]);
+            }
+          }
+        }
+      }
+      for (let preField of preFields) {
+        vue.watch(entity[preField], () => {
+          monitorFieldChange();
+        });
+      }
+    }
+    function getMonitorFieldValues() {
+      let values = "";
+      for (let fieldInfo of monitorFieldInfos) {
+        values += "_" + pageHelperUtil.getVariableValue(entity, fieldInfo);
+      }
+      return values;
+    }
+    let initMonitorValue = getMonitorFieldValues();
+    let monitorTimeout = false;
+    function monitorFieldChange() {
+      if (monitorTimeout) {
+        clearTimeout(monitorTimeout);
+      }
+      monitorTimeout = setTimeout(function() {
+        const newValue = getMonitorFieldValues();
+        if (newValue == initMonitorValue) {
+          return;
+        }
+        initMonitorValue = newValue;
+        pageHelperUtil.queryOptionDatasources(props.pageContext, optionconfigInfo, void 0).then((error) => {
+          console.log("查询失败!", error);
+          queryLoadingFlag.value = false;
+        });
+      }, 200);
+    }
+    function optionChange(value) {
+      let selItems = null;
+      if (listOptions.value && value != void 0 && value != null) {
+        selItems = listOptions.value.filter((item) => {
+          return Array.isArray(value) ? value.includes(item.value) : value === item.value;
+        });
+      }
+      pageHelperUtil.autoSetAfterSelect(props.configure, props.pageContext, autoSets, selItems);
+    }
+    function updateOptions(newOptions) {
+      listOptions.value = newOptions ? newOptions : [];
+      console.log("updateOptions", newOptions);
+    }
+    __expose({
+      updateOptions
+    });
+    return (_ctx, _cache) => {
+      const _component_el_option = vue.resolveComponent("el-option");
+      const _component_el_select = vue.resolveComponent("el-select");
+      const _component_el_form_item = vue.resolveComponent("el-form-item");
+      return vue.openBlock(), vue.createBlock(_component_el_form_item, {
+        required: vue.unref(designProperty).required ? true : false,
+        class: vue.normalizeClass(vue.unref(runtimeClass)),
+        "label-width": vue.unref(designProperty).labelWidth,
+        style: vue.normalizeStyle(vue.unref(runtimeStyle))
+      }, {
+        label: vue.withCtx(() => [
+          vue.unref(designProperty).tittleShow ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            style: vue.normalizeStyle({ ...vue.unref(headerStyle) })
+          }, vue.toDisplayString(vue.unref(designProperty).title), 5)) : vue.createCommentVNode("", true)
+        ]),
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_el_select, {
+            disabled: vue.unref(designProperty).state === "disabled",
+            size: vue.unref(designProperty).size,
+            clearable: vue.unref(designProperty).clearable,
+            multiple: vue.unref(designProperty).multiple,
+            "collapse-tags": vue.unref(designProperty).collapseTags,
+            "collapse-tags-tooltip": vue.unref(designProperty).collapseTagsTooltip,
+            filterable: vue.unref(designProperty).filterable,
+            "allow-create": vue.unref(designProperty).allowCreate,
+            placeholder: vue.unref(designProperty).placeholder,
+            "remote-show-suffix": vue.unref(designProperty).remoteShowSuffix,
+            remote: vue.unref(designProperty).remote,
+            "remote-method": vue.unref(designProperty).remoteMethod,
+            loading: queryLoadingFlag.value,
+            onChange: vue.unref(designProperty).changeMethod,
+            modelValue: dynamicModelMethod.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => dynamicModelMethod.value = $event)
+          }, {
+            default: vue.withCtx(() => [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(listOptions.value, (item) => {
+                return vue.openBlock(), vue.createBlock(_component_el_option, {
+                  key: item.value,
+                  label: item.label,
+                  value: item.value
+                }, {
+                  default: vue.withCtx(() => [
+                    item._description_ ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                      vue.createElementVNode("span", _hoisted_1, vue.toDisplayString(item.label), 1),
+                      vue.createElementVNode("span", _hoisted_2, vue.toDisplayString(item._description_), 1)
+                    ], 64)) : vue.createCommentVNode("", true)
+                  ]),
+                  _: 2
+                }, 1032, ["label", "value"]);
+              }), 128))
+            ]),
+            _: 1
+          }, 8, ["disabled", "size", "clearable", "multiple", "collapse-tags", "collapse-tags-tooltip", "filterable", "allow-create", "placeholder", "remote-show-suffix", "remote", "remote-method", "loading", "onChange", "modelValue"])
+        ]),
+        _: 1
+      }, 8, ["required", "class", "label-width", "style"]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/lib/runtime/views/assemblys/form/switch/switch-runtime.vue.js

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

package/lib/runtime/views/assemblys/form/switch/switch-runtime.vue2.js

@@ -0,0 +1,63 @@
+"use strict";
+const vue = require("vue");
+const pageInitUtil = require("../../../../../src/utils/page-init-util.js");
+const pageHelperUtil = require("../../../../../src/utils/page-helper-util.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "switch-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const entity = props.pageContext.entity ? props.pageContext.entity : {};
+    let dynamicFields = pageInitUtil.getFormModelFields(props.pageContext, props.configure);
+    const dynamicModelMethod = vue.computed({
+      get() {
+        return pageHelperUtil.getVariableValue(entity, dynamicFields);
+      },
+      set(value) {
+        pageHelperUtil.setVariableValue(entity, dynamicFields, value);
+      }
+    });
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const headerStyle = runtimeInfo.headerStyle;
+    const designProperty = runtimeInfo.props ? runtimeInfo.props : {};
+    const switchStyle = runtimeInfo.switchStyle;
+    return (_ctx, _cache) => {
+      const _component_el_switch = vue.resolveComponent("el-switch");
+      const _component_el_form_item = vue.resolveComponent("el-form-item");
+      return vue.openBlock(), vue.createBlock(_component_el_form_item, {
+        required: vue.unref(designProperty).required,
+        class: vue.normalizeClass(vue.unref(runtimeClass)),
+        "label-width": vue.unref(designProperty).labelWidth,
+        style: vue.normalizeStyle(vue.unref(runtimeStyle))
+      }, {
+        label: vue.withCtx(() => [
+          vue.unref(designProperty).tittleShow ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            style: vue.normalizeStyle({ ...vue.unref(headerStyle) })
+          }, vue.toDisplayString(vue.unref(designProperty).title), 5)) : vue.createCommentVNode("", true)
+        ]),
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_el_switch, {
+            disabled: vue.unref(designProperty).state === "disabled",
+            "active-value:": vue.unref(designProperty).activeValue,
+            "active-text": vue.unref(designProperty).activeText,
+            "inactive-value": vue.unref(designProperty).inactiveValue,
+            "inactive-text": vue.unref(designProperty).inactiveText,
+            width: vue.unref(designProperty).offOnWidth,
+            size: vue.unref(designProperty).size,
+            style: vue.normalizeStyle(vue.unref(switchStyle)),
+            modelValue: dynamicModelMethod.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => dynamicModelMethod.value = $event)
+          }, null, 8, ["disabled", "active-value:", "active-text", "inactive-value", "inactive-text", "width", "size", "style", "modelValue"])
+        ]),
+        _: 1
+      }, 8, ["required", "class", "label-width", "style"]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/lib/runtime/views/assemblys/form/tag/tag-runtime.vue.js

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

package/lib/runtime/views/assemblys/form/tag/tag-runtime.vue2.js

@@ -0,0 +1,63 @@
+"use strict";
+const vue = require("vue");
+const pageInitUtil = require("../../../../../src/utils/page-init-util.js");
+const pageHelperUtil = require("../../../../../src/utils/page-helper-util.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "tag-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    const props = __props;
+    pageInitUtil.getFormModelFields(props.pageContext, props.configure);
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const headerStyle = runtimeInfo.headerStyle;
+    const designProperty = runtimeInfo.props ? runtimeInfo.props : {};
+    let contentVariable = designProperty.formatting;
+    if (!contentVariable) {
+      const propsBase = props.configure.props.base ? props.configure.props.base : {};
+      contentVariable = propsBase.prop;
+    }
+    if (!contentVariable) {
+      contentVariable = "${page." + props.configure.uuid + "}";
+    }
+    const dynamicValue = vue.computed(() => {
+      const resultValue = pageHelperUtil.formatVariableValue(props.pageContext, contentVariable);
+      return resultValue == void 0 || resultValue == null ? "" : resultValue;
+    });
+    return (_ctx, _cache) => {
+      const _component_el_tag = vue.resolveComponent("el-tag");
+      const _component_el_form_item = vue.resolveComponent("el-form-item");
+      return vue.openBlock(), vue.createBlock(_component_el_form_item, {
+        required: vue.unref(designProperty).required,
+        class: vue.normalizeClass(vue.unref(runtimeClass)),
+        "label-width": vue.unref(designProperty).labelWidth,
+        style: vue.normalizeStyle(vue.unref(runtimeStyle))
+      }, {
+        label: vue.withCtx(() => [
+          vue.unref(designProperty).tittleShow ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            style: vue.normalizeStyle({ ...vue.unref(headerStyle) })
+          }, vue.toDisplayString(vue.unref(designProperty).title), 5)) : vue.createCommentVNode("", true)
+        ]),
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_el_tag, {
+            size: vue.unref(designProperty).size,
+            closable: vue.unref(designProperty).closable,
+            type: vue.unref(designProperty).type
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(vue.toDisplayString(dynamicValue.value), 1)
+            ]),
+            _: 1
+          }, 8, ["size", "closable", "type"])
+        ]),
+        _: 1
+      }, 8, ["required", "class", "label-width", "style"]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/lib/runtime/views/assemblys/form/textarea/textarea-runtime.vue.js

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

package/lib/runtime/views/assemblys/form/textarea/textarea-runtime.vue2.js

@@ -0,0 +1,65 @@
+"use strict";
+const vue = require("vue");
+const pageInitUtil = require("../../../../../src/utils/page-init-util.js");
+const pageHelperUtil = require("../../../../../src/utils/page-helper-util.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "textarea-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const entity = props.pageContext.entity ? props.pageContext.entity : {};
+    let dynamicFields = pageInitUtil.getFormModelFields(props.pageContext, props.configure);
+    const dynamicModelMethod = vue.computed({
+      get() {
+        return pageHelperUtil.getVariableValue(entity, dynamicFields);
+      },
+      set(value) {
+        pageHelperUtil.setVariableValue(entity, dynamicFields, value);
+      }
+    });
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const designProperty = runtimeInfo.props ? runtimeInfo.props : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const headerStyle = runtimeInfo.headerStyle;
+    return (_ctx, _cache) => {
+      const _component_el_input = vue.resolveComponent("el-input");
+      const _component_el_form_item = vue.resolveComponent("el-form-item");
+      return vue.openBlock(), vue.createElementBlock("div", null, [
+        vue.createVNode(_component_el_form_item, {
+          required: vue.unref(designProperty).required ? true : false,
+          class: vue.normalizeClass(vue.unref(runtimeClass)),
+          "label-width": vue.unref(designProperty).labelWidth,
+          style: vue.normalizeStyle(vue.unref(runtimeStyle))
+        }, {
+          label: vue.withCtx(() => [
+            vue.unref(designProperty).tittleShow ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 0,
+              style: vue.normalizeStyle({ ...vue.unref(headerStyle) })
+            }, vue.toDisplayString(vue.unref(designProperty).title), 5)) : vue.createCommentVNode("", true)
+          ]),
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_el_input, {
+              disabled: vue.unref(designProperty).state === "disabled",
+              readonly: vue.unref(designProperty).state === "readonly",
+              size: vue.unref(designProperty).size,
+              clearable: vue.unref(designProperty).clearable,
+              placeholder: vue.unref(designProperty).placeholder,
+              modelValue: dynamicModelMethod.value,
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => dynamicModelMethod.value = $event),
+              rows: vue.unref(designProperty).rows ? vue.unref(designProperty).rows : 2,
+              maxlength: vue.unref(designProperty).maxLength,
+              "show-word-limit": vue.unref(designProperty).showInputNum,
+              type: "textarea"
+            }, null, 8, ["disabled", "readonly", "size", "clearable", "placeholder", "modelValue", "rows", "maxlength", "show-word-limit"])
+          ]),
+          _: 1
+        }, 8, ["required", "class", "label-width", "style"])
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

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

@@ -0,0 +1,142 @@
+"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("../../../src/utils/interfaces/page-design-types.js");
+const globalRefs = require("../../../src/utils/global-refs.js");
+const pageInitUtil = require("../../../src/utils/page-init-util.js");
+const pageHelperUtil = require("../../../src/utils/page-helper-util.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "object-render",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    const props = __props;
+    if (props.configure.style == void 0) {
+      props.configure.style = {};
+    }
+    const permissionCodes = pageInitUtil.getPermissionCodes(props.configure, props.pageContext);
+    let handleShowFlag = vue.ref(true);
+    let showFlag = vue.ref(true);
+    if (props.configure && props.configure.props && props.configure.props.showConditions) {
+      const showConditions = props.configure.props.showConditions;
+      if (showConditions.length > 0) {
+        showFlag = vue.computed(() => {
+          if (!handleShowFlag.value) {
+            return false;
+          }
+          return pageHelperUtil.caculateShowCondition(props.pageContext, props.configure, showConditions);
+        });
+      }
+    }
+    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 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;
+      }
+    }
+    function setComponentRef(el) {
+      thisRef.value = el;
+      if (el && !el.show) {
+        el.show = function() {
+          handleShowFlag.value = true;
+        };
+      }
+      if (el && !el.hide) {
+        el.hide = function() {
+          handleShowFlag.value = false;
+        };
+      }
+      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.props && props.configure.props.base) {
+        const propsBase = props.configure.props.base;
+        if (propsBase.prop) {
+          let propName = propsBase.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);
+        }
+      }
+    }
+    vue.onMounted(() => {
+      if (!thisRef.value || !thisRef.value.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") {
+        const contentObj = [thisRef.value.parentNode];
+        if (contentObj && contentObj.length > 0) {
+          const contentRec = contentObj[0].getBoundingClientRect();
+          if (position == "top") {
+            runtimeStyle.value["top"] = contentRec.top + "px";
+          }
+          if (position == "bottom") {
+            runtimeStyle.value["bottom"] = "10px";
+          }
+        }
+        const thisRec = thisRef.value.getBoundingClientRect();
+        runtimeStyle.value["width"] = thisRec.width + "px";
+      } else if (thisStyle.position) {
+        runtimeStyle.value["position"] = thisStyle.position;
+        if (runtimeStyle.value.position != "relative") {
+          if (!runtimeStyle.value["width"]) {
+            const thisRec = thisRef.value.getBoundingClientRect();
+            runtimeStyle.value["width"] = thisRec.width + "px";
+          }
+          if (thisStyle.left) {
+            runtimeStyle.value["left"] = thisStyle.left + "px";
+          }
+          if (thisStyle.top) {
+            runtimeStyle.value["top"] = thisStyle.top + "px";
+          }
+        }
+      }
+    });
+    return (_ctx, _cache) => {
+      const _directive_permission = vue.resolveDirective("permission");
+      return vue.withDirectives((vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(dynamicComponent.value), {
+        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)],
+        [_directive_permission, vue.unref(permissionCodes)]
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/lib/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/lib/runtime/views/assemblys/workflow/workflow-button/workflowbutton-runtime.vue.js

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

package/lib/runtime/views/assemblys/workflow/workflow-button/workflowbutton-runtime.vue2.js

@@ -0,0 +1,61 @@
+"use strict";
+const vue = require("vue");
+const objectRender_vue_vue_type_script_setup_true_lang = require("../../object-render.vue.js");
+const eventUtil = require("../../../../../src/utils/events/event-util.js");
+const standardEvent = require("../../../../../src/utils/events/standard-event.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "workflowbutton-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    vue.ref(runtimeInfo.style ? runtimeInfo.style : {});
+    runtimeInfo.class;
+    const buttonInfo = props.pageContext.workflowButtonComponent;
+    const completeTaskParam = props.pageContext.completeTaskParam;
+    const visibleBtns = vue.ref([]);
+    props.configure.items.forEach((item) => {
+      const pageCode = props.pageContext.code;
+      const pageVersion = props.pageContext.version;
+      if (isVisibleBtn(item, pageCode, pageVersion)) {
+        visibleBtns.value.push(item);
+      }
+    });
+    function getStandardClickEvent(events, pageCode, pageVersion) {
+      const clickEventFunObj = eventUtil.getClickEventFuncByType(pageCode, pageVersion, events);
+      if (clickEventFunObj) {
+        const isStandardEvent = clickEventFunObj.isStandard;
+        if (isStandardEvent) {
+          return clickEventFunObj.event.eventName;
+        }
+      }
+    }
+    function isVisibleBtn(btnConfigure, pageCode, pageVersion) {
+      const events = btnConfigure.events;
+      const workflowStandardEventName = getStandardClickEvent(events, pageCode, pageVersion);
+      const isVisible = standardEvent.isVisibleWorkflowButton(
+        workflowStandardEventName,
+        buttonInfo,
+        completeTaskParam
+      );
+      return isVisible;
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("span", null, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(visibleBtns.value, (element, itemIndex) => {
+          return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+            element.check ? (vue.openBlock(), vue.createBlock(objectRender_vue_vue_type_script_setup_true_lang, {
+              key: itemIndex,
+              pageContext: _ctx.pageContext,
+              configure: element
+            }, null, 8, ["pageContext", "configure"])) : vue.createCommentVNode("", true)
+          ], 64);
+        }), 256))
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;