super-page-designer 0.0.1-tmp1

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

@@ -0,0 +1,68 @@
+"use strict";
+const vue = require("vue");
+const formDesignUtil = require("../../../../utils/form-design-util.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "textarea-design",
+  props: {
+    configure: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    if (!props.configure.runtime) {
+      props.configure.runtime = {};
+    }
+    const designStyle = vue.ref({});
+    const designClass = vue.ref("");
+    const designHeaderStyle = vue.ref({});
+    const designProperty = vue.ref({});
+    vue.watch(props.configure.style, () => {
+      formDesignUtil.caculateDetailComponentStyle(props.configure, designStyle, designClass, designHeaderStyle);
+      props.configure.runtime.style = designStyle.value;
+      props.configure.runtime.class = designClass.value;
+      props.configure.runtime.headerStyle = designHeaderStyle.value;
+    }, { immediate: true });
+    vue.watch(props.configure.props, () => {
+      formDesignUtil.caculateComponentProps(props.configure, designProperty);
+      props.configure.runtime.props = designProperty.value;
+    }, { immediate: true });
+    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,
+          class: vue.normalizeClass([designClass.value, "remove-formLabel-formContent-blankStyle"]),
+          "label-width": designProperty.value.labelWidth,
+          style: vue.normalizeStyle(designStyle.value)
+        }, {
+          label: vue.withCtx(() => [
+            designProperty.value.tittleShow ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 0,
+              style: vue.normalizeStyle({ ...designHeaderStyle.value, "padding-right": "12px" })
+            }, 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: designProperty.value.value,
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => designProperty.value.value = $event),
+              rows: designProperty.value.rows ? designProperty.value.rows : 2,
+              maxlength: designProperty.value.maxLength,
+              "show-word-limit": designProperty.value.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/dist/lib/components/design/views/assemblys/object-design.vue.d.ts

@@ -0,0 +1,48 @@
+import { PageDesign, Component } from '../../utils/interfaces/page-design-types';
+
+interface MyProps {
+    pageDesign?: PageDesign;
+    configure: Component;
+    selectWidget: object;
+    indexObj: any;
+    showSelectedClass: boolean;
+    errorBlank: boolean;
+}
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MyProps>, {
+    showSelectedClass: boolean;
+    errorBlank: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    onCopy: (...args: any[]) => void;
+    onSelectWidget: (...args: any[]) => void;
+    onCustomAttrWidget: (...args: any[]) => void;
+    onDelete: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MyProps>, {
+    showSelectedClass: boolean;
+    errorBlank: boolean;
+}>>> & {
+    onOnSelectWidget?: (...args: any[]) => any;
+    onOnCopy?: (...args: any[]) => any;
+    onOnCustomAttrWidget?: (...args: any[]) => any;
+    onOnDelete?: (...args: any[]) => any;
+}, {
+    errorBlank: boolean;
+    showSelectedClass: boolean;
+}, {}>;
+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;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,328 @@
+"use strict";
+const vue = require("vue");
+const Icons = require("@element-plus/icons");
+const errorDesign_vue_vue_type_script_setup_true_lang = require("./error-design.vue.js");
+const assemblysConfig = require("../../utils/assemblys-config.js");
+const containerDesignUtil = require("../../utils/container-design-util.js");
+const pageDesignTypes = require("../../utils/interfaces/page-design-types.js");
+const pagePermissionUtil = require("../../utils/page-permission-util.js");
+const formDesignUtil = require("../../utils/form-design-util.js");
+const pageStore = require("../../../../stores/page-store.js");
+const _hoisted_1 = { class: "amb-widget-item-tool" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "object-design",
+  props: {
+    pageDesign: {},
+    configure: {},
+    selectWidget: {},
+    indexObj: {},
+    showSelectedClass: { type: Boolean, default: true },
+    errorBlank: { type: Boolean, default: false }
+  },
+  emits: ["onSelectWidget", "onCustomAttrWidget", "onCopy", "onDelete"],
+  setup(__props, { emit: __emit }) {
+    const pageContextUtil = pageStore.usePageContextStore();
+    const props = __props;
+    if (props.configure.name === "table") {
+      if (props.pageDesign.tableRuntimes && props.pageDesign.tableRuntimes[props.configure.uuid]) {
+        const soureConfigureStr = props.pageDesign.tableRuntimes[props.configure.uuid].configure;
+        const soureConfigure = JSON.parse(soureConfigureStr);
+        Object.assign(props.configure, soureConfigure);
+        delete props.pageDesign.tableRuntimes[props.configure.uuid];
+      }
+    }
+    if (props.indexObj) {
+      props.indexObj.index++;
+    }
+    if (props.configure.props == void 0) {
+      props.configure.props = {};
+    }
+    if (props.configure.style == void 0) {
+      props.configure.style = {};
+    }
+    const fieldInfo = pageContextUtil.getModelField();
+    if (props.pageDesign && props.configure && props.configure.name == "table") {
+      if (props.configure.uuid) {
+        if (!props.pageDesign.tableUuids) {
+          props.pageDesign.tableUuids = [];
+        }
+        setTimeout(() => {
+          var _a, _b, _c, _d;
+          if (!((_b = (_a = props.pageDesign) == null ? void 0 : _a.tableUuids) == null ? void 0 : _b.includes(props.configure.uuid))) {
+            (_d = (_c = props.pageDesign) == null ? void 0 : _c.tableUuids) == null ? void 0 : _d.push(props.configure.uuid);
+          }
+        }, 500);
+        vue.onUnmounted(() => {
+          var _a, _b, _c, _d;
+          const uuidIndex = (_b = (_a = props.pageDesign) == null ? void 0 : _a.tableUuids) == null ? void 0 : _b.indexOf(props.configure.uuid);
+          if (uuidIndex != void 0 && uuidIndex > -1) {
+            (_d = (_c = props.pageDesign) == null ? void 0 : _c.tableUuids) == null ? void 0 : _d.shift(uuidIndex, 1);
+          }
+        });
+      }
+    }
+    if (props.configure.events && props.pageDesign) {
+      vue.watch(
+        props.configure.events,
+        (newVal) => {
+          pagePermissionUtil.batchUpdatePermissions(props.configure, props.pageDesign);
+        },
+        { immediate: true }
+      );
+      vue.onUnmounted(() => {
+        pagePermissionUtil.batchRemovePermissions(props.pageDesign, props.configure.uuid);
+      });
+    }
+    props.configure.componentIndex = props.indexObj.index;
+    let thisComponentIndex = props.indexObj.index;
+    const $emits = __emit;
+    const dynamicComponent = vue.ref({});
+    dynamicComponent.value = assemblysConfig.getDesignComponentByName(props.configure.name);
+    const showCopy = vue.ref(true);
+    if (dynamicComponent.value == null) {
+      dynamicComponent.value = errorDesign_vue_vue_type_script_setup_true_lang;
+      showCopy.value = false;
+    }
+    vue.watch(
+      () => props.configure.name,
+      (newVal) => {
+        dynamicComponent.value = assemblysConfig.getDesignComponentByName(newVal);
+        $emits("onSelectWidget", thisComponentIndex, props.configure);
+      }
+    );
+    if (props.configure.props && props.configure.props.verification) {
+      vue.watch(
+        () => props.configure.props.verification.required,
+        (newValue, oldValue) => {
+          formDesignUtil.watchRequiredValidate(props.pageDesign, props.configure, newValue, fieldInfo);
+        }
+      );
+      vue.watch(
+        () => props.configure.props.verification.type,
+        (newValue, oldValue) => {
+          let ruleType;
+          if (newValue) {
+            ruleType = newValue.join(",");
+          }
+          formDesignUtil.watchValidateType(props.pageDesign, props.configure, ruleType, fieldInfo);
+        }
+      );
+      vue.watch(
+        () => props.configure.props.verification.verifyRegex,
+        (newValue, oldValue) => {
+          formDesignUtil.watchPatternValidate(props.pageDesign, props.configure, newValue, fieldInfo);
+        }
+      );
+      vue.watch(
+        () => props.configure.props.verification.regex,
+        (newValue, oldValue) => {
+          formDesignUtil.watchPatternValidate(props.pageDesign, props.configure, newValue, fieldInfo);
+        }
+      );
+      vue.watch(
+        () => props.configure.props.verification.verifyMaxLength,
+        (newValue, oldValue) => {
+          formDesignUtil.watchMaxOrMinValidate(
+            props.pageDesign,
+            props.configure,
+            "max",
+            newValue,
+            props.configure.props.verification.maxLength,
+            fieldInfo
+          );
+        }
+      );
+      vue.watch(
+        () => props.configure.props.verification.maxLength,
+        (newValue, oldValue) => {
+          formDesignUtil.watchMaxOrMinValidate(
+            props.pageDesign,
+            props.configure,
+            "max",
+            props.configure.props.verification.verifyMaxLength,
+            newValue,
+            fieldInfo
+          );
+        }
+      );
+      vue.watch(
+        () => props.configure.props.verification.verifyMinLength,
+        (newValue, oldValue) => {
+          formDesignUtil.watchMaxOrMinValidate(
+            props.pageDesign,
+            props.configure,
+            "min",
+            newValue,
+            props.configure.props.verification.minLength,
+            fieldInfo
+          );
+        }
+      );
+      vue.watch(
+        () => props.configure.props.verification.minLength,
+        (newValue, oldValue) => {
+          formDesignUtil.watchMaxOrMinValidate(
+            props.pageDesign,
+            props.configure,
+            "min",
+            props.configure.props.verification.verifyMinLength,
+            newValue,
+            fieldInfo
+          );
+        }
+      );
+    }
+    const thisRef = vue.ref(null);
+    const designStyle = vue.ref({});
+    const designClass = vue.ref("");
+    function caculateNewStyle() {
+      containerDesignUtil.caculateCommonStyle(props.configure, designStyle, designClass);
+      if (!props.configure.runtime) {
+        props.configure.runtime = {};
+      }
+      if (!props.configure.runtime.common) {
+        props.configure.runtime.common = {};
+      }
+      props.configure.runtime.common.class = designClass.value;
+      props.configure.runtime.common.style = designStyle.value;
+    }
+    if (props.configure.props && props.configure.props) {
+      vue.watch(
+        props.configure.props,
+        () => {
+          caculateNewStyle();
+        },
+        { immediate: true }
+      );
+    }
+    if (props.configure.style && props.configure.style) {
+      vue.watch(props.configure.style, () => {
+        caculateNewStyle();
+      });
+    }
+    if (props.configure.props) {
+      if (!props.configure.props.size) {
+        props.configure.props.size = {};
+      }
+      const sizeConf = props.configure.props.size;
+      let pcConf = sizeConf[pageDesignTypes.PageDimensions.PC];
+      if (!pcConf) {
+        pcConf = {};
+        sizeConf[pageDesignTypes.PageDimensions.PC] = pcConf;
+      }
+      if (Object.keys(pcConf).length == 0) {
+        pcConf.widthType = sizeConf.widthType;
+        pcConf.flexSpan = sizeConf.flexSpan;
+        pcConf.fixWidth = sizeConf.fixWidth;
+        pcConf.fixHeight = sizeConf.fixHeight;
+        delete sizeConf.widthType;
+        delete sizeConf.flexSpan;
+        delete sizeConf.fixWidth;
+        delete sizeConf.fixHeight;
+      }
+    }
+    const outerStyle = vue.computed(() => {
+      const tempStyle = designStyle.value;
+      if (!tempStyle || !props.pageDesign) {
+        return {};
+      }
+      const style = {};
+      if (props.configure.design && props.configure.design.style) {
+        Object.assign(style, props.configure.design.style);
+      }
+      const dimentions = props.pageDesign.dimensions ? props.pageDesign.dimensions : "pc";
+      const styleConf = tempStyle[dimentions + "_style"];
+      if (styleConf) {
+        style["width"] = styleConf.width;
+        style["height"] = styleConf.height;
+      }
+      designClass.value = tempStyle[dimentions + "_class"];
+      console.log("outerStyle1", styleConf, tempStyle);
+      return style;
+    });
+    vue.watch(props.selectWidget, (newValue) => {
+      console.log("watch----props.selectWidget==", props.selectWidget);
+      if (newValue && newValue.value == thisComponentIndex) {
+        selectedClass.value = "amb-design-item-selected";
+      } else {
+        selectedClass.value = "";
+      }
+    });
+    const selectedClass = vue.ref("");
+    vue.onMounted(() => {
+      if (props.configure.props && props.configure.props.isInit) {
+        delete props.configure.props.isInit;
+        $emits("onSelectWidget", thisComponentIndex, props.configure);
+      }
+    });
+    function handleSelectWidget(evt) {
+      if (evt) {
+        evt.preventDefault();
+      }
+      $emits("onSelectWidget", thisComponentIndex, props.configure);
+    }
+    function onSelectWidget(selIndex, objConfigure) {
+      $emits("onSelectWidget", selIndex, objConfigure);
+    }
+    function onCustomAttrWidget(itemConfigure, itemAttrComponent) {
+      $emits("onCustomAttrWidget", itemConfigure, itemAttrComponent);
+    }
+    function copyObj(evt) {
+      evt.preventDefault();
+      $emits("onCopy", props.configure);
+    }
+    function deleteObj(evt) {
+      evt.preventDefault();
+      formDesignUtil.deleteRule(props.pageDesign, props.configure);
+      $emits("onDelete", props.configure);
+    }
+    return (_ctx, _cache) => {
+      const _component_el_icon = vue.resolveComponent("el-icon");
+      return vue.openBlock(), vue.createElementBlock("div", {
+        style: vue.normalizeStyle([{ "position": "relative" }, outerStyle.value]),
+        class: vue.normalizeClass(designClass.value),
+        ref_key: "thisRef",
+        ref: thisRef
+      }, [
+        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(dynamicComponent.value), {
+          style: vue.normalizeStyle([designStyle.value, { "height": "100%" }]),
+          configure: _ctx.configure,
+          pageDesign: _ctx.pageDesign,
+          indexObj: _ctx.indexObj,
+          errorBlank: _ctx.errorBlank,
+          selectWidget: _ctx.selectWidget,
+          onClick: vue.withModifiers(handleSelectWidget, ["stop"]),
+          onHandleSelect: handleSelectWidget,
+          class: vue.normalizeClass([[selectedClass.value], "amb-design-item"]),
+          onOnSelectWidget: onSelectWidget,
+          onOnCustomAttrWidget: onCustomAttrWidget
+        }, null, 40, ["style", "configure", "pageDesign", "indexObj", "errorBlank", "selectWidget", "class"])),
+        vue.withDirectives(vue.createElementVNode("span", _hoisted_1, [
+          vue.withDirectives(vue.createVNode(_component_el_icon, {
+            onClick: vue.withModifiers(copyObj, ["stop"]),
+            style: { "margin-left": "6px" }
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(Icons.CopyDocument))
+            ]),
+            _: 1
+          }, 512), [
+            [vue.vShow, showCopy.value]
+          ]),
+          vue.createVNode(_component_el_icon, {
+            onClick: vue.withModifiers(deleteObj, ["stop"]),
+            style: { "margin-left": "6px" }
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(Icons.Delete))
+            ]),
+            _: 1
+          })
+        ], 512), [
+          [vue.vShow, selectedClass.value && _ctx.showSelectedClass]
+        ])
+      ], 6);
+    };
+  }
+});
+module.exports = _sfc_main;

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

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

package/dist/lib/components/design/views/assemblys/page/component/setting-form-rule-base-input.vue.d.ts

@@ -0,0 +1,33 @@
+declare const _default: import('vue').DefineComponent<{
+    code: {
+        type: StringConstructor;
+        default: any;
+    };
+    rowId: {
+        type: NumberConstructor;
+        default: any;
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+    open: (...args: any[]) => void;
+    opend: (...args: any[]) => void;
+    closed: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    code: {
+        type: StringConstructor;
+        default: any;
+    };
+    rowId: {
+        type: NumberConstructor;
+        default: any;
+    };
+}>> & {
+    onClose?: (...args: any[]) => any;
+    onOpen?: (...args: any[]) => any;
+    onOpend?: (...args: any[]) => any;
+    onClosed?: (...args: any[]) => any;
+}, {
+    code: string;
+    rowId: number;
+}, {}>;
+export default _default;