super-page-designer 0.0.2-tmp9 → 1.0.2

package/dist/lib/components/design/views/design/view/view-design-display.vue.js

@@ -0,0 +1,396 @@
+"use strict";
+const vue = require("vue");
+const Icons = require("@element-plus/icons");
+const vueDraggablePlus = require("vue-draggable-plus");
+const objectDesign_vue_vue_type_script_setup_true_lang = require("../../assemblys/object-design.vue.js");
+const commonUtil = require("../../../utils/common-util.js");
+const pageHelperUtil = require("../../../utils/page-helper-util.js");
+const containerDesignUtil = require("../../../utils/container-design-util.js");
+const viewDesignPreview_vue_vue_type_script_setup_true_lang = require("./view-design-preview.vue.js");
+const pageEventContent = require("../page-event/page-event-content.vue.js");
+const pageTableUtil = require("../../../utils/page-table-util.js");
+const http = require("agilebuilder-ui/src/utils/request");
+const elementPlus = require("element-plus");
+const _hoisted_1 = { class: "amb-design-tool" };
+const _hoisted_2 = {
+  class: "amb-page-type",
+  style: { "margin-left": "0px" }
+};
+const _hoisted_3 = { class: "amb-page-type" };
+const _hoisted_4 = { style: { "float": "right", "margin-right": "10px" } };
+const _hoisted_5 = /* @__PURE__ */ vue.createElementVNode("label", null, "保存", -1);
+const _hoisted_6 = /* @__PURE__ */ vue.createElementVNode("label", null, "预览", -1);
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "view-design-display",
+  props: {
+    configure: {},
+    selectWidget: {},
+    selAsselbyType: {}
+  },
+  emits: [
+    "onSelectWidget",
+    "onCustomAttrWidget",
+    "changeSelectEvent",
+    "addEvent",
+    "changeSelectStandardEvent"
+  ],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const $emits = __emit;
+    if (props.configure.props == void 0) {
+      props.configure.props = {};
+    }
+    if (props.configure.style == void 0) {
+      props.configure.style = {};
+    }
+    if (props.configure.items == void 0 || props.configure.items == null) {
+      props.configure.items = [];
+    }
+    const pageItems = props.configure.items;
+    const pageDesignPreview = vue.ref(null);
+    const componentIndexObj = vue.reactive({
+      index: 0
+    });
+    const designStyle = vue.ref({});
+    const designClass = vue.ref("");
+    caculateNewStyle();
+    const dynamicPageSizeStyle = vue.computed(function() {
+      let pageWidth = null;
+      if (props.configure.dimensions == "ipad") {
+        pageWidth = 768;
+      } else if (props.configure.dimensions == "phone") {
+        pageWidth = 414;
+      }
+      const styleInfo = {
+        width: pageWidth ? pageWidth + "px" : ""
+      };
+      for (let field in designStyle.value) {
+        styleInfo[field] = designStyle.value[field];
+      }
+      return styleInfo;
+    });
+    vue.watch(props.configure.props, () => {
+      caculateNewStyle();
+    });
+    vue.watch(props.configure.style, () => {
+      caculateNewStyle();
+    });
+    function caculateNewStyle() {
+      containerDesignUtil.caculatePageStyle(props.configure, designStyle, designClass);
+      if (!props.configure.runtime) {
+        props.configure.runtime = {};
+      }
+      props.configure.runtime.class = designClass.value;
+      props.configure.runtime.style = designStyle.value;
+    }
+    const winHeight = vue.ref();
+    const contentHeightStyle = vue.computed(() => {
+      return {
+        height: winHeight.value + "px"
+      };
+    });
+    const ambPageDesignContent = vue.ref(null);
+    vue.onMounted(() => {
+      if (ambPageDesignContent.value) {
+        const rect = ambPageDesignContent.value.getBoundingClientRect();
+        if (rect.y) {
+          winHeight.value = window.innerHeight - rect.y;
+        }
+        pageHelperUtil.addComponentRef(props.configure, -1, ambPageDesignContent);
+      }
+    });
+    function pageDesignClick(evt) {
+      $emits("onSelectWidget", -1);
+    }
+    function onSelectWidget(selIndex, objConfigure) {
+      $emits("onSelectWidget", selIndex, objConfigure);
+    }
+    function onCustomAttrWidget(itemConfigure, itemAttrComponent) {
+      $emits("onCustomAttrWidget", itemConfigure, itemAttrComponent);
+    }
+    function copyItem(sourceItem) {
+      const index = pageItems.indexOf(sourceItem);
+      const copyObj = vue.reactive(commonUtil.deepCopy(sourceItem));
+      copyObj.uuid = commonUtil.getUuidv4();
+      pageItems.splice(index, 0, copyObj);
+    }
+    function deleteItem(sourceItem) {
+      if (sourceItem.items && sourceItem.items.length > 0) {
+        if (!confirm("还有子元素，确定要删除吗?")) {
+          return;
+        }
+      }
+      const index = pageItems.indexOf(sourceItem);
+      if (index > -1) {
+        pageItems.splice(index, 1);
+      }
+    }
+    const pageDesignBoardMain = vue.ref(null);
+    vueDraggablePlus.useDraggable(pageDesignBoardMain, pageItems, {
+      group: "amb-assembly-item",
+      animation: 300,
+      ghostClass: "amb-item-ghost",
+      forceFallback: true,
+      onAdd(event) {
+      }
+    });
+    function saveForm() {
+      const configureCopy = JSON.parse(JSON.stringify(props.configure));
+      configureCopy.tableRuntimes = {};
+      if (configureCopy.tableUuids) {
+        configureCopy.tableUuids.forEach((tableUuid) => {
+          const table = commonUtil.findDesignItemByUuid(configureCopy, tableUuid);
+          if (table) {
+            pageTableUtil.setTableRuntimesFromConfigure(table, configureCopy);
+          }
+        });
+      }
+      http.post("/component/super-page-design/save", { id: 30, designJson: JSON.stringify(configureCopy) }).then((res) => {
+        console.log(res);
+        elementPlus.ElMessage({
+          message: "保存成功",
+          type: "success"
+        });
+      }).catch((error) => {
+        console.log(error);
+        elementPlus.ElMessage({
+          message: "保存失败",
+          type: "error"
+        });
+      });
+    }
+    const previewVisible = vue.ref(false);
+    function preview() {
+      const configureCopy = JSON.parse(JSON.stringify(props.configure));
+      configureCopy.tableRuntimes = {};
+      if (configureCopy.tableUuids) {
+        configureCopy.tableUuids.forEach((tableUuid) => {
+          const table = commonUtil.findDesignItemByUuid(configureCopy, tableUuid);
+          if (table) {
+            pageTableUtil.setTableRuntimesFromConfigure(table, configureCopy);
+          }
+        });
+        console.log("saveForm----setTableRuntimes=", configureCopy);
+      }
+      pageDesignPreview.value = configureCopy;
+      previewVisible.value = true;
+    }
+    const handleTypeVal = vue.ref(null);
+    const eventFormContent = vue.ref({});
+    const customEventContent = vue.ref({});
+    const isShowEventContent = vue.ref(false);
+    function onSelectEvent(newValue) {
+      if (newValue && newValue === "selected") {
+        isShowEventContent.value = true;
+      } else {
+        isShowEventContent.value = false;
+      }
+    }
+    function addEvent(eventForm, handleType) {
+      eventFormContent.value = eventForm;
+      const customEvent = getCustomEventByEventName(eventForm.eventName);
+      if (customEvent) {
+        customEventContent.value = customEvent;
+      }
+      if (handleType) {
+        handleTypeVal.value = handleType;
+      } else {
+        handleTypeVal.value = "event";
+      }
+      refreshJsContent();
+    }
+    function changeEvent(eventForm) {
+      if (!eventForm) {
+        isShowEventContent.value = false;
+      } else {
+        handleTypeVal.value = null;
+        eventFormContent.value = eventForm;
+        const customEvent = getCustomEventByEventName(eventForm.eventName);
+        if (customEvent) {
+          customEventContent.value = customEvent;
+        } else {
+          customEventContent.value = null;
+        }
+        refreshJsContent();
+      }
+    }
+    function refreshJsContent() {
+      isShowEventContent.value = false;
+      setTimeout(() => {
+        isShowEventContent.value = true;
+      }, 1);
+    }
+    function getCustomEventByEventName(eventName) {
+      if (props.configure.customEvents) {
+        let eventObjs = props.configure.customEvents.filter((event) => event.eventName === eventName);
+        if (eventObjs && eventObjs.length > 0) {
+          return eventObjs[0];
+        }
+      }
+    }
+    function changeSelectEvent(customEvent) {
+      $emits("changeSelectEvent", customEvent);
+    }
+    function addEventClick(eventForm) {
+      $emits("addEvent", eventForm);
+    }
+    function changeSelectStandardEvent(eventName, eventLabel) {
+      $emits("changeSelectStandardEvent", eventName, eventLabel);
+    }
+    __expose({ onSelectEvent, addEvent, changeEvent });
+    return (_ctx, _cache) => {
+      const _component_el_icon = vue.resolveComponent("el-icon");
+      const _component_el_divider = vue.resolveComponent("el-divider");
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+        vue.createElementVNode("div", {
+          class: "amb-design-content",
+          ref_key: "ambPageDesignContent",
+          ref: ambPageDesignContent,
+          style: vue.normalizeStyle(contentHeightStyle.value)
+        }, [
+          vue.createElementVNode("div", _hoisted_1, [
+            vue.withDirectives(vue.createElementVNode("label", {
+              class: vue.normalizeClass(["amb-page-type", { selected: !_ctx.configure.dimensions || _ctx.configure.dimensions == "pc" }]),
+              onClick: _cache[0] || (_cache[0] = ($event) => _ctx.configure.dimensions = "pc")
+            }, [
+              vue.createVNode(_component_el_icon, { size: 25 }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(Icons.Monitor))
+                ]),
+                _: 1
+              })
+            ], 2), [
+              [vue.vShow, _ctx.selAsselbyType === "assembly"]
+            ]),
+            vue.withDirectives(vue.createElementVNode("label", {
+              class: vue.normalizeClass(["amb-page-type", { selected: _ctx.configure.dimensions == "ipad" }]),
+              onClick: _cache[1] || (_cache[1] = ($event) => _ctx.configure.dimensions = "ipad")
+            }, [
+              vue.createVNode(_component_el_icon, { size: 23 }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(Icons.Cellphone))
+                ]),
+                _: 1
+              })
+            ], 2), [
+              [vue.vShow, _ctx.selAsselbyType === "assembly"]
+            ]),
+            vue.withDirectives(vue.createElementVNode("label", {
+              class: vue.normalizeClass(["amb-page-type", { selected: _ctx.configure.dimensions == "phone" }]),
+              onClick: _cache[2] || (_cache[2] = ($event) => _ctx.configure.dimensions = "phone")
+            }, [
+              vue.createVNode(_component_el_icon, { size: 23 }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(Icons.Iphone))
+                ]),
+                _: 1
+              })
+            ], 2), [
+              [vue.vShow, _ctx.selAsselbyType === "assembly"]
+            ]),
+            vue.withDirectives(vue.createVNode(_component_el_divider, {
+              direction: "vertical",
+              class: "amb-design-tool-split"
+            }, null, 512), [
+              [vue.vShow, _ctx.selAsselbyType === "assembly"]
+            ]),
+            vue.createElementVNode("label", _hoisted_2, [
+              vue.createVNode(_component_el_icon, { size: 23 }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(Icons.ArrowLeft))
+                ]),
+                _: 1
+              })
+            ]),
+            vue.createElementVNode("label", _hoisted_3, [
+              vue.createVNode(_component_el_icon, { size: 23 }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(Icons.ArrowRight))
+                ]),
+                _: 1
+              })
+            ]),
+            vue.createElementVNode("div", _hoisted_4, [
+              vue.createElementVNode("label", {
+                class: "amb-page-type",
+                onClick: _cache[3] || (_cache[3] = ($event) => saveForm())
+              }, [
+                vue.createVNode(_component_el_icon, { size: 18 }, {
+                  default: vue.withCtx(() => [
+                    vue.createVNode(vue.unref(Icons.Check))
+                  ]),
+                  _: 1
+                }),
+                _hoisted_5
+              ]),
+              vue.createVNode(_component_el_divider, {
+                direction: "vertical",
+                class: "amb-design-tool-split"
+              }),
+              vue.createElementVNode("label", {
+                class: "amb-page-type",
+                style: { "margin-left": "0px" },
+                onClick: _cache[4] || (_cache[4] = ($event) => preview())
+              }, [
+                vue.createVNode(_component_el_icon, { size: 18 }, {
+                  default: vue.withCtx(() => [
+                    vue.createVNode(vue.unref(Icons.View))
+                  ]),
+                  _: 1
+                }),
+                _hoisted_6
+              ])
+            ])
+          ]),
+          vue.withDirectives(vue.createElementVNode("div", {
+            class: vue.normalizeClass(["amb-design-board", designClass.value]),
+            ref_key: "pageDesignBoardMain",
+            ref: pageDesignBoardMain,
+            style: vue.normalizeStyle(dynamicPageSizeStyle.value),
+            onClick: pageDesignClick
+          }, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(pageItems), (element, itemIndex) => {
+              return vue.openBlock(), vue.createBlock(objectDesign_vue_vue_type_script_setup_true_lang, {
+                key: element,
+                indexObj: componentIndexObj,
+                configure: element,
+                pageDesign: _ctx.configure,
+                selectWidget: _ctx.selectWidget,
+                onOnSelectWidget: onSelectWidget,
+                onOnCustomAttrWidget: onCustomAttrWidget,
+                onOnCopy: copyItem,
+                onOnDelete: deleteItem
+              }, null, 8, ["indexObj", "configure", "pageDesign", "selectWidget"]);
+            }), 128))
+          ], 6), [
+            [vue.vShow, _ctx.selAsselbyType === "assembly"]
+          ]),
+          isShowEventContent.value ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            class: vue.normalizeClass(["amb-design-board", designClass.value]),
+            style: vue.normalizeStyle(dynamicPageSizeStyle.value)
+          }, [
+            vue.createVNode(pageEventContent, {
+              ref: "pageEventContentRef",
+              configure: _ctx.configure,
+              handleType: handleTypeVal.value,
+              eventForm: eventFormContent.value,
+              customEvent: customEventContent.value,
+              onChangeSelectEvent: changeSelectEvent,
+              onAddEvent: addEventClick,
+              onChangeSelectStandardEvent: changeSelectStandardEvent
+            }, null, 8, ["configure", "handleType", "eventForm", "customEvent"])
+          ], 6)) : vue.createCommentVNode("", true)
+        ], 4),
+        previewVisible.value ? (vue.openBlock(), vue.createBlock(viewDesignPreview_vue_vue_type_script_setup_true_lang, {
+          key: 0,
+          pageDesign: pageDesignPreview.value,
+          modelValue: previewVisible.value,
+          "onUpdate:modelValue": _cache[5] || (_cache[5] = ($event) => previewVisible.value = $event),
+          onClose: _cache[6] || (_cache[6] = ($event) => previewVisible.value = false)
+        }, null, 8, ["pageDesign", "modelValue"])) : vue.createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/design/views/design/view/view-design-display.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const viewDesignDisplay_vue_vue_type_script_setup_true_lang = require("./view-design-display.vue.js");
+module.exports = viewDesignDisplay_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/design/views/design/view/view-design-preview.vue.js

