super-page-runtime 2.3.17-sit4 → 2.3.18-tmp1

package/dist/lib/components/runtime/views/assemblys/data/tree/tree-runtime.vue2.js

@@ -0,0 +1,531 @@
+"use strict";
+const Vue = require("vue");
+const folder = require("../../../../../../assets/folder.png.js");
+const file = require("../../../../../../assets/file.png.js");
+const pageInitUtil = require("../../../../utils/page-init-util.js");
+const pageHelperUtil = require("../../../../utils/page-helper-util.js");
+const treeUtils = require("../../../../utils/tree-utils.js");
+const eventUtil = require("../../../../utils/events/event-util.js");
+const permission = require("../../../../../../node_modules/.pnpm/agilebuilder-ui@1.1.58_@vue_29e6d749740d5c0a82211de8e577b320/node_modules/agilebuilder-ui/src/utils/permission.js");
+const index = require("../../../../../../node_modules/.pnpm/element-plus@2.10.5_vue@3.5.18_typescript@5.4.5_/node_modules/element-plus/es/components/message-box/index.js");
+const index$1 = require("../../../../../../node_modules/.pnpm/element-plus@2.10.5_vue@3.5.18_typescript@5.4.5_/node_modules/element-plus/es/components/message/index.js");
+const _hoisted_1 = {
+  key: 0,
+  class: "custom-tree-node"
+};
+const _hoisted_2 = ["title"];
+const _hoisted_3 = {
+  key: 0,
+  class: "item-row"
+};
+const _hoisted_4 = { class: "item-side" };
+const _hoisted_5 = {
+  key: 1,
+  class: "item-side",
+  style: { "display": "flex", "align-items": "center" }
+};
+const _hoisted_6 = ["onClick"];
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "tree-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props, { expose: __expose }) {
+    var _a, _b, _c;
+    const contxtMenuRef = Vue.ref();
+    const showContextMenu = Vue.ref(false);
+    const props = __props;
+    const entity = props.pageContext.entity ? props.pageContext.entity : {};
+    const hasPermissionContextMenus = Vue.ref([]);
+    if ((_a = props.configure.props) == null ? void 0 : _a.contextMenus) {
+      if (!props.pageContext || !props.configure || props.pageContext.isTest) {
+        hasPermissionContextMenus.value = props.configure.props.contextMenus;
+      } else {
+        props.configure.props.contextMenus.forEach((item) => {
+          if (item.functionCodes && item.functionCodes.length > 0) {
+            for (let i = 0; i < item.functionCodes.length; i++) {
+              const code = item.functionCodes[i];
+              const hasPermission = permission.default(code, props.pageContext.systemCode);
+              if (hasPermission) {
+                hasPermissionContextMenus.value.push(item);
+                return;
+              }
+            }
+          } else {
+            hasPermissionContextMenus.value.push(item);
+          }
+        });
+      }
+    }
+    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 isLazy = Vue.ref(((_c = (_b = props.configure.props) == null ? void 0 : _b.base) == null ? void 0 : _c.lazy) ? true : false);
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const menuTreeRef = Vue.ref();
+    const designProperty = Vue.ref(runtimeInfo.props ? runtimeInfo.props : {});
+    const defaultProps = Vue.ref({
+      id: "nodeId",
+      label: "name",
+      children: "children",
+      isLeaf: "leaf",
+      disabled: "disabled",
+      nodeType: "nodeType",
+      iconType: "iconType",
+      iconValue: "iconValue"
+    });
+    const isShowTree = Vue.ref(false);
+    const menuData = Vue.ref([]);
+    const selectNode = Vue.ref(null);
+    const filterText = Vue.ref("");
+    const isSearch = Vue.ref(false);
+    const editNodeId = Vue.ref("");
+    const newNodeIdFlag = Vue.ref("");
+    const editNodeName = Vue.ref("");
+    Vue.onMounted(() => {
+      Vue.nextTick(() => {
+        const value = dynamicModelMethod.value;
+        eventUtil.handleAfterInitEvent(value, props.pageContext, props.configure, {
+          componentRef: menuTreeRef.value,
+          value,
+          entity: props.pageContext.entity.data,
+          pageData: props.pageContext.entity.page
+        });
+      });
+    });
+    if (!isLazy.value) {
+      treeUtils.getMenuTreeData(props.pageContext, props.configure).then((treeNodes) => {
+        menuData.value = treeNodes;
+        isShowTree.value = true;
+      });
+    } else {
+      isShowTree.value = true;
+    }
+    Vue.watch(filterText, (val) => {
+      isSearch.value = true;
+      menuTreeRef.value.filter(val);
+    });
+    const filterNode = (value, data) => {
+      if (!value) return true;
+      return data.name.includes(value);
+    };
+    function handleNodeClick(data, node, nodeTree) {
+      selectNode.value = node;
+      eventUtil.handleFormEvent(null, props.pageContext, props.configure, "node-click", {
+        data,
+        node,
+        nodeTree
+      });
+    }
+    function loadNode(node, resolve) {
+      const parentId = 0;
+      let parentNodeId = "0";
+      if (node.level === 0) {
+        parentNodeId = parentId + "";
+      } else {
+        parentNodeId = node.data.nodeId;
+      }
+      initLoadNode(parentNodeId, node, resolve);
+    }
+    function initLoadNode(parentNodeId, node, resolve) {
+      const param = {
+        parentNodeId,
+        data: node.data,
+        // 节点详细信息，json字符串
+        searchValue: filterText,
+        // 查询条件
+        isSearch: isSearch.value
+        // 是否是查询
+      };
+      treeUtils.getMenuTreeData(props.pageContext, props.configure, parentNodeId, node, param).then(
+        (treeNodes) => {
+          isSearch.value = false;
+          resolve(treeNodes);
+          if (parentNodeId === "0") {
+            const rootNodeId = treeNodes[0].nodeId;
+            loadRootNode(rootNodeId, node);
+          }
+        }
+      );
+    }
+    function loadRootNode(rootNodeId, node) {
+      const param = {
+        parentNodeId: rootNodeId,
+        data: node.data,
+        // 节点详细信息，json字符串
+        searchValue: filterText,
+        // 查询条件
+        isSearch: isSearch.value
+        // 是否是查询
+      };
+      treeUtils.getMenuTreeData(props.pageContext, props.configure, rootNodeId, node, param).then((children) => {
+        isSearch.value = false;
+        menuTreeRef.value.updateKeyChildren(rootNodeId, children);
+        if (menuTreeRef.value.store.nodesMap[rootNodeId]) {
+          menuTreeRef.value.store.nodesMap[rootNodeId].expanded = true;
+        }
+      });
+    }
+    function getSelectNode() {
+      return selectNode.value;
+    }
+    function expandNode(node) {
+      node.loaded = false;
+      node.expand();
+    }
+    function loadTreeNodes() {
+      treeUtils.getMenuTreeData(props.pageContext, props.configure).then((treeNodes) => {
+        isSearch.value = false;
+        menuData.value = treeNodes;
+      });
+    }
+    function getNode(node) {
+      menuTreeRef.value.getNode(node);
+    }
+    const clickContextMenuNode = Vue.ref({});
+    const clickContextMenuEvent = (item) => {
+      if (!clickContextMenuNode.value) {
+        return;
+      }
+      if (item.type === "standard" && item.standardEvent) {
+        if (item.standardEvent === "edit") {
+          editNodeId.value = clickContextMenuNode.value.data.nodeId;
+          editNodeName.value = clickContextMenuNode.value.data.name;
+        } else if (item.standardEvent === "delete") {
+          if (clickContextMenuNode.value.childNodes && clickContextMenuNode.value.childNodes.length > 0) {
+            if (item.deleteParentNodeTip) {
+              if (!item.deleteParentNodeTipMessage) {
+                item.deleteParentNodeTipMessage = "当前节点下有子节点，确认删除？";
+              }
+              index.ElMessageBox.confirm(item.deleteParentNodeTipMessage, {
+                confirmButtonText: "确定",
+                cancelButtonText: "取消",
+                type: "error"
+              }).then(() => {
+                handDeleteNode(item);
+              }).catch(() => {
+                clickContextMenuNode.value = null;
+                console.log("取消");
+              });
+            } else {
+              handDeleteNode(item);
+            }
+          } else {
+            handDeleteNode(item);
+          }
+        } else {
+          const newNodeData = getNewNode();
+          editNodeId.value = newNodeData.nodeId;
+          newNodeIdFlag.value = newNodeData.nodeId;
+          editNodeName.value = newNodeData.name;
+          if (item.standardEvent === "addSiblingNode") {
+            newNodeData.isLeaf = clickContextMenuNode.value.data.isLeaf;
+            if (clickContextMenuNode.value.parent && clickContextMenuNode.value.parent.level > 0) {
+              menuTreeRef.value.append(newNodeData, clickContextMenuNode.value.parent);
+            } else {
+              menuData.value.push(newNodeData);
+            }
+          } else if (item.standardEvent === "addChildNode") {
+            newNodeData.isLeaf = true;
+            clickContextMenuNode.value.data.isLeaf = false;
+            menuTreeRef.value.append(newNodeData, clickContextMenuNode.value);
+            menuTreeRef.value.setCurrentKey(newNodeData.nodeId, true);
+          }
+        }
+      } else {
+        console.log("自定义事件", item);
+      }
+    };
+    const nodeContextmenu = (event, data, node, resolve) => {
+      if (editNodeId.value) {
+        index$1.ElMessage.warning("请先保存当前编辑节点!");
+        return;
+      }
+      document.removeEventListener("click", closeContextmenu);
+      clickContextMenuNode.value = node;
+      showContextMenu.value = true;
+      const { clientX: mouseX, clientY: mouseY } = event;
+      const menu = contxtMenuRef.value;
+      if (menu) {
+        const { innerWidth: windowWidth, innerHeight: windowHeight } = window;
+        const { offsetWidth: menuWidth, offsetHeight: menuHeight } = menu;
+        const left = mouseX + menuWidth > windowWidth ? mouseX - menuWidth : mouseX;
+        const top = mouseY + menuHeight > windowHeight ? mouseY - menuHeight : mouseY;
+        menu.style.left = `${left}px`;
+        menu.style.top = `${top}px`;
+        menu.style.display = "block";
+      }
+      document.addEventListener("click", closeContextmenu);
+    };
+    const closeContextmenu = () => {
+      showContextMenu.value = false;
+      document.removeEventListener("click", closeContextmenu);
+    };
+    const saveEditNode = (node) => {
+      if (editNodeName.value === "") {
+        index$1.ElMessage.warning("请输入节点名称");
+        return;
+      }
+      node.data.name = editNodeName.value;
+      if (newNodeIdFlag.value && node.data.nodeId === newNodeIdFlag.value) {
+        treeUtils.createTreeNode(node, props.configure, props.pageContext).then((res) => {
+          updateNodeData(node, res.currentNode);
+          resetEditNode();
+          index$1.ElMessage.success("保存成功！");
+        });
+      } else {
+        treeUtils.updateTreeNode(node, props.configure, props.pageContext).then((res) => {
+          console.log(res);
+          updateNodeData(node, res.currentNode);
+          resetEditNode();
+          index$1.ElMessage.success("保存成功！");
+        });
+      }
+    };
+    const updateNodeData = (node, newNodeData) => {
+      if (node.parent && node.parent.level > 0) {
+        const index2 = node.parent.data.children.findIndex(
+          (item) => item.nodeId === node.data.nodeId
+        );
+        node.parent.data.children[index2] = newNodeData;
+        node.data = newNodeData;
+      } else {
+        const index2 = node.parent.data.findIndex((item) => item.nodeId === node.data.nodeId);
+        node.parent.data[index2] = newNodeData;
+        node.data = newNodeData;
+      }
+    };
+    const cancelEditNode = (node, configure, pageContext) => {
+      if (newNodeIdFlag.value && node.data.nodeId === newNodeIdFlag.value) {
+        menuTreeRef.value.remove(node);
+      }
+      resetEditNode();
+    };
+    const resetEditNode = () => {
+      editNodeId.value = "";
+      editNodeName.value = "";
+      newNodeIdFlag.value = "";
+    };
+    const getNewNode = () => {
+      return {
+        nodeId: "primary" + (/* @__PURE__ */ new Date()).getTime(),
+        name: "新增节点",
+        disabled: false,
+        iconType: "custom",
+        isLeaf: true
+      };
+    };
+    function handDeleteNode(item) {
+      if (item.tipMessage) {
+        index.ElMessageBox.confirm(item.tipMessage, {
+          confirmButtonText: "确定",
+          cancelButtonText: "取消",
+          type: "error"
+        }).then(() => {
+          treeUtils.deleteNode(clickContextMenuNode.value, props.configure, props.pageContext).then(() => {
+            index$1.ElMessage.success("删除成功！");
+            removeTreeNode();
+            clickContextMenuNode.value = null;
+          });
+        }).catch(() => {
+          clickContextMenuNode.value = null;
+          console.log("取消");
+        });
+      } else {
+        treeUtils.deleteNode(clickContextMenuNode.value, props.configure, props.pageContext).then(() => {
+          index$1.ElMessage.success("删除成功！");
+          removeTreeNode();
+          clickContextMenuNode.value = null;
+        });
+      }
+    }
+    const removeTreeNode = () => {
+      const parentNode = clickContextMenuNode.value.parent;
+      menuTreeRef.value.remove(clickContextMenuNode.value);
+      if (parentNode.childNodes && parentNode.childNodes.length === 0) {
+        parentNode.data.isLeaf = true;
+      }
+      if (parentNode.data.children && parentNode.data.children.length > 0) {
+        parentNode.data.children = parentNode.data.children.filter(
+          (item) => item.nodeId !== clickContextMenuNode.value.data.nodeId
+        );
+      }
+    };
+    const getCheckedNodes = (leafOnly, includeHalfChecked) => {
+      return menuTreeRef.value.getCheckedNodes(leafOnly, includeHalfChecked);
+    };
+    const setCheckedNodes = (nodes) => {
+      menuTreeRef.value.setCheckedNodes(nodes);
+    };
+    const getCheckedKeys = (leafOnly) => {
+      return menuTreeRef.value.getCheckedKeysleafOnly();
+    };
+    const setCheckedKeys = (keys, leafOnly) => {
+      menuTreeRef.value.setCheckedKeys(keys, leafOnly);
+    };
+    const setChecked = (node, checked, deep) => {
+      menuTreeRef.value.setChecked(node, checked, deep);
+    };
+    const getCurrentKey = () => {
+      return menuTreeRef.value.getCurrentKey();
+    };
+    const getCurrentNode = () => {
+      return menuTreeRef.value.getCurrentNode();
+    };
+    const setCurrentKey = (key, shouldAutoExpandParent = true) => {
+      return menuTreeRef.value.setCurrentKey(key, shouldAutoExpandParent);
+    };
+    const setCurrentNode = (node, shouldAutoExpandParent = true) => {
+      return menuTreeRef.value.setCurrentNode(node, shouldAutoExpandParent);
+    };
+    __expose({
+      getSelectNode,
+      expandNode,
+      loadTreeNodes,
+      getNode,
+      getCheckedNodes,
+      setCheckedNodes,
+      getCheckedKeys,
+      setCheckedKeys,
+      setChecked,
+      getCurrentKey,
+      getCurrentNode,
+      setCurrentKey,
+      setCurrentNode
+    });
+    return (_ctx, _cache) => {
+      var _a2;
+      const _component_el_input = Vue.resolveComponent("el-input");
+      const _component_el_button = Vue.resolveComponent("el-button");
+      const _component_SuperIcon = Vue.resolveComponent("SuperIcon");
+      const _component_el_tree = Vue.resolveComponent("el-tree");
+      return Vue.openBlock(), Vue.createElementBlock("div", {
+        class: Vue.normalizeClass(["amb-tree-runtime-main", Vue.unref(runtimeClass)])
+      }, [
+        designProperty.value.filter ? (Vue.openBlock(), Vue.createBlock(_component_el_input, {
+          key: 0,
+          modelValue: filterText.value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => filterText.value = $event),
+          style: { "width": "100%" },
+          placeholder: "请输入查询条件"
+        }, null, 8, ["modelValue"])) : Vue.createCommentVNode("", true),
+        isShowTree.value ? (Vue.openBlock(), Vue.createBlock(_component_el_tree, {
+          key: 1,
+          ref_key: "menuTreeRef",
+          ref: menuTreeRef,
+          style: Vue.normalizeStyle(Vue.unref(runtimeStyle)),
+          load: loadNode,
+          data: menuData.value,
+          "node-key": "nodeId",
+          props: defaultProps.value,
+          "default-expand-all": designProperty.value.defaultExpandAll,
+          "expand-on-click-node": designProperty.value.expandOnClickNode,
+          indent: designProperty.value.retractWidth ? designProperty.value.retractWidth : 18,
+          accordion: designProperty.value.accordion,
+          "show-checkbox": designProperty.value.showCheckbox ? true : false,
+          "highlight-current": "",
+          lazy: isLazy.value,
+          "filter-node-method": filterNode,
+          onNodeClick: handleNodeClick,
+          onNodeContextmenu: nodeContextmenu
+        }, {
+          default: Vue.withCtx(({ node, data }) => [
+            data.nodeId === editNodeId.value ? (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_1, [
+              Vue.createVNode(_component_el_input, {
+                modelValue: editNodeName.value,
+                "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => editNodeName.value = $event),
+                size: "small"
+              }, null, 8, ["modelValue"]),
+              Vue.createElementVNode("div", null, [
+                Vue.createVNode(_component_el_button, {
+                  type: "primary",
+                  link: "",
+                  onClick: ($event) => saveEditNode(node)
+                }, {
+                  default: Vue.withCtx(() => _cache[2] || (_cache[2] = [
+                    Vue.createTextVNode(" 保存 ", -1)
+                  ])),
+                  _: 2,
+                  __: [2]
+                }, 1032, ["onClick"]),
+                Vue.createVNode(_component_el_button, {
+                  style: { "margin-left": "4px" },
+                  type: "primary",
+                  link: "",
+                  onClick: ($event) => cancelEditNode(node, _ctx.configure, _ctx.pageContext)
+                }, {
+                  default: Vue.withCtx(() => _cache[3] || (_cache[3] = [
+                    Vue.createTextVNode(" 撤销 ", -1)
+                  ])),
+                  _: 2,
+                  __: [3]
+                }, 1032, ["onClick"])
+              ])
+            ])) : (Vue.openBlock(), Vue.createElementBlock("span", {
+              key: 1,
+              title: node.label,
+              class: "ellipsis"
+            }, [
+              data.iconValue ? (Vue.openBlock(), Vue.createBlock(_component_SuperIcon, {
+                key: 0,
+                iconType: data.iconType,
+                iconValue: data.iconValue
+              }, null, 8, ["iconType", "iconValue"])) : designProperty.value.iconValue ? (Vue.openBlock(), Vue.createBlock(_component_SuperIcon, {
+                key: 1,
+                iconType: designProperty.value.iconType,
+                iconValue: designProperty.value.iconValue
+              }, null, 8, ["iconType", "iconValue"])) : (Vue.openBlock(), Vue.createElementBlock(Vue.Fragment, { key: 2 }, [
+                !data.isLeaf ? (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_3, [
+                  Vue.createElementVNode("div", _hoisted_4, [
+                    _cache[4] || (_cache[4] = Vue.createElementVNode("img", {
+                      src: folder,
+                      class: "file"
+                    }, null, -1)),
+                    Vue.createElementVNode("span", null, Vue.toDisplayString(data.name), 1)
+                  ])
+                ])) : (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_5, [
+                  _cache[5] || (_cache[5] = Vue.createElementVNode("img", {
+                    src: file,
+                    class: "file"
+                  }, null, -1)),
+                  Vue.createElementVNode("span", null, Vue.toDisplayString(data.name), 1)
+                ]))
+              ], 64))
+            ], 8, _hoisted_2))
+          ]),
+          _: 1
+        }, 8, ["style", "data", "props", "default-expand-all", "expand-on-click-node", "indent", "accordion", "show-checkbox", "lazy"])) : Vue.createCommentVNode("", true),
+        Vue.withDirectives(Vue.createElementVNode("div", null, [
+          Vue.createElementVNode("ul", {
+            ref_key: "contxtMenuRef",
+            ref: contxtMenuRef,
+            class: "context-menu"
+          }, [
+            (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(hasPermissionContextMenus.value, (item, index2) => {
+              return Vue.openBlock(), Vue.createElementBlock("li", {
+                key: index2,
+                tabindex: "-1",
+                class: "menu__item",
+                onClick: ($event) => clickContextMenuEvent(item)
+              }, [
+                Vue.createElementVNode("span", null, Vue.toDisplayString(item.name), 1)
+              ], 8, _hoisted_6);
+            }), 128))
+          ], 512)
+        ], 512), [
+          [Vue.vShow, showContextMenu.value && ((_a2 = hasPermissionContextMenus.value) == null ? void 0 : _a2.length) > 0]
+        ])
+      ], 2);
+    };
+  }
+});
+module.exports = _sfc_main;

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

@@ -0,0 +1,22 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    configure: {
+        type: ObjectConstructor;
+        default: {
+            name: string;
+        };
+    };
+    selectWidget: ObjectConstructor;
+    indexObj: ObjectConstructor;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    configure: {
+        type: ObjectConstructor;
+        default: {
+            name: string;
+        };
+    };
+    selectWidget: ObjectConstructor;
+    indexObj: ObjectConstructor;
+}>> & Readonly<{}>, {
+    configure: Record<string, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,22 @@
+"use strict";
+const Vue = require("vue");
+const _hoisted_1 = { style: { "text-align": "center", "color": "red" } };
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "error-render",
+  props: {
+    configure: {
+      type: Object,
+      default: {
+        name: "未知"
+      }
+    },
+    selectWidget: Object,
+    indexObj: Object
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return Vue.openBlock(), Vue.createElementBlock("div", _hoisted_1, " 不能识别的组件类型【" + Vue.toDisplayString(__props.configure.name) + "】 ", 1);
+    };
+  }
+});
+module.exports = _sfc_main;

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

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

package/dist/lib/components/runtime/views/assemblys/form/checkbox/checkbox-runtime.vue.js

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