super-page-designer 0.0.1-tmp1

package/dist/lib/components/design/views/design/page-event/page-event-container.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const pageEventContainer_vue_vue_type_script_setup_true_lang = require("./page-event-container.vue.js");
+module.exports = pageEventContainer_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/design/views/design/page-event/page-event-content.css

@@ -0,0 +1,4 @@
+
+.amb-design-event-content[data-v-5221912e] {
+  padding: 10px;
+}

package/dist/lib/components/design/views/design/page-event/page-event-content.vue.d.ts

@@ -0,0 +1,32 @@
+declare function initJsConfig(): void;
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    eventForm: Object;
+    configure: PageDesign;
+    customEvent: Object;
+    handleType: String;
+}>, {
+    initJsConfig: typeof initJsConfig;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    changeSelectEvent: (...args: any[]) => void;
+    changeSelectStandardEvent: (...args: any[]) => void;
+    addEvent: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    eventForm: Object;
+    configure: PageDesign;
+    customEvent: Object;
+    handleType: String;
+}>>> & {
+    onAddEvent?: (...args: any[]) => any;
+    onChangeSelectEvent?: (...args: any[]) => any;
+    onChangeSelectStandardEvent?: (...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/design/views/design/page-event/page-event-content.vue.js

@@ -0,0 +1,6 @@
+"use strict";
+const pageEventContent_vue_vue_type_script_setup_true_lang = require("./page-event-content.vue2.js");
+;/* empty css                         */
+const _pluginVue_exportHelper = require("../../../../../_virtual/_plugin-vue_export-helper.js");
+const pageEventContent = /* @__PURE__ */ _pluginVue_exportHelper(pageEventContent_vue_vue_type_script_setup_true_lang, [["__scopeId", "data-v-5221912e"]]);
+module.exports = pageEventContent;

package/dist/lib/components/design/views/design/page-event/page-event-content.vue2.js

@@ -0,0 +1,441 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const config = require("./config.vue.js");
+const assemblysConfig = require("../../../utils/assemblys-config.js");
+const eventBus = require("../../../utils/eventBus.js");
+const _hoisted_1 = { style: { "margin": "10px" } };
+const _hoisted_2 = { style: { "padding-right": "10px" } };
+const _hoisted_3 = { key: 1 };
+const _hoisted_4 = {
+  class: "codemirror",
+  style: { "margin-left": "20px" }
+};
+const _hoisted_5 = { key: 2 };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "page-event-content",
+  props: {
+    eventForm: {},
+    configure: {},
+    customEvent: {},
+    handleType: {}
+  },
+  emits: ["changeSelectEvent", "addEvent", "changeSelectStandardEvent"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const configure = props.configure;
+    const winHeight = vue.ref();
+    let containerHeightStyle = vue.ref();
+    const inputEventType = vue.ref();
+    const eventOptions = vue.ref([]);
+    const currentEvent = vue.ref();
+    const currentStandardEvent = vue.ref();
+    const isChangeEvent = vue.ref(true);
+    const standardEventOptions = assemblysConfig.standardButtonOperations;
+    let myCustomEvent = props.customEvent;
+    vue.onMounted(() => {
+      initEventOptions();
+      initInputEventType();
+      winHeight.value = window.innerHeight;
+      containerHeightStyle.value = {
+        overflow: "auto",
+        height: winHeight.value + "px"
+      };
+    });
+    function initInputEventType() {
+      if (props.eventForm.componentName === "button-detail" && props.eventForm.name === "click" && props.eventForm.isStandard) {
+        inputEventType.value = "standard";
+        currentStandardEvent.value = props.eventForm.eventName;
+      } else if (props.eventForm.componentName === "button-detail" && props.eventForm.name === "click" && props.eventForm.eventName) {
+        inputEventType.value = "event";
+        currentEvent.value = props.eventForm.eventName;
+      } else if (props.eventForm.componentName === "button-detail" && props.eventForm.name === "click" && !props.eventForm.eventName) {
+        inputEventType.value = "standard";
+        currentStandardEvent.value = null;
+      } else {
+        if (props.handleType) {
+          inputEventType.value = props.handleType;
+        } else {
+          inputEventType.value = "event";
+        }
+        currentEvent.value = props.eventForm.eventName;
+      }
+    }
+    function changeTitle() {
+      props.eventForm.title = myCustomEvent.title;
+      eventBus.$emit("changeEventInfo", { customEvent: myCustomEvent, type: "title" });
+    }
+    function changeFuncName() {
+      props.eventForm.eventName = myCustomEvent.eventName;
+      eventBus.$emit("changeEventInfo", { customEvent: myCustomEvent, type: "eventName" });
+    }
+    function changeFuncParam() {
+      props.eventForm.funcParam = myCustomEvent.funcParam;
+      eventBus.$emit("changeEventInfo", { customEvent: myCustomEvent, type: "funcParam" });
+    }
+    function initEventOptions() {
+      if (configure.customEvents) {
+        eventOptions.value = [];
+        const funcList = configure.customEvents.filter((func) => func.name === "customFunc");
+        eventOptions.value.push({
+          label: "自定义方法",
+          options: funcList
+        });
+        const eventList = configure.customEvents.filter((func) => func.name !== "customFunc");
+        eventOptions.value.push({
+          label: "自定义事件",
+          options: eventList
+        });
+      }
+    }
+    function validateFun() {
+      const funcName = props.eventForm.eventName;
+      if (configure.customEvents) {
+        const funcList = configure.customEvents.filter((func) => func.eventName === funcName);
+        if (funcList && funcList.length > 1) {
+          elementPlus.ElMessage({
+            type: "warning",
+            message: "该自定义方法名已存在，请修改方法名",
+            showClose: true
+          });
+          myCustomEvent.eventName = null;
+        }
+      }
+      props.eventForm.eventName = myCustomEvent.eventName;
+    }
+    const isInitJsConfig = vue.ref(true);
+    function initJsConfig() {
+      inputEventType.value = "handle";
+      initEventOptions();
+      isInitJsConfig.value = false;
+      setTimeout(() => {
+        isInitJsConfig.value = true;
+      }, 5);
+    }
+    function selectEvent(eventName) {
+      if (props.eventForm.label && props.eventForm.name && props.eventForm.componentUuid) {
+        if (configure.customEvents) {
+          const eventList = configure.customEvents.filter((func) => func.eventName === eventName);
+          if (eventList && eventList.length > 0) {
+            myCustomEvent = eventList[0];
+            emits("changeSelectEvent", myCustomEvent);
+            isChangeEvent.value = false;
+            setTimeout(() => {
+              isChangeEvent.value = true;
+            }, 5);
+          }
+        }
+      }
+    }
+    function selectStandardEvent(eventName) {
+      const eventLabel = assemblysConfig.getStandardOperationLabel(eventName);
+      emits("changeSelectStandardEvent", eventName, eventLabel);
+    }
+    function addEvent(value) {
+      if (value === "handle") {
+        emits("addEvent", props.eventForm);
+      }
+    }
+    __expose({ initJsConfig });
+    return (_ctx, _cache) => {
+      const _component_el_radio = vue.resolveComponent("el-radio");
+      const _component_el_option = vue.resolveComponent("el-option");
+      const _component_el_option_group = vue.resolveComponent("el-option-group");
+      const _component_el_select = vue.resolveComponent("el-select");
+      const _component_el_radio_group = vue.resolveComponent("el-radio-group");
+      const _component_el_form_item = vue.resolveComponent("el-form-item");
+      const _component_el_col = vue.resolveComponent("el-col");
+      const _component_el_row = vue.resolveComponent("el-row");
+      const _component_el_input = vue.resolveComponent("el-input");
+      const _component_el_form = vue.resolveComponent("el-form");
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+        vue.createVNode(_component_el_form, {
+          ref: "form",
+          model: vue.unref(myCustomEvent),
+          "inline-message": "",
+          "label-width": "80px"
+        }, {
+          default: vue.withCtx(() => [
+            !vue.unref(myCustomEvent) || _ctx.eventForm.name !== "customFunc" && _ctx.eventForm.name !== "customEvent" || vue.unref(myCustomEvent).name !== "customFunc" && !vue.unref(myCustomEvent).eventName ? (vue.openBlock(), vue.createBlock(_component_el_row, { key: 0 }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(_component_el_col, null, {
+                  default: vue.withCtx(() => [
+                    vue.createVNode(_component_el_form_item, { label: "脚本" }, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(_component_el_radio_group, {
+                          modelValue: inputEventType.value,
+                          "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => inputEventType.value = $event),
+                          onChange: addEvent
+                        }, {
+                          default: vue.withCtx(() => [
+                            _ctx.eventForm.componentName === "button-detail" && _ctx.eventForm.name === "click" ? (vue.openBlock(), vue.createBlock(_component_el_radio, {
+                              key: 0,
+                              value: "standard",
+                              size: "large"
+                            }, {
+                              default: vue.withCtx(() => [
+                                vue.createTextVNode("选择标准事件")
+                              ]),
+                              _: 1
+                            })) : vue.createCommentVNode("", true),
+                            vue.withDirectives(vue.createVNode(_component_el_select, {
+                              modelValue: currentStandardEvent.value,
+                              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => currentStandardEvent.value = $event),
+                              placeholder: "Select",
+                              style: { "width": "240px" },
+                              onChange: selectStandardEvent
+                            }, {
+                              default: vue.withCtx(() => [
+                                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(standardEventOptions), (group) => {
+                                  return vue.openBlock(), vue.createBlock(_component_el_option_group, {
+                                    key: group.label,
+                                    label: group.label
+                                  }, {
+                                    default: vue.withCtx(() => [
+                                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(group.options, (item) => {
+                                        return vue.openBlock(), vue.createBlock(_component_el_option, {
+                                          key: item.value,
+                                          label: item.label,
+                                          value: item.value
+                                        }, null, 8, ["label", "value"]);
+                                      }), 128))
+                                    ]),
+                                    _: 2
+                                  }, 1032, ["label"]);
+                                }), 128))
+                              ]),
+                              _: 1
+                            }, 8, ["modelValue"]), [
+                              [vue.vShow, inputEventType.value === "standard"]
+                            ]),
+                            vue.createVNode(_component_el_radio, {
+                              value: "event",
+                              size: "large"
+                            }, {
+                              default: vue.withCtx(() => [
+                                vue.createTextVNode("选择已有事件")
+                              ]),
+                              _: 1
+                            }),
+                            vue.createElementVNode("span", _hoisted_2, [
+                              vue.withDirectives(vue.createVNode(_component_el_select, {
+                                modelValue: currentEvent.value,
+                                "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => currentEvent.value = $event),
+                                placeholder: "Select",
+                                style: { "width": "240px" },
+                                onChange: selectEvent
+                              }, {
+                                default: vue.withCtx(() => [
+                                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(eventOptions.value, (group) => {
+                                    return vue.openBlock(), vue.createBlock(_component_el_option_group, {
+                                      key: group.label,
+                                      label: group.label
+                                    }, {
+                                      default: vue.withCtx(() => [
+                                        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(group.options, (item) => {
+                                          return vue.openBlock(), vue.createBlock(_component_el_option, {
+                                            key: item.eventName,
+                                            label: item.title,
+                                            value: item.eventName
+                                          }, null, 8, ["label", "value"]);
+                                        }), 128))
+                                      ]),
+                                      _: 2
+                                    }, 1032, ["label"]);
+                                  }), 128))
+                                ]),
+                                _: 1
+                              }, 8, ["modelValue"]), [
+                                [vue.vShow, inputEventType.value === "event"]
+                              ])
+                            ]),
+                            vue.createVNode(_component_el_radio, {
+                              value: "handle",
+                              size: "large"
+                            }, {
+                              default: vue.withCtx(() => [
+                                vue.createTextVNode("新增事件")
+                              ]),
+                              _: 1
+                            })
+                          ]),
+                          _: 1
+                        }, 8, ["modelValue"])
+                      ]),
+                      _: 1
+                    })
+                  ]),
+                  _: 1
+                })
+              ]),
+              _: 1
+            })) : vue.createCommentVNode("", true),
+            vue.unref(myCustomEvent) && isChangeEvent.value && (inputEventType.value === "handle" || vue.unref(myCustomEvent) && vue.unref(myCustomEvent).name === "customFunc" && !_ctx.eventForm.componentUuid || vue.unref(myCustomEvent) && vue.unref(myCustomEvent).name === "customEvent" && !_ctx.eventForm.componentUuid || currentEvent.value && _ctx.eventForm.componentUuid) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, [
+              vue.createVNode(_component_el_row, null, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_el_col, { span: 8 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_el_form_item, { label: "事件标题" }, {
+                        default: vue.withCtx(() => [
+                          vue.createVNode(_component_el_input, {
+                            modelValue: vue.unref(myCustomEvent).title,
+                            "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => vue.unref(myCustomEvent).title = $event),
+                            onInput: changeTitle
+                          }, null, 8, ["modelValue"])
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  }),
+                  vue.createVNode(_component_el_col, { span: 4 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_el_form_item, { label: "事件类型" }, {
+                        default: vue.withCtx(() => [
+                          vue.createTextVNode(vue.toDisplayString(_ctx.eventForm.label) + "(" + vue.toDisplayString(_ctx.eventForm.name) + ") ", 1)
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  }),
+                  vue.createVNode(_component_el_col, { span: 4 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_el_form_item, { label: "组件类型" }, {
+                        default: vue.withCtx(() => [
+                          vue.createTextVNode(vue.toDisplayString(_ctx.eventForm.componentName), 1)
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  }),
+                  vue.createVNode(_component_el_col, { span: 8 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_el_form_item, { label: "组件uuid" }, {
+                        default: vue.withCtx(() => [
+                          vue.createTextVNode(vue.toDisplayString(_ctx.eventForm.componentUuid), 1)
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              }),
+              vue.unref(myCustomEvent).name === "customFunc" ? (vue.openBlock(), vue.createBlock(_component_el_row, { key: 0 }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_el_col, { span: 12 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_el_form_item, {
+                        label: "方法名",
+                        rules: [
+                          {
+                            required: true,
+                            message: "必填",
+                            trigger: "blur"
+                          }
+                        ],
+                        prop: "eventName"
+                      }, {
+                        default: vue.withCtx(() => [
+                          vue.createVNode(_component_el_input, {
+                            modelValue: vue.unref(myCustomEvent).eventName,
+                            "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => vue.unref(myCustomEvent).eventName = $event),
+                            onChange: validateFun,
+                            onInput: changeFuncName
+                          }, null, 8, ["modelValue"])
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  }),
+                  vue.createVNode(_component_el_col, { span: 12 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_el_form_item, {
+                        label: "方法参数",
+                        prop: "funcParam"
+                      }, {
+                        default: vue.withCtx(() => [
+                          vue.createVNode(_component_el_input, {
+                            modelValue: vue.unref(myCustomEvent).funcParam,
+                            "onUpdate:modelValue": _cache[5] || (_cache[5] = ($event) => vue.unref(myCustomEvent).funcParam = $event),
+                            onInput: changeFuncParam
+                          }, null, 8, ["modelValue"])
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              })) : vue.createCommentVNode("", true),
+              vue.createVNode(_component_el_form_item, { label: "描述" }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_el_input, {
+                    modelValue: vue.unref(myCustomEvent).remark,
+                    "onUpdate:modelValue": _cache[6] || (_cache[6] = ($event) => vue.unref(myCustomEvent).remark = $event),
+                    autosize: { minRows: 2, maxRows: 4 },
+                    type: "textarea"
+                  }, null, 8, ["modelValue"])
+                ]),
+                _: 1
+              }),
+              vue.createElementVNode("div", _hoisted_4, [
+                isInitJsConfig.value ? (vue.openBlock(), vue.createBlock(config, {
+                  key: 0,
+                  eventForm: vue.unref(myCustomEvent)
+                }, null, 8, ["eventForm"])) : vue.createCommentVNode("", true)
+              ])
+            ])) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_5, [
+              vue.createVNode(_component_el_row, null, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_el_col, { span: 4 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_el_form_item, { label: "事件类型" }, {
+                        default: vue.withCtx(() => [
+                          vue.createTextVNode(vue.toDisplayString(_ctx.eventForm.label) + "(" + vue.toDisplayString(_ctx.eventForm.name) + ") ", 1)
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  }),
+                  vue.createVNode(_component_el_col, { span: 4 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_el_form_item, { label: "组件类型" }, {
+                        default: vue.withCtx(() => [
+                          vue.createTextVNode(vue.toDisplayString(_ctx.eventForm.componentName), 1)
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  }),
+                  vue.createVNode(_component_el_col, { span: 8 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_el_form_item, { label: "组件uuid" }, {
+                        default: vue.withCtx(() => [
+                          vue.createTextVNode(vue.toDisplayString(_ctx.eventForm.componentUuid), 1)
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              })
+            ]))
+          ]),
+          _: 1
+        }, 8, ["model"])
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/design/views/design/view/assemblys-container-explore.vue.d.ts

@@ -0,0 +1,33 @@
+declare const _default: import('vue').DefineComponent<{
+    designItems: ArrayConstructor;
+    selectWidget: ObjectConstructor;
+    headerSearchClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    treeMarginTop: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    onSelectWidget: (...args: any[]) => void;
+    selectComponent: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    designItems: ArrayConstructor;
+    selectWidget: ObjectConstructor;
+    headerSearchClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    treeMarginTop: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    onOnSelectWidget?: (...args: any[]) => any;
+    onSelectComponent?: (...args: any[]) => any;
+}, {
+    headerSearchClass: string;
+    treeMarginTop: string;
+}, {}>;
+export default _default;

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

@@ -0,0 +1,74 @@
+"use strict";
+const vue = require("vue");
+const Icons = require("@element-plus/icons");
+const pageExploreUtil = require("../../../utils/page-explore-util.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "assemblys-container-explore",
+  props: {
+    designItems: Array,
+    selectWidget: Object,
+    headerSearchClass: {
+      type: String,
+      default: "amb-assembly-header-search"
+    },
+    treeMarginTop: {
+      type: String,
+      default: "margin-top:40px;"
+    }
+  },
+  emits: ["onSelectWidget", "selectComponent"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const $emits = __emit;
+    const searchItemName = vue.ref("");
+    const defaultProps = {
+      children: "children",
+      label: "label"
+    };
+    const cachePageItemMap = vue.ref({});
+    const treeDatas = vue.computed(() => {
+      const treeDatas2 = pageExploreUtil.convertToExploreTreeDatas(props.designItems, searchItemName.value, cachePageItemMap);
+      return treeDatas2;
+    });
+    const handleNodeClick = (data) => {
+      let configureObj = null;
+      if (data.componentIndex != void 0) {
+        configureObj = cachePageItemMap.value[data.componentIndex];
+      }
+      if (configureObj) {
+        $emits("onSelectWidget", data.componentIndex, configureObj);
+      } else {
+        $emits("onSelectWidget", -1);
+      }
+      $emits("selectComponent", data.componentIndex, configureObj, data);
+    };
+    return (_ctx, _cache) => {
+      const _component_el_input = vue.resolveComponent("el-input");
+      const _component_el_tree = vue.resolveComponent("el-tree");
+      return vue.openBlock(), vue.createElementBlock("div", null, [
+        vue.createElementVNode("div", {
+          class: vue.normalizeClass(__props.headerSearchClass)
+        }, [
+          vue.createVNode(_component_el_input, {
+            modelValue: searchItemName.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => searchItemName.value = $event),
+            style: { "height": "36px" },
+            placeholder: "Search...",
+            clearable: "",
+            class: "input-with-select",
+            "suffix-icon": vue.unref(Icons.Search)
+          }, null, 8, ["modelValue", "suffix-icon"])
+        ], 2),
+        vue.createVNode(_component_el_tree, {
+          style: vue.normalizeStyle(__props.treeMarginTop),
+          data: treeDatas.value,
+          props: defaultProps,
+          "default-expand-all": "",
+          "expand-on-click-node": false,
+          onNodeClick: handleNodeClick
+        }, null, 8, ["style", "data"])
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

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

@@ -0,0 +1,3 @@
+"use strict";
+const assemblysContainerExplore_vue_vue_type_script_setup_true_lang = require("./assemblys-container-explore.vue.js");
+module.exports = assemblysContainerExplore_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/design/views/design/view/assemblys-container-list.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    handleMoveEnd: (...args: any[]) => void;
+    handleMoveStart: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>> & {
+    onHandleMoveEnd?: (...args: any[]) => any;
+    onHandleMoveStart?: (...args: any[]) => any;
+}, {}, {}>;
+export default _default;