super-page-runtime 2.0.40 → 2.0.42

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

@@ -0,0 +1,71 @@
+"use strict";
+const Vue = require("vue");
+const pageInitUtil = require("../../../../utils/page-init-util.js");
+const pageHelperUtil = require("../../../../utils/page-helper-util.js");
+const eventUtil = require("../../../../utils/events/event-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 = Vue.ref(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: designProperty.value.required ? true : false,
+          class: Vue.normalizeClass(Vue.unref(runtimeClass)),
+          "label-width": designProperty.value.labelWidth,
+          style: Vue.normalizeStyle(Vue.unref(runtimeStyle))
+        }, {
+          label: Vue.withCtx(() => [
+            designProperty.value.tittleShow ? (Vue.openBlock(), Vue.createElementBlock("div", {
+              key: 0,
+              style: Vue.normalizeStyle({ ...Vue.unref(headerStyle) })
+            }, Vue.toDisplayString(designProperty.value.title), 5)) : Vue.createCommentVNode("", true)
+          ]),
+          default: Vue.withCtx(() => [
+            Vue.createVNode(_component_el_input, {
+              disabled: designProperty.value.state === "disabled",
+              readonly: designProperty.value.state === "readonly",
+              size: designProperty.value.size,
+              clearable: designProperty.value.clearable,
+              placeholder: designProperty.value.placeholder,
+              modelValue: dynamicModelMethod.value,
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => dynamicModelMethod.value = $event),
+              rows: designProperty.value.rows ? designProperty.value.rows : 2,
+              maxlength: designProperty.value.maxLength,
+              "show-word-limit": designProperty.value.showInputNum,
+              type: "textarea",
+              onInput: _cache[1] || (_cache[1] = ($event) => Vue.unref(eventUtil.handleEvent)($event, _ctx.pageContext, _ctx.configure, "input")),
+              onChange: _cache[2] || (_cache[2] = ($event) => Vue.unref(eventUtil.handleEvent)($event, _ctx.pageContext, _ctx.configure, "change")),
+              onBlur: _cache[3] || (_cache[3] = ($event) => Vue.unref(eventUtil.handleEvent)($event, _ctx.pageContext, _ctx.configure, "blur")),
+              onFocus: _cache[4] || (_cache[4] = ($event) => Vue.unref(eventUtil.handleEvent)($event, _ctx.pageContext, _ctx.configure, "focus")),
+              onClick: _cache[5] || (_cache[5] = ($event) => Vue.unref(eventUtil.handleEvent)($event, _ctx.pageContext, _ctx.configure, "click"))
+            }, 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/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<__VLS_TypePropsToRuntimeProps<MyProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<MyProps>>>, {}, {}>;
+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,154 @@
+"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 _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);
+    if (props.configure && props.configure.props && props.configure.props.base) {
+      props.configure.props.base.functionCode = permissionCodes;
+    }
+    pageInitUtil.packageFormRules(props.pageContext, props.configure);
+    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() {
+          showFlag.value = true;
+        };
+      }
+      if (el && !el.hide) {
+        el.hide = function() {
+          showFlag.value = false;
+        };
+      }
+      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.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;
+      }
+      dynamicallyCalculatePosition();
+    });
+    const dynamicallyCalculatePosition = () => {
+      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) ? Vue.unref(permissionCodes) : "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/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,39 @@
+"use strict";
+const Vue = require("vue");
+require("../../../../utils/eventBus.js");
+const commonUtil = require("../../../../utils/common-util.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "pictureflow-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const maxHeight = Vue.ref(null);
+    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.openBlock(), Vue.createBlock(_component_workflow_history, {
+        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,39 @@
+"use strict";
+const Vue = require("vue");
+require("../../../../utils/eventBus.js");
+const commonUtil = require("../../../../utils/common-util.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "textflow-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const maxHeight = Vue.ref(null);
+    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(
+        () => props.pageContext.entity.task.id,
+        () => {
+          if (workflowId && historyList.value) {
+            historyList.value.refresh();
+          }
+        },
+        { immediate: true }
+      );
+    }
+    return (_ctx, _cache) => {
+      const _component_workflow_history_list = Vue.resolveComponent("workflow-history-list");
+      return Vue.openBlock(), Vue.createBlock(_component_workflow_history_list, {
+        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,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/dist/lib/components/runtime/views/assemblys/workflow/workflow-button/workflowbutton-runtime.vue2.js

@@ -0,0 +1,59 @@
+"use strict";
+const Vue = require("vue");
+const objectRender_vue_vue_type_script_setup_true_lang = require("../../object-render.vue.js");
+const eventUtil = require("../../../../utils/events/event-util.js");
+const standardEvent = require("../../../../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) => {
+      if (isVisibleBtn(item)) {
+        visibleBtns.value.push(item);
+      }
+    });
+    function getStandardClickEvent(events) {
+      const clickEventFunObj = eventUtil.getClickEventFuncByType(props.pageContext, events, "click");
+      if (clickEventFunObj) {
+        const isStandardEvent = clickEventFunObj.isStandard;
+        if (isStandardEvent) {
+          return clickEventFunObj.event.eventName;
+        }
+      }
+    }
+    function isVisibleBtn(btnConfigure) {
+      const events = btnConfigure.runtime && btnConfigure.runtime.events ? btnConfigure.runtime.events : [];
+      const workflowStandardEventName = getStandardClickEvent(events);
+      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;

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

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

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

@@ -0,0 +1,79 @@
+"use strict";
+const Vue = require("vue");
+const superPage_vue_vue_type_script_setup_true_lang = require("./super-page.vue.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "super-page-dialog",
+  props: {
+    parentPageContext: {},
+    parentPageEventParams: {},
+    jumpPageSetting: {},
+    isTest: { type: Boolean }
+  },
+  emits: ["open", "opened", "close", "closed"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const showContent = Vue.ref(true);
+    const myJumpPageSetting = props.jumpPageSetting ? props.jumpPageSetting : null;
+    const width = Vue.ref(null);
+    const title = Vue.ref(null);
+    const pageCode = Vue.ref(null);
+    const dataId = Vue.ref(null);
+    const taskId = Vue.ref(null);
+    const pageRequest = Vue.ref({});
+    if (myJumpPageSetting) {
+      title.value = myJumpPageSetting && myJumpPageSetting["jumpPageTitle"] ? myJumpPageSetting["jumpPageTitle"] : null;
+      width.value = myJumpPageSetting && myJumpPageSetting["jumpPageWidth"] ? myJumpPageSetting["jumpPageWidth"] : "100%";
+      pageCode.value = myJumpPageSetting && myJumpPageSetting["pageCode"];
+      dataId.value = myJumpPageSetting && myJumpPageSetting["dataId"] ? myJumpPageSetting["dataId"] : null;
+      taskId.value = myJumpPageSetting && myJumpPageSetting["taskId"] ? myJumpPageSetting["taskId"] : null;
+      if (props.parentPageEventParams) {
+        try {
+          const pageParams = JSON.parse(JSON.stringify(props.parentPageEventParams));
+          if (pageParams["pageContext"]) {
+            delete pageParams["pageContext"];
+          }
+          if (pageParams["configureObj"]) {
+            delete pageParams["configureObj"];
+          }
+          Object.assign(pageRequest.value, pageParams);
+        } catch (error) {
+          console.error(error);
+        }
+        if (dataId.value === null || dataId.value === void 0) {
+          dataId.value = props.parentPageEventParams["id"];
+        }
+      }
+      pageRequest.value["parentPageCode"] = myJumpPageSetting && myJumpPageSetting["parentPageCode"] ? myJumpPageSetting["parentPageCode"] : null;
+      pageRequest.value["parentPageVersion"] = myJumpPageSetting && myJumpPageSetting["parentPageVersion"] ? myJumpPageSetting["parentPageVersion"] : null;
+      pageRequest.value["jumpMode"] = myJumpPageSetting ? myJumpPageSetting["jumpMode"] : null;
+      pageRequest.value["id"] = dataId.value;
+      pageRequest.value["taskId"] = taskId.value;
+    }
+    return (_ctx, _cache) => {
+      const _component_el_drawer = Vue.resolveComponent("el-drawer");
+      return Vue.openBlock(), Vue.createBlock(_component_el_drawer, {
+        modelValue: showContent.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => showContent.value = $event),
+        "with-header": !title.value,
+        title: title.value,
+        direction: "btt",
+        size: width.value,
+        onOpen: _cache[1] || (_cache[1] = ($event) => emits("open")),
+        onOpened: _cache[2] || (_cache[2] = ($event) => emits("opened")),
+        onClose: _cache[3] || (_cache[3] = ($event) => emits("close")),
+        onClosed: _cache[4] || (_cache[4] = ($event) => emits("closed"))
+      }, {
+        default: Vue.withCtx(() => [
+          pageCode.value ? (Vue.openBlock(), Vue.createBlock(superPage_vue_vue_type_script_setup_true_lang, {
+            key: 0,
+            pageCode: pageCode.value,
+            pageRequest: pageRequest.value
+          }, null, 8, ["pageCode", "pageRequest"])) : Vue.createCommentVNode("", true)
+        ]),
+        _: 1
+      }, 8, ["modelValue", "with-header", "title", "size"]);
+    };
+  }
+});
+module.exports = _sfc_main;

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

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

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

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