@@ -0,0 +1,38 @@
+"use strict";
+const vue = require("vue");
+require("@element-plus/icons");
+const superPageRuntime = require("super-page-runtime");
+const system = require("../../../utils/system.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "view-design-preview",
+  props: {
+    pageDesign: {}
+  },
+  emits: ["close"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const title = vue.computed(() => {
+      return "预览【" + props.pageDesign.label + "】";
+    });
+    const emits = __emit;
+    return (_ctx, _cache) => {
+      const _component_el_dialog = vue.resolveComponent("el-dialog");
+      return vue.openBlock(), vue.createBlock(_component_el_dialog, {
+        fullscreen: "",
+        "close-on-press-escape": "",
+        title: title.value,
+        onClose: _cache[0] || (_cache[0] = ($event) => emits("close"))
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(vue.unref(superPageRuntime.SuperPage), {
+            pageDesign: _ctx.pageDesign,
+            publishVersion: vue.unref(system.getPublishVersion),
+            isTest: true
+          }, null, 8, ["pageDesign", "publishVersion"])
+        ]),
+        _: 1
+      }, 8, ["title"]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/design/views/design/view/view-design-preview.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const viewDesignPreview_vue_vue_type_script_setup_true_lang = require("./view-design-preview.vue.js");
+module.exports = viewDesignPreview_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/design/views/design/view/view-design.vue.js

@@ -0,0 +1,126 @@
+"use strict";
+const vue = require("vue");
+const assemblysContainer_vue_vue_type_script_setup_true_lang = require("./assemblys-container.vue.js");
+const viewDesignDisplay_vue_vue_type_script_setup_true_lang = require("./view-design-display.vue.js");
+const attrContainer_vue_vue_type_script_setup_true_lang = require("./attr-container.vue.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "view-design",
+  props: {
+    configure: {}
+  },
+  emits: ["addEvent", "changeEvent", "onSelectEvent"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const configure = props.configure;
+    if (configure.items == void 0) {
+      configure.items = [];
+    }
+    const designItems = configure.items;
+    const selectWidget = vue.reactive({
+      value: -1
+    });
+    const attrContainerRef = vue.ref(null);
+    let selAsselbyType = vue.ref("assembly");
+    function onSelectWidget(selIndex, objConfigure) {
+      selIndex = selIndex == void 0 ? -1 : selIndex;
+      selectWidget.value = selIndex;
+      if (selIndex == -1) {
+        objConfigure = configure;
+      }
+      if (attrContainerRef.value && attrContainerRef.value) {
+        if (objConfigure.style == void 0) {
+          objConfigure.style = {};
+        }
+        if (objConfigure.props == void 0) {
+          objConfigure.props = {};
+        }
+        if (objConfigure.events == void 0) {
+          objConfigure.events = [];
+        }
+        attrContainerRef.value.changeAssembly(objConfigure);
+      }
+    }
+    function onCustomAttrWidget(itemConfigure, itemAttrComponent) {
+      attrContainerRef.value.changeAssemblyByComponent(itemConfigure, itemAttrComponent);
+    }
+    const viewDesignDisplayRef = vue.ref(null);
+    function onSelectEvent(newValue) {
+      if (newValue && newValue === "selected") {
+        selAsselbyType.value = "pageEvent";
+      } else {
+        selAsselbyType.value = "assembly";
+      }
+      viewDesignDisplayRef.value.onSelectEvent(newValue);
+    }
+    function addEvent(eventForm, handleType) {
+      viewDesignDisplayRef.value.addEvent(eventForm, handleType);
+    }
+    function changeEvent(eventForm) {
+      viewDesignDisplayRef.value.changeEvent(eventForm);
+    }
+    const assemblysContainerRef = vue.ref(null);
+    function changeSelectEvent(customEvent) {
+      assemblysContainerRef.value.changeSelectEvent(customEvent);
+    }
+    function addEventClick(eventForm) {
+      assemblysContainerRef.value.doCreateEvent(eventForm);
+    }
+    function changeSelectStandardEvent(eventName, eventLabel) {
+      assemblysContainerRef.value.changeSelectStandardEvent(eventName, eventLabel);
+    }
+    return (_ctx, _cache) => {
+      const _component_el_aside = vue.resolveComponent("el-aside");
+      const _component_el_main = vue.resolveComponent("el-main");
+      const _component_el_container = vue.resolveComponent("el-container");
+      return vue.openBlock(), vue.createBlock(_component_el_container, { class: "amb-container" }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_el_aside, { class: "amb-container-left" }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(assemblysContainer_vue_vue_type_script_setup_true_lang, {
+                ref_key: "assemblysContainerRef",
+                ref: assemblysContainerRef,
+                configure: vue.unref(configure),
+                designItems: vue.unref(designItems),
+                selectWidget,
+                onOnSelectWidget: onSelectWidget,
+                onAddEvent: addEvent,
+                onChangeEvent: changeEvent,
+                onOnSelectEvent: onSelectEvent
+              }, null, 8, ["configure", "designItems", "selectWidget"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(_component_el_main, { class: "amb-container-main" }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(viewDesignDisplay_vue_vue_type_script_setup_true_lang, {
+                ref_key: "viewDesignDisplayRef",
+                ref: viewDesignDisplayRef,
+                configure: vue.unref(configure),
+                selectWidget,
+                selAsselbyType: vue.unref(selAsselbyType),
+                onOnSelectWidget: onSelectWidget,
+                onOnCustomAttrWidget: onCustomAttrWidget,
+                onChangeSelectEvent: changeSelectEvent,
+                onAddEvent: addEventClick,
+                onChangeSelectStandardEvent: changeSelectStandardEvent
+              }, null, 8, ["configure", "selectWidget", "selAsselbyType"])
+            ]),
+            _: 1
+          }),
+          vue.createVNode(_component_el_aside, { class: "amb-container-attr" }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(attrContainer_vue_vue_type_script_setup_true_lang, {
+                pageInfo: vue.unref(configure),
+                ref_key: "attrContainerRef",
+                ref: attrContainerRef
+              }, null, 8, ["pageInfo"])
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/design/views/design/view/view-design.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const viewDesign_vue_vue_type_script_setup_true_lang = require("./view-design.vue.js");
+module.exports = viewDesign_vue_vue_type_script_setup_true_lang;

package/dist/lib/index.d.ts

@@ -1,3 +1,3 @@
-import { Design, WfEditor } from './components/design';
+import { default as Design } from './components/design';
 
-export { Design, WfEditor };
+export { Design };

package/dist/lib/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+;/* empty css                        */
+const pageDesign_vue_vue_type_script_setup_true_lang = require("./components/design/views/design/page-design.vue.js");
+exports.Design = pageDesign_vue_vue_type_script_setup_true_lang;

package/dist/lib/stores/page-store.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const pinia = require("pinia");
+const pagePermissionUtil = require("super-page-runtime/src/components/runtime/utils/page-permission-util");
+const usePageContextStore = pinia.defineStore("pageContextUtil", () => {
+  const pageContext = vue.ref({ systemCode: "", systemVersion: -1 });
+  vue.ref([]);
+  const pageContextVarOptions = vue.ref({
+    dataOptions: [],
+    systemVarOptions: [],
+    pageVarOptions: []
+  });
+  function setPageContext(newPageContext) {
+    pageContext.value = newPageContext;
+    setPageContextVarOptions(newPageContext);
+  }
+  function setPageContextVarOptions(pageObject) {
+    if (pageObject) {
+      pageContextVarOptions.value.dataOptions = [];
+      pageObject.modelFields.forEach((element) => {
+        pageContextVarOptions.value.dataOptions.push({
+          value: element.name,
+          label: element.alias
+        });
+      });
+      pageContextVarOptions.value.pageVarOptions = setVarOptions(pageObject.variables);
+    }
+  }
+  function setVarOptions(variables, parentName) {
+    const tempVarOptions = [];
+    if (variables) {
+      variables.forEach((element) => {
+        if (element.name === "bbb")
+          ;
+        const item = {
+          code: element.code,
+          value: element.name,
+          label: element.alias
+        };
+        if (parentName) {
+          item.value = `${parentName}.${element.name}`;
+        }
+        if (element.items && element.items.length > 0 && element.type !== "array") {
+          item.items = setVarOptions(element.items, element.name);
+        }
+        tempVarOptions.push(item);
+      });
+    }
+    return tempVarOptions;
+  }
+  function getModelField(fieldName) {
+    if (!fieldName) {
+      return null;
+    }
+    const modelFields = pageContext.value && pageContext.value.modelFields ? pageContext.value.modelFields : [];
+    if (!modelFields) {
+      return null;
+    }
+    for (let item of modelFields) {
+      if (item.name == fieldName) {
+        return item;
+      }
+    }
+    return null;
+  }
+  function getPagePermissionOptions() {
+    const options = [];
+    if (pageContext.value != null && pageContext.value.pagePermissions) {
+      for (let p of pageContext.value.pagePermissions) {
+        if (!p.simpleCode || p.simpleCode === "page") {
+          continue;
+        }
+        if (pagePermissionUtil.FuncType.AUTHORIZED === p.funcType || !p.funcType) {
+          options.push({
+            value: p.simpleCode,
+            sourceType: p.type,
+            //来源类型
+            label: p.simpleCode + (p.name ? "-" + p.name : "")
+          });
+        }
+      }
+    }
+    return options;
+  }
+  return {
+    pageContext,
+    pageContextVarOptions,
+    setPageContext,
+    getModelField,
+    getPagePermissionOptions
+  };
+});
+exports.usePageContextStore = usePageContextStore;