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

package/dist/mainAreaWorkerMain.js

@@ -1680,8 +1680,11 @@ const VirtualDomElements = {
 const Button$1 = 'event.button';
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
+const DeltaMode = 'event.deltaMode';
+const DeltaY = 'event.deltaY';
 const DropId = 'event.dropId';
 const EventTargetClassName = 'event.target.className';
+const Key = 'event.key';
 const TargetName = 'event.target.name';
 
 const Tab = 13;
@@ -2401,27 +2404,32 @@ const promptSave = async title => {
   });
   return shouldDiscard ? 'discard' : 'cancel';
 };
+const canCloseTab = async tab => {
+  if (tab.editorUid === -1 || !tab.isDirty) {
+    return true;
+  }
+  const savePromptResult = await promptSave(tab.title);
+  if (savePromptResult === 'cancel') {
+    return false;
+  }
+  if (savePromptResult === 'save') {
+    const editorState = await saveEditor(tab.editorUid);
+    if (editorState?.modified !== false) {
+      return false;
+    }
+    if (tab.uri) {
+      await handleModifiedStatusChange$1(tab.uri, false);
+    }
+  }
+  return savePromptResult === 'save' || savePromptResult === 'discard';
+};
 const closeTabAndSave = async (state, groupId, tabId) => {
   const tab = findTabInState(state, groupId, tabId);
   if (!tab) {
     return state;
   }
-  if (tab.editorUid !== -1 && tab.isDirty) {
-    const savePromptResult = await promptSave(tab.title);
-    if (savePromptResult === 'cancel') {
-      return state;
-    }
-    if (savePromptResult === 'save') {
-      const editorState = await saveEditor(tab.editorUid);
-      if (editorState?.modified !== false) {
-        return state;
-      }
-      if (tab.uri) {
-        await handleModifiedStatusChange$1(tab.uri, false);
-      }
-    } else if (savePromptResult !== 'discard') {
-      return state;
-    }
+  if (!(await canCloseTab(tab))) {
+    return state;
   }
   return closeTabWithViewlet(state, groupId, tabId);
 };
@@ -2485,6 +2493,16 @@ const closeAll$1 = async state => {
   return withEmptyGroups(addClosedTabs(state, entries));
 };
 
+const closeAllAndSave = async state => {
+  const tabs = state.layout.groups.flatMap(group => group.tabs);
+  for (const tab of tabs) {
+    if (!(await canCloseTab(tab))) {
+      return state;
+    }
+  }
+  return closeAll$1(state);
+};
+
 const redistributeSizesWithRemainder = groups => {
   const baseSize = Math.floor(100 / groups.length);
   const remainder = 100 % groups.length;
@@ -2825,6 +2843,10 @@ const create$1 = (uid, uri, x, y, width, height, platform, assetDir, tabHeight =
   set$1(uid, state, state);
 };
 
+const isEqual$3 = (oldState, newState) => {
+  return oldState.layout === newState.layout && oldState.width === newState.width;
+};
+
 const isEqual$2 = (oldState, newState) => {
   return false;
 };
@@ -2842,12 +2864,13 @@ const RenderCss = 10;
 const RenderIncremental = 11;
 const RenderPendingViewletUpdate = 12;
 const RenderDragData = 13;
+const RenderActiveTabVisibility = 14;
 
 const isPendingViewletUpdateEqual = (oldState, newState) => {
   return newState.pendingViewletUpdate === undefined;
 };
-const modules = [isEqual, isEqual$2, isPendingViewletUpdateEqual, isEqual$1];
-const numbers = [RenderIncremental, RenderCss, RenderPendingViewletUpdate, RenderDragData];
+const modules = [isEqual, isEqual$2, isPendingViewletUpdateEqual, isEqual$1, isEqual$3];
+const numbers = [RenderIncremental, RenderCss, RenderPendingViewletUpdate, RenderDragData, RenderActiveTabVisibility];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -3203,19 +3226,140 @@ const findTabById = (state, tabId) => {
   return undefined;
 };
 
-const getSelectedTabBounds = state => {
+const getSegmentSize = segment => {
+  return segment.groups.reduce((total, group) => total + group.size, 0);
+};
+const getGroupSegment = (segments, groupId) => {
+  return segments.find(segment => segment.groups.some(group => group.id === groupId));
+};
+const getGroupSegments = (groups, parentDirection) => {
+  const segments = [];
+  let index = 0;
+  while (index < groups.length) {
+    const group = groups[index];
+    if (group.direction !== parentDirection) {
+      const startIndex = index;
+      const nestedGroups = [group];
+      const {
+        segmentId
+      } = group;
+      index++;
+      while (index < groups.length && groups[index].direction === group.direction && groups[index].segmentId === segmentId) {
+        nestedGroups.push(groups[index]);
+        index++;
+      }
+      segments.push({
+        direction: nestedGroups.length === 1 ? undefined : group.direction,
+        groups: nestedGroups,
+        startIndex
+      });
+      continue;
+    }
+    segments.push({
+      direction: undefined,
+      groups: [group],
+      startIndex: index
+    });
+    index++;
+  }
+  return segments;
+};
+
+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 getEditorGroupBoundsFromRoot = (layout, rootBounds) => {
   const {
+    direction,
+    groups
+  } = layout;
+  const segments = getGroupSegments(groups, direction);
+  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 getEditorGroupBounds = (layout, width, height) => {
+  return getEditorGroupBoundsFromRoot(layout, {
     height,
+    width,
+    x: 0,
+    y: 0
+  });
+};
+const getEditorGroupContentBounds = (layout, bounds, tabHeight) => {
+  return getEditorGroupBoundsFromRoot(layout, bounds).map(({
+    group,
+    ...groupBounds
+  }) => ({
+    ...groupBounds,
+    groupId: group.id,
+    height: groupBounds.height - tabHeight,
+    y: groupBounds.y + tabHeight
+  }));
+};
+
+const getSelectedTabBounds = (state, groupId = state.layout.activeGroupId) => {
+  const {
+    height,
+    layout,
     tabHeight,
     width,
     x,
     y
   } = state;
-  return {
-    height: height - tabHeight,
+  const bounds = getEditorGroupContentBounds(layout, {
+    height,
     width,
     x,
-    y: y + tabHeight
+    y
+  }, tabHeight).find(item => item.groupId === groupId);
+  if (!bounds) {
+    return {
+      height: height - tabHeight,
+      width,
+      x,
+      y: y + tabHeight
+    };
+  }
+  return {
+    height: bounds.height,
+    width: bounds.width,
+    x: bounds.x,
+    y: bounds.y
   };
 };
 
@@ -3301,7 +3445,7 @@ const maybeCreateViewletForSelectedTab = async (state, newState, groupIndex, ind
   if (!viewletModuleId) {
     return undefined;
   }
-  const bounds = getSelectedTabBounds(newState);
+  const bounds = getSelectedTabBounds(newState, newState.layout.groups[groupIndex].id);
   let stateWithViewlet = createViewletForTab(newState, tabId);
   set$1(uid, state, stateWithViewlet);
   if (switchCommands.length > 0) {
@@ -4131,12 +4275,8 @@ const openInputWithContext = async (context, options) => {
       await context.updateState(() => unsupportedState);
       return;
     }
-    const bounds = {
-      height: stateAfterModuleId.height - stateAfterModuleId.tabHeight,
-      width: stateAfterModuleId.width,
-      x: stateAfterModuleId.x,
-      y: stateAfterModuleId.y + stateAfterModuleId.tabHeight
-    };
+    const tabLocation = findTabById(stateAfterModuleId, tabId);
+    const bounds = getSelectedTabBounds(stateAfterModuleId, tabLocation?.groupId);
     const stateWithViewlet = createViewletForTab(stateAfterModuleId, tabId, viewletModuleId, bounds);
     let intermediateState = stateWithViewlet;
     const {
@@ -4468,42 +4608,6 @@ const retryOpen = async state => {
   return openUri(state, tab.uri);
 };
 
-const getSegmentSize = segment => {
-  return segment.groups.reduce((total, group) => total + group.size, 0);
-};
-const getGroupSegments = (groups, parentDirection) => {
-  const segments = [];
-  let index = 0;
-  while (index < groups.length) {
-    const group = groups[index];
-    if (group.direction !== parentDirection) {
-      const startIndex = index;
-      const nestedGroups = [group];
-      const {
-        segmentId
-      } = group;
-      index++;
-      while (index < groups.length && groups[index].direction === group.direction && groups[index].segmentId === segmentId) {
-        nestedGroups.push(groups[index]);
-        index++;
-      }
-      segments.push({
-        direction: nestedGroups.length === 1 ? undefined : group.direction,
-        groups: nestedGroups,
-        startIndex
-      });
-      continue;
-    }
-    segments.push({
-      direction: undefined,
-      groups: [group],
-      startIndex: index
-    });
-    index++;
-  }
-  return segments;
-};
-
 const rebalanceGroupSizes = groups => {
   const groupCount = groups.length;
   if (groupCount === 0) {
@@ -4822,60 +4926,6 @@ 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;
@@ -5361,14 +5411,7 @@ const newFile = async state => {
     uri: 'untitled:///1'
   };
   const stateWithNewTab = openTab(newState, targetGroupId, newTab);
-
-  // Calculate bounds: use main area bounds minus tab height
-  const bounds = {
-    height: stateWithNewTab.height - stateWithNewTab.tabHeight,
-    width: stateWithNewTab.width,
-    x: stateWithNewTab.x,
-    y: stateWithNewTab.y + stateWithNewTab.tabHeight
-  };
+  const bounds = getSelectedTabBounds(stateWithNewTab, targetGroupId);
   const viewletModuleId = EditorText;
   const stateWithViewlet = createViewletForTab(stateWithNewTab, tabId);
   let intermediateState = stateWithViewlet;
@@ -5408,7 +5451,7 @@ const handleHeaderDoubleClick = async (state, className, groupIndexRaw) => {
   return newFile(state);
 };
 
-const getAllTabs = layout => {
+const getAllTabs$1 = layout => {
   const {
     groups
   } = layout;
@@ -5428,7 +5471,7 @@ const loadFileIcons = async state => {
     groups
   } = layout;
   try {
-    const allTabs = getAllTabs(layout);
+    const allTabs = getAllTabs$1(layout);
     const {
       newFileIconCache
     } = await getFileIconsForTabs(allTabs, fileIconCache);
@@ -5535,13 +5578,6 @@ const resizeChild = async (editorUid, dimensions) => {
   }
 };
 const handleResize = async (state, dimensions) => {
-  const {
-    height,
-    width,
-    x,
-    y
-  } = dimensions;
-
   // Resize all editor children to their new bounds
   const {
     layout,
@@ -5550,20 +5586,24 @@ const handleResize = async (state, dimensions) => {
   const {
     groups
   } = layout;
-  const contentHeight = height - tabHeight;
+  const groupBounds = getEditorGroupContentBounds(layout, dimensions, tabHeight);
   const resizePromises = [];
-  const tabs = groups.flatMap(group => group.tabs);
-  for (const tab of tabs) {
-    if (tab.editorUid === -1) {
+  for (const group of groups) {
+    const bounds = groupBounds.find(item => item.groupId === group.id);
+    if (!bounds) {
       continue;
     }
-    const resizePromise = resizeChild(tab.editorUid, {
-      height: contentHeight,
-      width,
-      x,
-      y: y + tabHeight
-    });
-    resizePromises.push(resizePromise);
+    const dimensions = {
+      height: bounds.height,
+      width: bounds.width,
+      x: bounds.x,
+      y: bounds.y
+    };
+    for (const tab of group.tabs) {
+      if (tab.editorUid !== -1) {
+        resizePromises.push(resizeChild(tab.editorUid, dimensions));
+      }
+    }
   }
   const resizeCommands = await Promise.all(resizePromises);
   return resizeCommands.flat();
@@ -5768,6 +5808,7 @@ const handleSashPointerDown = async (state, sashId, clientX, clientY) => {
     layout
   } = state;
   const {
+    direction,
     groups
   } = layout;
   const beforeGroup = groups.find(group => group.id === parsed.beforeGroupId);
@@ -5778,13 +5819,20 @@ const handleSashPointerDown = async (state, sashId, clientX, clientY) => {
   if (!Number.isFinite(clientX) || !Number.isFinite(clientY)) {
     return state;
   }
+  const segments = getGroupSegments(groups, direction);
+  const beforeSegment = getGroupSegment(segments, parsed.beforeGroupId);
+  const afterSegment = getGroupSegment(segments, parsed.afterGroupId);
+  if (!beforeSegment || !afterSegment) {
+    return state;
+  }
+  const isNestedSash = beforeSegment === afterSegment;
   return {
     ...state,
     sashDrag: {
       afterGroupId: parsed.afterGroupId,
-      afterSize: afterGroup.size,
+      afterSize: isNestedSash ? afterGroup.size : getSegmentSize(afterSegment),
       beforeGroupId: parsed.beforeGroupId,
-      beforeSize: beforeGroup.size,
+      beforeSize: isNestedSash ? beforeGroup.size : getSegmentSize(beforeSegment),
       sashId,
       startClientX: clientX,
       startClientY: clientY
@@ -5792,6 +5840,14 @@ const handleSashPointerDown = async (state, sashId, clientX, clientY) => {
   };
 };
 
+const resizeGroupInSegment = (segment, groupId, segmentSize) => {
+  const group = segment.groups.find(group => group.id === groupId);
+  if (!group) {
+    return undefined;
+  }
+  const previousSegmentSize = getSegmentSize(segment);
+  return round(group.size / previousSegmentSize * segmentSize);
+};
 const handleSashPointerMove = async (state, clientX, clientY) => {
   const {
     height,
@@ -5811,6 +5867,13 @@ const handleSashPointerMove = async (state, clientX, clientY) => {
     direction,
     groups
   } = layout;
+  const segments = getGroupSegments(groups, direction);
+  const beforeSegment = getGroupSegment(segments, sashDrag.beforeGroupId);
+  const afterSegment = getGroupSegment(segments, sashDrag.afterGroupId);
+  if (!beforeSegment || !afterSegment) {
+    return state;
+  }
+  const isNestedSash = beforeSegment === afterSegment;
   const axisSize = direction === Horizontal ? width : height;
   if (!axisSize) {
     return state;
@@ -5828,6 +5891,23 @@ const handleSashPointerMove = async (state, clientX, clientY) => {
   const beforeSize = clamp(sashDrag.beforeSize + deltaPercent, minGroupSize, totalResizableSize - minGroupSize);
   const afterSize = totalResizableSize - beforeSize;
   const newGroups = groups.map(group => {
+    if (!isNestedSash) {
+      const resizedBeforeGroupSize = resizeGroupInSegment(beforeSegment, group.id, beforeSize);
+      if (resizedBeforeGroupSize !== undefined) {
+        return {
+          ...group,
+          size: resizedBeforeGroupSize
+        };
+      }
+      const resizedAfterGroupSize = resizeGroupInSegment(afterSegment, group.id, afterSize);
+      if (resizedAfterGroupSize !== undefined) {
+        return {
+          ...group,
+          size: resizedAfterGroupSize
+        };
+      }
+      return group;
+    }
     if (group.id === sashDrag.beforeGroupId) {
       return {
         ...group,
@@ -5885,6 +5965,77 @@ const handleTabContextMenu = async (state, button, x, y, groupIndexRaw = '', tab
   return state;
 };
 
+const getFocusIndex = (key, index, tabCount) => {
+  switch (key) {
+    case 'ArrowLeft':
+      return (index + tabCount - 1) % tabCount;
+    case 'ArrowRight':
+      return (index + 1) % tabCount;
+    case 'End':
+      return tabCount - 1;
+    case 'Home':
+      return 0;
+    default:
+      return -1;
+  }
+};
+const focusTab = async (state, groupIndex, index) => {
+  const selector = `.${MainTab}[data-group-index="${groupIndex}"][data-index="${index}"]`;
+  if (isConnected()) {
+    await invoke('Viewlet.focusSelector', state.uid, selector);
+  } else {
+    await invoke$1('Viewlet.focusSelector', state.uid, selector);
+  }
+};
+const handleTabKeyDown = async (state, groupIndexRaw, indexRaw, key) => {
+  if (!groupIndexRaw || !indexRaw) {
+    return state;
+  }
+  const groupIndex = Number.parseInt(groupIndexRaw);
+  const index = Number.parseInt(indexRaw);
+  const group = state.layout.groups[groupIndex];
+  if (!group || index < 0 || index >= group.tabs.length) {
+    return state;
+  }
+  if ([' ', 'Enter', 'Space'].includes(key)) {
+    return selectTab(state, groupIndex, index);
+  }
+  const focusIndex = getFocusIndex(key, index, group.tabs.length);
+  if (focusIndex === -1) {
+    return state;
+  }
+  await focusTab(state, groupIndex, focusIndex);
+  return state;
+};
+
+const getPixelDelta = (state, deltaMode, deltaY) => {
+  switch (deltaMode) {
+    case 1:
+      return deltaY * 16;
+    case 2:
+      return deltaY * state.width;
+    default:
+      return deltaY;
+  }
+};
+const handleTabsWheel = async (state, groupIndexRaw, deltaMode, deltaY) => {
+  if (!groupIndexRaw || deltaY === 0) {
+    return state;
+  }
+  const groupIndex = Number.parseInt(groupIndexRaw);
+  if (!state.layout.groups[groupIndex]) {
+    return state;
+  }
+  const selector = `.${MainTabs}[data-group-index="${groupIndex}"]`;
+  const pixelDelta = getPixelDelta(state, deltaMode, deltaY);
+  if (isConnected()) {
+    await invoke('Viewlet.scrollSelectorBy', state.uid, selector, pixelDelta);
+  } else {
+    await invoke$1('Viewlet.scrollSelectorBy', state.uid, selector, pixelDelta);
+  }
+  return state;
+};
+
 const handleUriChange = async (state, oldUri, newUri) => {
   const {
     homeDirUri,
@@ -6056,7 +6207,10 @@ const tryRestoreLayout = savedState => {
   return normalizedLayout;
 };
 
-const createViewlets = async (layout, viewletModuleIds, bounds) => {
+const createViewlets = async (state, viewletModuleIds) => {
+  const {
+    layout
+  } = state;
   const {
     groups
   } = layout;
@@ -6067,7 +6221,8 @@ const createViewlets = async (layout, viewletModuleIds, bounds) => {
     if (activeTab && viewletModuleIds[activeTab.id]) {
       const editorUid = activeTab.editorUid === -1 ? create$2() : activeTab.editorUid;
       editorUids[activeTab.id] = editorUid;
-      const title = await createViewlet(viewletModuleIds[activeTab.id], editorUid, activeTab.id, bounds, activeTab.uri);
+      const bounds = getSelectedTabBounds(state, group.id);
+      const title = await createViewlet(viewletModuleIds[activeTab.id], editorUid, activeTab.id, bounds, activeTab.uri || '');
       if (title) {
         titles[activeTab.id] = title;
       }
@@ -6141,19 +6296,10 @@ const updateTabs = (state, editorUids) => {
 };
 
 const restoreAndCreateEditors = async (state, restoredLayout) => {
-  const {
-    tabHeight
-  } = state;
   let newState = {
     ...state,
     layout: restoredLayout
   };
-  const bounds = {
-    height: newState.height - tabHeight,
-    width: newState.width,
-    x: newState.x,
-    y: newState.y + tabHeight
-  };
 
   // Get viewlet module IDs for all active tabs
   const viewletModuleIds = await getViewletModuleIds(newState.layout);
@@ -6162,7 +6308,7 @@ const restoreAndCreateEditors = async (state, restoredLayout) => {
   const {
     editorUids,
     titles
-  } = await createViewlets(newState.layout, viewletModuleIds, bounds);
+  } = await createViewlets(newState, viewletModuleIds);
 
   // Update tabs with editor UIDs
   newState = updateTabs(newState, editorUids);
@@ -6172,6 +6318,7 @@ const restoreAndCreateEditors = async (state, restoredLayout) => {
     const activeTab = group.tabs.find(tab => tab.id === group.activeTabId);
     if (activeTab && viewletModuleIds[activeTab.id]) {
       const editorUid = editorUids[activeTab.id];
+      getSelectedTabBounds(newState, group.id);
       newState = createViewletForTab(newState, activeTab.id);
       newState = handleViewletReady(newState, editorUid, titles[activeTab.id]);
     }
@@ -6298,6 +6445,30 @@ const hasActiveTextEditor = state => {
   return activeTab?.tab.editorInput?.type === 'editor';
 };
 
+const getTabs = group => {
+  return group.tabs;
+};
+const getAllTabs = state => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  return groups.flatMap(getTabs);
+};
+
+const isDirty = tab => {
+  return tab.isDirty;
+};
+const getDirtyTabs = state => {
+  return getAllTabs(state).filter(isDirty);
+};
+
+const hasDirtyTabs = state => {
+  return getDirtyTabs(state).length > 0;
+};
+
 const initialize$1 = async () => {
   // Kept as a compatibility command for existing renderer startup code.
 };
@@ -6695,6 +6866,24 @@ const refresh = state => {
   };
 };
 
+const renderActiveTabVisibility = (oldState, newState) => {
+  const {
+    activeGroupId,
+    groups
+  } = newState.layout;
+  const groupIndex = groups.findIndex(group => group.id === activeGroupId);
+  if (groupIndex === -1) {
+    return [];
+  }
+  const group = groups[groupIndex];
+  const tabIndex = group.tabs.findIndex(tab => tab.id === group.activeTabId);
+  if (tabIndex === -1) {
+    return [];
+  }
+  const selector = `.${MainTab}[data-group-index="${groupIndex}"][data-index="${tabIndex}"]`;
+  return ['Viewlet.scrollSelectorIntoView', newState.uid, selector];
+};
+
 const getDragOverlayCss = dragOverlay => {
   if (!dragOverlay) {
     return [];
@@ -7168,6 +7357,8 @@ const HandleDrop = 25;
 const HandleDragStart = 26;
 const HandleDragEnd = 27;
 const HandleTabMouseUp = 28;
+const HandleTabKeyDown = 29;
+const HandleTabsWheel = 30;
 
 const dragOverlayVirtualDom = {
   childCount: 0,
@@ -7396,9 +7587,11 @@ const renderTab = (tab, isActive, tabIndex, groupIndex) => {
     onDblClick: HandleDoubleClick,
     onDragEnd: HandleDragEnd,
     onDragStart: HandleDragStart,
+    onKeyDown: HandleTabKeyDown,
     onMouseDown: HandleClickTab,
     onMouseUp: HandleTabMouseUp,
     role: Tab$1,
+    tabIndex: isActive ? 0 : -1,
     title: tab.uriTitle || tab.uri || tab.title,
     type: Div
   }, ...renderTabIcon(tab), tabTitleNode, text(tab.title), ...closeButtonNodes];
@@ -7408,6 +7601,8 @@ const getTabsVirtualDom = (group, groupIndex, tabsChildCount) => {
   return [{
     childCount: tabsChildCount,
     className: MainTabs,
+    'data-groupIndex': groupIndex,
+    onWheel: HandleTabsWheel,
     role: TabList,
     type: Div
   }, ...group.tabs.flatMap((tab, tabIndex) => renderTab(tab, tab.id === group.activeTabId, tabIndex, groupIndex))];
@@ -7768,6 +7963,8 @@ const renderPendingViewletUpdate = (oldState, newState) => {
 
 const getRenderer = diffType => {
   switch (diffType) {
+    case RenderActiveTabVisibility:
+      return renderActiveTabVisibility;
     case RenderCss:
       return renderCss;
     case RenderDragData:
@@ -7820,10 +8017,17 @@ const renderEventListeners = () => {
     params: ['handleClick', TargetName]
   }, {
     name: HandleClickClose,
-    params: ['handleClickCloseTab', 'event.target.dataset.groupIndex', 'event.target.dataset.index']
+    params: ['handleClickCloseTab', 'event.currentTarget.dataset.groupIndex', 'event.currentTarget.dataset.index'],
+    stopPropagation: true
   }, {
     name: HandleClickTab,
-    params: ['handleClickTab', 'event.target.dataset.groupIndex', 'event.target.dataset.index', Button$1]
+    params: ['handleClickTab', 'event.currentTarget.dataset.groupIndex', 'event.currentTarget.dataset.index', Button$1]
+  }, {
+    name: HandleTabKeyDown,
+    params: ['handleTabKeyDown', 'event.currentTarget.dataset.groupIndex', 'event.currentTarget.dataset.index', Key]
+  }, {
+    name: HandleTabsWheel,
+    params: ['handleTabsWheel', 'event.currentTarget.dataset.groupIndex', DeltaMode, DeltaY]
   }, {
     name: HandleDoubleClick,
     params: ['handleDoubleClick', 'event.target.dataset.groupIndex', 'event.target.dataset.index']
@@ -7963,12 +8167,7 @@ const reopenEditorWith = async (context, preferredEditorId) => {
     errorMessage: undefined,
     loadingState: undefined
   });
-  const bounds = {
-    height: resetState.height - resetState.tabHeight,
-    width: resetState.width,
-    x: resetState.x,
-    y: resetState.y + resetState.tabHeight
-  };
+  const bounds = getSelectedTabBounds(resetState, latestTab.groupId);
   const stateWithViewlet = createViewletForTab(resetState, initialTab.id);
   await context.updateState(() => stateWithViewlet);
   const tabWithViewlet = findTabById(stateWithViewlet, initialTab.id);
@@ -8358,6 +8557,7 @@ const commandMap = {
   'Main.closeActiveEditor': wrapSerialCommand(closeActiveEditor),
   'Main.closeAll': wrapSerialCommand(closeAll$1),
   'Main.closeAllEditors': wrapSerialCommand(closeAll$1),
+  'Main.closeAllEditorsAndSave': wrapSerialCommand(closeAllAndSave),
   'Main.closeFocusedTab': wrapSerialCommand(closeFocusedTab),
   'Main.closeOthers': wrapSerialCommand(closeOtherTabs),
   'Main.closeSaved': wrapSerialCommand(closeSaved$1),
@@ -8373,6 +8573,7 @@ const commandMap = {
   'Main.handleModifiedStatusChange': wrapAsyncCommand(handleModifiedStatusChangeWithContext),
   'Main.handleTabContextMenu': wrapSerialCommand(handleTabContextMenu),
   'Main.hasActiveTextEditor': wrapGetter(hasActiveTextEditor),
+  'Main.hasDirtyTabs': wrapGetter(hasDirtyTabs),
   'Main.openInput': wrapSerialAsyncCommand(openInputWithContext),
   'Main.openUri': wrapSerialAsyncCommand(openUriWithContext),
   'Main.openUris': wrapSerialAsyncCommand(openUrisWithContext),
@@ -8383,6 +8584,7 @@ const commandMap = {
   'MainArea.closeActiveEditor': wrapSerialCommand(closeActiveEditor),
   'MainArea.closeAll': wrapSerialCommand(closeAll$1),
   'MainArea.closeAllEditors': wrapSerialCommand(closeAll$1),
+  'MainArea.closeAllEditorsAndSave': wrapSerialCommand(closeAllAndSave),
   'MainArea.closeEditorGroup': wrapSerialCommand(closeEditorGroup$1),
   'MainArea.closeFocusedTab': wrapSerialCommand(closeFocusedTab),
   'MainArea.closeOthers': wrapSerialCommand(closeOtherTabs),
@@ -8428,12 +8630,15 @@ const commandMap = {
   'MainArea.handleSashPointerMove': wrapSerialCommand(handleSashPointerMove),
   'MainArea.handleSashPointerUp': wrapSerialCommand(handleSashPointerUp),
   'MainArea.handleTabContextMenu': wrapSerialCommand(handleTabContextMenu),
+  'MainArea.handleTabKeyDown': wrapSerialCommand(handleTabKeyDown),
   'MainArea.handleTabMouseUp': wrapSerialCommand(resetPointerDown),
+  'MainArea.handleTabsWheel': wrapSerialCommand(handleTabsWheel),
   'MainArea.handleTestWorkerMessagePort': handleTestWorkerMessagePort,
   'MainArea.handleUriChange': wrapSerialCommand(handleUriChange),
   'MainArea.handleWorkspaceChange': wrapSerialCommand(handleWorkspaceChange),
   'MainArea.handleWorkspaceRefresh': wrapAsyncCommand(handleWorkspaceRefreshWithContext),
   'MainArea.hasActiveTextEditor': wrapGetter(hasActiveTextEditor),
+  'MainArea.hasDirtyTabs': wrapGetter(hasDirtyTabs),
   'MainArea.initialize': initialize$1,
   'MainArea.loadContent': loadContentTracked,
   'MainArea.moveIntoNewWindow': wrapSerialCommand(moveIntoNewWindow),

package/package.json

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