@tmagic/editor 1.0.0-beta.9 → 1.0.0-rc.3

package/src/layouts/sidebar/LayerMenu.vue

@@ -1,115 +1,110 @@
 <template>
-  <div v-if="node" class="magic-editor-content-menu">
-    <div
-      v-if="node.items"
-      class="magic-editor-content-menu-item"
-      @mouseenter="setSubVisiable(true)"
-      @mouseleave="setSubVisiable(false)"
-    >
-      新增
-    </div>
-    <div v-if="node.type !== 'app'" class="magic-editor-content-menu-item" @click="() => copy(node)">复制</div>
-    <div
-      v-if="node.type !== 'app' && node.type !== 'page'"
-      class="magic-editor-content-menu-item"
-      @click="() => remove()"
-    >
-      删除
-    </div>
-    <div class="subMenu" v-show="subVisible" @mouseenter="setSubVisiable(true)" @mouseleave="setSubVisiable(false)">
-      <el-scrollbar>
-        <template v-if="node.type === 'tabs'">
-          <div
-            class="magic-editor-content-menu-item"
-            @click="
-              () =>
-                append({
-                  type: 'tab-pane',
-                })
-            "
-          >
-            标签
-          </div>
-        </template>
-
-        <template v-else-if="node.type === 'app'">
-          <div
-            class="magic-editor-content-menu-item"
-            v-for="item in menu.app"
-            :key="item.type"
-            @click="() => append(item)"
-          >
-            {{ item.text }}
-          </div>
-        </template>
-
-        <template v-else-if="node.items">
-          <div v-for="list in menu.component" :key="list.title">
-            <template v-for="item in list.items">
-              <div class="magic-editor-content-menu-item" v-if="item" :key="item.type" @click="() => append(item)">
-                {{ item.text }}
-              </div>
-            </template>
-            <div class="separation"></div>
-          </div>
-        </template>
-      </el-scrollbar>
-    </div>
-  </div>
+  <content-menu :menu-data="menuData" ref="menu" style="overflow: initial"></content-menu>
 </template>
 
 <script lang="ts">
-import { computed, defineComponent, inject, PropType, ref } from 'vue';
+import { computed, defineComponent, inject, markRaw, ref } from 'vue';
+import { Delete, DocumentCopy, Files, Plus } from '@element-plus/icons';
 
-import type { ComponentGroup, Services } from '@editor/type';
+import { NodeType } from '@tmagic/schema';
 
