@lvce-editor/main-area-worker 9.50.0 → 9.50.1

package/dist/mainAreaWorkerMain.js

@@ -4768,7 +4768,6 @@ const show2 = async (uid, menuId, x, y, args) => {
 };
 
 const NoGroupId = -1;
-const RendererWorkerForwardDelay$1 = 50;
 const handleContextMenu = async (state, rawGroupId, x, y) => {
   const {
     uid
@@ -4782,15 +4781,6 @@ const handleContextMenu = async (state, rawGroupId, x, y) => {
   if (Number.isNaN(groupId)) {
     return state;
   }
-  if (isConnected()) {
-    setTimeout(() => {
-      void show2(uid, Main$1, x, y, {
-        groupId,
-        menuId: Main$1
-      });
-    }, RendererWorkerForwardDelay$1);
-    return state;
-  }
   await show2(uid, Main$1, x, y, {
     groupId,
     menuId: Main$1
@@ -4832,6 +4822,60 @@ const handleDragLeave = state => {
   };
 };
 
+const getChildBounds = (bounds, direction, offset, size) => {
+  if (direction === Horizontal) {
+    return {
+      height: bounds.height,
+      width: bounds.width * size,
+      x: bounds.x + bounds.width * offset,
+      y: bounds.y
+    };
+  }
+  return {
+    height: bounds.height * size,
+    width: bounds.width,
+    x: bounds.x,
+    y: bounds.y + bounds.height * offset
+  };
+};
+const getEditorGroupBounds = (layout, width, height) => {
+  const {
+    direction,
+    groups
+  } = layout;
+  const segments = getGroupSegments(groups, direction);
+  const rootBounds = {
+    height,
+    width,
+    x: 0,
+    y: 0
+  };
+  const result = [];
+  let segmentOffset = 0;
+  for (const segment of segments) {
+    const segmentSize = getSegmentSize(segment);
+    const segmentBounds = getChildBounds(rootBounds, direction, segmentOffset / 100, segmentSize / 100);
+    segmentOffset += segmentSize;
+    if (segment.direction === undefined) {
+      result.push({
+        ...segmentBounds,
+        group: segment.groups[0]
+      });
+      continue;
+    }
+    let groupOffset = 0;
+    for (const group of segment.groups) {
+      const groupBounds = getChildBounds(segmentBounds, segment.direction, groupOffset / segmentSize, group.size / segmentSize);
+      groupOffset += group.size;
+      result.push({
+        ...groupBounds,
+        group
+      });
+    }
+  }
+  return result;
+};
+
 const None = 0;
 const Up = 1;
 const Down = 2;
@@ -4906,6 +4950,12 @@ const getSplitDirection = (x, y, width, height) => {
 const isNotEmpty = group => {
   return !group.isEmpty;
 };
+const getContentOffsetY = (targetIsEmpty, hasOpenEditor, tabHeight) => {
+  if (targetIsEmpty !== undefined) {
+    return targetIsEmpty ? 0 : tabHeight;
+  }
+  return hasOpenEditor ? tabHeight : 0;
+};
 const getDragOverlay = (state, eventX, eventY) => {
   const {
     height,
@@ -4918,17 +4968,33 @@ const getDragOverlay = (state, eventX, eventY) => {
   const {
     groups
   } = layout;
+  const relativeEventX = Math.min(Math.max(eventX - x, 0), width);
+  const relativeEventY = Math.min(Math.max(eventY - y, 0), height);
+  const groupBounds = getEditorGroupBounds(layout, width, height);
+  const target = groupBounds.find(bounds => {
+    return relativeEventX >= bounds.x && relativeEventX <= bounds.x + bounds.width && relativeEventY >= bounds.y && relativeEventY <= bounds.y + bounds.height;
+  });
   const hasOpenEditor = groups.some(isNotEmpty);
-  const contentY = hasOpenEditor ? tabHeight : 0;
-  const contentHeight = Math.max(0, height - contentY);
-  const relativeX = eventX - x;
-  const relativeY = eventY - y - contentY;
-  const splitDirection = getSplitDirection(relativeX, relativeY, width, contentHeight);
-  return getOverlay(0, contentY, width, contentHeight, splitDirection);
+  const targetX = target?.x ?? 0;
+  const targetY = target?.y ?? 0;
+  const targetWidth = target?.width ?? width;
+  const targetHeight = target?.height ?? height;
+  const contentOffsetY = getContentOffsetY(target?.group.isEmpty, hasOpenEditor, tabHeight);
+  const contentY = targetY + contentOffsetY;
+  const contentHeight = Math.max(0, targetHeight - contentOffsetY);
+  const relativeX = relativeEventX - targetX;
+  const relativeY = relativeEventY - contentY;
+  const splitDirection = getSplitDirection(relativeX, relativeY, targetWidth, contentHeight);
+  return {
+    ...getOverlay(targetX, contentY, targetWidth, contentHeight, splitDirection),
+    ...(target && {
+      targetGroupId: target.group.id
+    })
+  };
 };
 
 const isDragOverlayEqual = (oldOverlay, newOverlay) => {
-  return oldOverlay?.x === newOverlay?.x && oldOverlay?.y === newOverlay?.y && oldOverlay?.width === newOverlay?.width && oldOverlay?.height === newOverlay?.height && oldOverlay?.splitDirection === newOverlay?.splitDirection;
+  return oldOverlay?.x === newOverlay?.x && oldOverlay?.y === newOverlay?.y && oldOverlay?.width === newOverlay?.width && oldOverlay?.height === newOverlay?.height && oldOverlay?.splitDirection === newOverlay?.splitDirection && oldOverlay?.targetGroupId === newOverlay?.targetGroupId;
 };
 
 const handleDragOver = (state, eventX, eventY) => {
@@ -5105,27 +5171,29 @@ const splitUp$1 = (state, groupId) => {
   return splitEditorGroup$1(state, resolvedGroupId, 'up');
 };
 
-const splitForDrop = (state, splitDirection) => {
+const splitForDrop = (state, splitDirection, targetGroupId) => {
   switch (splitDirection) {
     case Down:
-      return splitDown$1(state);
+      return splitDown$1(state, targetGroupId);
     case Left:
-      return splitLeft$1(state);
+      return splitLeft$1(state, targetGroupId);
     case Right:
-      return splitRight$1(state);
+      return splitRight$1(state, targetGroupId);
     case Up:
-      return splitUp$1(state);
+      return splitUp$1(state, targetGroupId);
     default:
       return state;
   }
 };
 
-const applyDropAction = async (context, action, splitDirection) => {
+const applyDropAction = async (context, action, splitDirection, targetGroupId) => {
   switch (action.command) {
     case 'openFiles':
       {
         if (action.uris.length > 0 && splitDirection !== None) {
-          await context.updateState(state => splitForDrop(state, splitDirection));
+          await context.updateState(state => splitForDrop(state, splitDirection, targetGroupId));
+        } else if (action.uris.length > 0 && targetGroupId !== undefined) {
+          await context.updateState(state => focusEditorGroup(state, targetGroupId));
         }
         await openUrisWithContext(context, action.uris, splitDirection === None);
         break;
@@ -5164,7 +5232,10 @@ const getDropAction = async uris => {
 };
 
 const handleDrop = async (context, dropIdOrItemIds) => {
-  const splitDirection = context.getState().dragOverlay?.splitDirection ?? None;
+  const {
+    splitDirection = None,
+    targetGroupId
+  } = context.getState().dragOverlay ?? {};
   await context.updateState(handleDragLeave);
   const {
     platform
@@ -5180,7 +5251,7 @@ const handleDrop = async (context, dropIdOrItemIds) => {
     uris = droppedUris;
   }
   const actions = await getDropAction(uris);
-  await applyDropAction(context, actions, splitDirection);
+  await applyDropAction(context, actions, splitDirection, targetGroupId);
 };
 
 const EditorGroupHeader = 'EditorGroupHeader';
@@ -5402,8 +5473,6 @@ const handleIconThemeChange = async state => {
   };
 };
 
-const RendererWorkerCallbackDelay = 50;
-const commandsWithDeferredRender = new Set(['handleContextMenu', 'handleTabContextMenu']);
 const handleMessagePort = async (port, viewletCommandMap, setAsRendererProcessFallback = true) => {
   const executeViewletCommand = async (uid, command, ...args) => {
     const fn = viewletCommandMap[`MainArea.${command}`];
@@ -5411,12 +5480,6 @@ const handleMessagePort = async (port, viewletCommandMap, setAsRendererProcessFa
       throw new TypeError(`Viewlet command not found: ${command}`);
     }
     await fn(uid, ...args);
-    if (commandsWithDeferredRender.has(command)) {
-      setTimeout(() => {
-        void invoke$1('Viewlet.requestRender', uid);
-      }, RendererWorkerCallbackDelay);
-      return;
-    }
     await invoke$1('Viewlet.requestRender', uid);
   };
   const rpc = await create$8({
@@ -5801,7 +5864,6 @@ const handleSashPointerUp = async state => {
   };
 };
 
-const RendererWorkerForwardDelay = 50;
 const handleTabContextMenu = async (state, button, x, y, groupIndexRaw = '', tabIndexRaw = '') => {
   number(x);
   number(y);
@@ -5816,15 +5878,6 @@ const handleTabContextMenu = async (state, button, x, y, groupIndexRaw = '', tab
     groupId: group.id,
     tabId: tab.id
   } : {};
-  if (isConnected()) {
-    setTimeout(() => {
-      void show2(uid, Tab, x, y, {
-        menuId: Tab,
-        ...target
-      });
-    }, RendererWorkerForwardDelay);
-    return state;
-  }
   await show2(uid, Tab, x, y, {
     menuId: Tab,
     ...target

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-area-worker",
-  "version": "9.50.0",
+  "version": "9.50.1",
   "description": "Main Area Worker",
   "repository": {
     "type": "git",