-export default defineComponent({
-  name: 'magic-editor-content-menu',
+import ContentMenu from '@editor/components/ContentMenu.vue';
+import type { ComponentGroup, MenuButton, MenuItem, Services } from '@editor/type';
 
-  props: {
-    componentGroupList: {
-      type: Array as PropType<ComponentGroup[]>,
-      default: () => [],
-    },
-  },
+export default defineComponent({
+  components: { ContentMenu },
 
-  setup(props) {
+  setup() {
     const services = inject<Services>('services');
-    const subVisible = ref(false);
+    const menu = ref<InstanceType<typeof ContentMenu>>();
     const node = computed(() => services?.editorService.get('node'));
+    const isRoot = computed(() => node.value?.type === NodeType.ROOT);
+    const isPage = computed(() => node.value?.type === NodeType.PAGE);
+    const componentList = computed(() => services?.componentListService.getList() || []);
 
-    return {
-      subVisible,
-
-      node,
+    const createMenuItems = (group: ComponentGroup): MenuButton[] =>
+      group.items.map((component) => ({
+        text: component.text,
+        type: 'button',
+        icon: component.icon,
+        handler: () => {
+          services?.editorService.add({
+            name: component.text,
+            type: component.type,
+            ...(component.data || {}),
+          });
+        },
+      }));
 
-      menu: computed(() => ({
-        app: [
+    const getSubMenuData = computed<MenuButton[]>(() => {
+      if (node.value?.type === 'tabs') {
+        return [
           {
-            type: 'page',
-            text: '页面',
+            text: '标签页',
+            type: 'button',
+            icon: Files,
+            handler: () => {
+              services?.editorService.add({
+                type: 'tab-pane',
+              });
+            },
           },
-        ],
-        component: props.componentGroupList,
-      })),
+        ];
+      }
+      if (node.value?.items) {
+        return (
+          componentList.value.reduce(
+            (subMenuData: MenuButton[], group: ComponentGroup, index) =>
+              subMenuData.concat(
+                createMenuItems(group),
+                index < componentList.value.length - 1
+                  ? [
+                      {
+                        type: 'divider',
+                        direction: 'horizontal',
+                      },
+                    ]
+                  : [],
+              ),
+            [],
+          ) || []
+        );
+      }
+      return [];
+    });
 
-      append(config: any) {
-        services?.editorService.add({
-          name: config.text,
-          type: config.type,
-        });
-      },
-
-      remove() {
-        node.value && services?.editorService.remove(node.value);
-      },
-
-      copy(node: any) {
-        services?.editorService.copy(node);
-      },
+    return {
+      menu,
+      menuData: computed<MenuItem[]>(() => [
+        {
+          type: 'button',
+          text: '新增',
+          icon: markRaw(Plus),
+          display: () => node.value?.items,
+          items: getSubMenuData.value,
+        },
+        {
+          type: 'button',
+          text: '复制',
+          icon: markRaw(DocumentCopy),
+          display: () => !isRoot.value,
+          handler: () => {
+            node.value && services?.editorService.copy(node.value);
+          },
+        },
+        {
+          type: 'button',
+          text: '删除',
+          icon: markRaw(Delete),
+          display: () => !isRoot.value && !isPage.value,
+          handler: () => {
+            node.value && services?.editorService.remove(node.value);
+          },
+        },
+      ]),
 
-      setSubVisiable(v: any) {
-        subVisible.value = v;
+      show(e: MouseEvent) {
+        menu.value?.show(e);
       },
     };
   },

package/src/layouts/sidebar/LayerPanel.vue

@@ -14,6 +14,7 @@
       ref="tree"
       node-key="id"
       draggable
+      :default-expanded-keys="expandedKeys"
       :load="loadItems"
       :data="values"
       :expand-on-click-node="false"
@@ -32,8 +33,8 @@
         <div
           :id="data.id"
           class="cus-tree-node"
-          @mousedown="toogleClickFlag"
-          @mouseup="toogleClickFlag"
+          @mousedown="toggleClickFlag"
+          @mouseup="toggleClickFlag"
           @mouseenter="highlightHandler(data)"
           :class="{ 'cus-tree-node-hover': canHighlight && data.id === highlightNode?.id }"
         >
@@ -47,18 +48,19 @@
     </el-tree>
 
     <teleport to="body">
-      <layer-menu :style="menuStyle"></layer-menu>
+      <layer-menu ref="menu"></layer-menu>
     </teleport>
   </el-scrollbar>
 </template>
 
 <script lang="ts">
-import { computed, defineComponent, inject, onMounted, Ref, ref, watchEffect } from 'vue';
+import { computed, defineComponent, inject, Ref, ref, watchEffect } from 'vue';
 import type { ElTree } from 'element-plus';
 import { throttle } from 'lodash-es';
 
 import type { MNode, MPage } from '@tmagic/schema';
 import { NodeType } from '@tmagic/schema';
+import StageCore from '@tmagic/stage';
 
 import type { EditorService } from '@editor/services/editor';
 import type { Services } from '@editor/type';
@@ -67,12 +69,13 @@ import LayerMenu from './LayerMenu.vue';
 
 const throttleTime = 150;
 
-const select = (data: MNode, editorService?: EditorService) => {
+const select = async (data: MNode, editorService?: EditorService) => {
   if (!data.id) {
     throw new Error('没有id');
   }
 
-  editorService?.select(data);
+  await editorService?.select(data);
+  editorService?.get<StageCore>('stage')?.select(data.id);
 };
 
 const highlight = (data: MNode, editorService?: EditorService) => {
@@ -80,6 +83,7 @@ const highlight = (data: MNode, editorService?: EditorService) => {
     throw new Error('没有id');
   }
   editorService?.highlight(data);
+  editorService?.get<StageCore>('stage')?.highlight(data.id);
 };
 
 const useDrop = (tree: Ref<InstanceType<typeof ElTree> | undefined>, editorService?: EditorService) => ({
@@ -140,6 +144,7 @@ const useStatus = (tree: Ref<InstanceType<typeof ElTree> | undefined>, editorSer
 
     highlightNode,
     clickNode: node,
+    expandedKeys: computed(() => (node.value ? [node.value.id] : [])),
   };
 };
 
@@ -153,12 +158,10 @@ const useFilter = (tree: Ref<InstanceType<typeof ElTree> | undefined>) => ({
     let name = '';
     if (data.name) {
       name = data.name;
-    } else if (data.type) {
-      name = data.type;
     } else if (data.items) {
       name = 'container';
     }
-    return name.indexOf(value) !== -1;
+    return `${data.id}${name}${data.type}`.indexOf(value) !== -1;
   },
 
   filterTextChangeHandler(val: string) {
@@ -166,46 +169,6 @@ const useFilter = (tree: Ref<InstanceType<typeof ElTree> | undefined>) => ({
   },
 });
 
-const useContentMenu = (editorService?: EditorService) => {
-  const menuStyle = ref({
-    position: 'absolute',
-    left: '0',
-    top: '0',
-    display: 'none',
-  });
-
-  onMounted(() => {
-    document.addEventListener(
-      'click',
-      () => {
-        menuStyle.value.display = 'none';
-      },
-      true,
-    );
-  });
-
-  return {
-    menuStyle,
-
-    contextmenu(event: MouseEvent, data: MNode) {
-      const bodyHeight = globalThis.document.body.clientHeight;
-
-      const left = `${event.clientX + 20}px`;
-      let top = `${event.clientY - 10}px`;
-
-      if (event.clientY + 300 > bodyHeight) {
-        top = `${bodyHeight - 300}px`;
-      }
-
-      menuStyle.value.left = left;
-      menuStyle.value.top = top;
-      menuStyle.value.display = '';
-
-      select(data, editorService);
-    },
-  };
-};
-
 export default defineComponent({
   name: 'magic-editor-layer-panel',
 
@@ -214,13 +177,14 @@ export default defineComponent({
   setup() {
     const services = inject<Services>('services');
     const tree = ref<InstanceType<typeof ElTree>>();
+    const menu = ref<InstanceType<typeof LayerMenu>>();
     const clicked = ref(false);
     const editorService = services?.editorService;
     const highlightHandler = throttle((data: MNode) => {
       highlight(data, editorService);
     }, throttleTime);
 
-    const toogleClickFlag = () => {
+    const toggleClickFlag = () => {
       clicked.value = !clicked.value;
     };
 
@@ -229,12 +193,22 @@ export default defineComponent({
       () => statusData.highlightNode.value?.id !== statusData.clickNode.value?.id && !clicked.value,
     );
 
+    editorService?.on('remove', () => {
+      setTimeout(() => {
+        tree.value?.getNode(editorService.get('node').id)?.updateChildren();
+      }, 0);
+    });
+
     return {
       tree,
+      menu,
       ...statusData,
       ...useDrop(tree, editorService),
       ...useFilter(tree),
-      ...useContentMenu(editorService),
+
+      highlightHandler,
+      toggleClickFlag,
+      canHighlight,
 
       clickHandler(data: MNode): void {
         if (services?.uiService.get<boolean>('uiSelectMode')) {
@@ -244,9 +218,12 @@ export default defineComponent({
         tree.value?.setCurrentKey(data.id);
         select(data, editorService);
       },
-      highlightHandler,
-      toogleClickFlag,
-      canHighlight,
+
+      async contextmenu(event: MouseEvent, data: MNode) {
+        event.preventDefault();
+        await select(data, editorService);
+        menu.value?.show(event);
+      },
     };
   },
 });

package/src/layouts/sidebar/Sidebar.vue

@@ -1,36 +1,26 @@
 <template>
-  <el-tabs v-if="data.type === 'tabs'" class="m-editor-sidebar" v-model="activeTabName" type="card" tab-position="left">
-    <el-tab-pane v-for="item in items" :key="item.text" :name="item.text">
-      <template #label>
-        <span>
-          <m-icon v-if="item.icon" :icon="item.icon"></m-icon>
-          <div v-if="item.text" class="magic-editor-tab-panel-title">{{ item.text }}</div>
-        </span>
-      </template>
-
-      <component :is="item.component" v-bind="item.props || {}" v-on="item.listeners || {}">
-        <template #layer-node-content="{ data, node }" v-if="item.slots?.layerNodeContent">
-          <component :is="item.slots.layerNodeContent" :data="data" :node="node" />
-        </template>
-      </component>
-    </el-tab-pane>
+  <el-tabs
+    v-if="data.type === 'tabs' && data.items.length"
+    class="m-editor-sidebar"
+    v-model="activeTabName"
+    type="card"
+    tab-position="left"
+  >
+    <tab-pane v-for="(item, index) in data.items" :key="index" :data="item"></tab-pane>
   </el-tabs>
 </template>
 
 <script lang="ts">
-import { computed, defineComponent, PropType, ref, watch } from 'vue';
-import { Coin, Files } from '@element-plus/icons';
+import { defineComponent, PropType, ref, watch } from 'vue';
 
-import MIcon from '@editor/components/Icon.vue';
-import { SideBarData, SideComponent } from '@editor/type';
+import { SideBarData } from '@editor/type';
 
-import ComponentListPanel from './ComponentListPanel.vue';
-import LayerPanel from './LayerPanel.vue';
+import TabPane from './TabPane.vue';
 
 export default defineComponent({
-  name: 'm-sidebar',
+  components: { TabPane },
 
-  components: { MIcon },
+  name: 'm-sidebar',
 
   props: {
     data: {
@@ -51,35 +41,6 @@ export default defineComponent({
 
     return {
       activeTabName,
-
-      items: computed<SideComponent[] | Record<string, any>[]>(() =>
-        props.data?.items.map((item) => {
-          if (typeof item !== 'string') {
-            return item;
-          }
-
-          switch (item) {
-            case 'component-list':
-              return {
-                type: 'component',
-                icon: Coin,
-                text: '组件',
-                component: ComponentListPanel,
-                slots: {},
-              };
-            case 'layer':
-              return {
-                type: 'component',
-                icon: Files,
-                text: '已选组件',
-                component: LayerPanel,
-                slots: {},
-              };
-            default:
-              return {};
-          }
-        }),
-      ),
     };
   },
 });

package/src/layouts/sidebar/TabPane.vue

@@ -0,0 +1,68 @@
+<template>
+  <el-tab-pane v-if="config" :name="config.text">
+    <template #label>
+      <div :key="config.text">
+        <m-icon v-if="config.icon" :icon="config.icon"></m-icon>
+        <div v-if="config.text" class="magic-editor-tab-panel-title">{{ config.text }}</div>
+      </div>
+    </template>
+
+    <component :is="config.component" v-bind="config.props || {}" v-on="config?.listeners || {}">
+      <template #layer-node-content="{ data, node }" v-if="config.slots?.layerNodeContent">
+        <component :is="config.slots?.layerNodeContent" :data="data" :node="node" />
+      </template>
+    </component>
+  </el-tab-pane>
+</template>
+
+<script lang="ts">
+import { computed, defineComponent, PropType } from 'vue';
+import { Coin, Files } from '@element-plus/icons';
+
+import MIcon from '@editor/components/Icon.vue';
+import { SideComponent, SideItem } from '@editor/type';
+
+import ComponentListPanel from './ComponentListPanel.vue';
+import LayerPanel from './LayerPanel.vue';
+
+export default defineComponent({
+  components: { MIcon },
+
+  props: {
+    data: {
+      type: Object as PropType<SideItem>,
+    },
+  },
+
+  setup(props) {
+    return {
+      config: computed<SideComponent | undefined>(() => {
+        if (typeof props.data !== 'string') {
+          return props.data;
+        }
+
+        switch (props.data) {
+          case 'component-list':
+            return {
+              type: 'component',
+              icon: Coin,
+              text: '组件',
+              component: ComponentListPanel,
+              slots: {},
+            };
+          case 'layer':
+            return {
+              type: 'component',
+              icon: Files,
+              text: '已选组件',
+              component: LayerPanel,
+              slots: {},
+            };
+          default:
+            return undefined;
+        }
+      }),
+    };
+  },
+});
+</script>