@lvce-editor/main-area-worker 9.9.0 → 9.12.0

package/dist/mainAreaWorkerMain.js

@@ -118,310 +118,6 @@ const terminate = () => {
   globalThis.close();
 };
 
-const getGroupIndexById = (state, groupId) => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  return groups.findIndex(group => group.id === groupId);
-};
-
-const redistributeSizesWithRounding = groups => {
-  return groups.map(group => ({
-    ...group,
-    size: Math.round(100 / groups.length)
-  }));
-};
-
-const withGroupsAndActiveGroup = (state, groups, activeGroupId) => {
-  return {
-    ...state,
-    layout: {
-      ...state.layout,
-      activeGroupId,
-      groups
-    }
-  };
-};
-
-const withEmptyGroups = state => {
-  return withGroupsAndActiveGroup(state, [], undefined);
-};
-
-const withGroups = (state, groups) => {
-  return {
-    ...state,
-    layout: {
-      ...state.layout,
-      groups
-    }
-  };
-};
-
-const closeTab = (state, groupId, tabId) => {
-  const {
-    activeGroupId,
-    groups
-  } = state.layout;
-
-  // Find the group to close the tab from
-  const groupIndex = getGroupIndexById(state, groupId);
-  if (groupIndex === -1) {
-    return state;
-  }
-  const group = groups[groupIndex];
-  // Check if the tab exists in the group
-  const tabWasRemoved = group.tabs.some(tab => tab.id === tabId);
-  if (!tabWasRemoved) {
-    return state;
-  }
-  const newGroups = groups.map(grp => {
-    if (grp.id === groupId) {
-      const newTabs = grp.tabs.filter(tab => tab.id !== tabId);
-      let newActiveTabId = grp.activeTabId;
-      if (grp.activeTabId === tabId) {
-        const tabIndex = grp.tabs.findIndex(tab => tab.id === tabId);
-        if (newTabs.length > 0) {
-          newActiveTabId = newTabs[Math.min(tabIndex, newTabs.length - 1)].id;
-        } else {
-          newActiveTabId = undefined;
-        }
-      }
-      return {
-        ...grp,
-        activeTabId: newActiveTabId,
-        isEmpty: newTabs.length === 0,
-        tabs: newTabs
-      };
-    }
-    return grp;
-  });
-
-  // If the group has no tabs left after closing, remove the group
-  const groupIsNowEmpty = newGroups[groupIndex].tabs.length === 0;
-  if (groupIsNowEmpty) {
-    const remainingGroups = newGroups.filter(group => group.id !== groupId);
-
-    // If there are remaining groups, redistribute sizes
-    if (remainingGroups.length > 0) {
-      const redistributedGroups = redistributeSizesWithRounding(remainingGroups);
-      const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0]?.id : activeGroupId;
-      return withGroupsAndActiveGroup(state, redistributedGroups, newActiveGroupId);
-    }
-
-    // If no remaining groups, return empty layout
-    return withEmptyGroups(state);
-  }
-  return withGroups(state, newGroups);
-};
-
-const getFocusedGroup = state => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  return groups.find(group => group.focused);
-};
-
-const closeActiveEditor = state => {
-  const focusedGroup = getFocusedGroup(state);
-  if (!focusedGroup) {
-    return state;
-  }
-  const {
-    activeTabId
-  } = focusedGroup;
-  if (activeTabId === undefined) {
-    return state;
-  }
-  return closeTab(state, focusedGroup.id, activeTabId);
-};
-
-const closeAll$1 = state => {
-  return withEmptyGroups(state);
-};
-
-const redistributeSizesWithRemainder = groups => {
-  const baseSize = Math.floor(100 / groups.length);
-  const remainder = 100 % groups.length;
-  return groups.map((group, index) => ({
-    ...group,
-    size: baseSize + (index === groups.length - 1 ? remainder : 0)
-  }));
-};
-
-const closeEditorGroup$1 = (state, groupId) => {
-  if (Number.isNaN(groupId)) {
-    return state;
-  }
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    groups
-  } = layout;
-  const groupIndex = getGroupIndexById(state, groupId);
-  if (groupIndex === -1 || groups.length <= 1) {
-    return state;
-  }
-  const remainingGroups = groups.filter(group => group.id !== groupId);
-  const redistributedGroups = redistributeSizesWithRemainder(remainingGroups);
-  const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0].id : activeGroupId;
-  return withGroupsAndActiveGroup(state, redistributedGroups, newActiveGroupId);
-};
-
-const isFocused = group => {
-  return group.focused;
-};
-const closeFocusedTab = state => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  const focusedGroup = groups.find(isFocused);
-  if (!focusedGroup) {
-    return state;
-  }
-  const {
-    activeTabId
-  } = focusedGroup;
-  if (activeTabId === undefined) {
-    return state;
-  }
-  return closeTab(state, focusedGroup.id, activeTabId);
-};
-
-const closeOtherTabs = (state, groupId) => {
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    groups
-  } = layout;
-  const targetGroupId = groupId ?? activeGroupId;
-  if (targetGroupId === undefined) {
-    return state;
-  }
-  const group = groups.find(g => g.id === targetGroupId);
-  if (!group) {
-    return state;
-  }
-  const {
-    activeTabId
-  } = group;
-  if (activeTabId === undefined) {
-    return state;
-  }
-  const newGroups = groups.map(g => {
-    if (g.id === targetGroupId) {
-      const newTabs = g.tabs.filter(tab => tab.id === activeTabId);
-      return {
-        ...g,
-        activeTabId,
-        isEmpty: newTabs.length === 0,
-        tabs: newTabs
-      };
-    }
-    return g;
-  });
-  return {
-    ...state,
-    layout: {
-      ...layout,
-      groups: newGroups
-    }
-  };
-};
-
-const getNextActiveTabId = (tabs, newTabs, activeTabId) => {
-  if (activeTabId === undefined) {
-    return undefined;
-  }
-  if (newTabs.some(tab => tab.id === activeTabId)) {
-    return activeTabId;
-  }
-  const activeTabIndex = tabs.findIndex(tab => tab.id === activeTabId);
-  if (activeTabIndex === -1 || newTabs.length === 0) {
-    return undefined;
-  }
-  return newTabs[Math.min(activeTabIndex, newTabs.length - 1)].id;
-};
-const closeSavedInGroup = group => {
-  const {
-    activeTabId,
-    tabs
-  } = group;
-  const newTabs = tabs.filter(tab => tab.isDirty);
-  if (newTabs.length === tabs.length) {
-    return group;
-  }
-  const newActiveTabId = getNextActiveTabId(tabs, newTabs, activeTabId);
-  return {
-    ...group,
-    activeTabId: newActiveTabId,
-    isEmpty: newTabs.length === 0,
-    tabs: newTabs
-  };
-};
-const closeSaved$1 = state => {
-  const {
-    groups
-  } = state.layout;
-  const newGroups = groups.map(closeSavedInGroup);
-  return withGroups(state, newGroups);
-};
-
-const getGroupById = (state, groupId) => {
-  return state.layout.groups.find(group => group.id === groupId);
-};
-
-const closeTabsRight = (state, groupId) => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  const group = getGroupById(state, groupId);
-  if (!group) {
-    return state;
-  }
-  const {
-    activeTabId,
-    tabs
-  } = group;
-  if (activeTabId === undefined) {
-    return state;
-  }
-  const activeTabIndex = tabs.findIndex(tab => tab.id === activeTabId);
-  if (activeTabIndex === -1) {
-    return state;
-  }
-  const newTabs = tabs.slice(0, activeTabIndex + 1);
-  if (newTabs.length === tabs.length) {
-    return state;
-  }
-  const newGroups = groups.map(g => {
-    if (g.id === groupId) {
-      return {
-        ...g,
-        isEmpty: newTabs.length === 0,
-        tabs: newTabs
-      };
-    }
-    return g;
-  });
-  return withGroups(state, newGroups);
-};
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -1744,35 +1440,388 @@ const getIcons = async iconRequests => {
   return invoke$1('IconTheme.getIcons', iconRequests);
 };
 
-const {
-  invoke,
-  invokeAndTransfer,
-  set: set$1
-} = create$3(RendererWorker);
-const showContextMenu2 = async (uid, menuId, x, y, args) => {
-  number(uid);
-  number(menuId);
-  number(x);
-  number(y);
-  await invoke('ContextMenu.show2', uid, menuId, x, y, args);
+const {
+  invoke,
+  invokeAndTransfer,
+  set: set$1
+} = create$3(RendererWorker);
+const handleModifiedStatusChange$1 = async (uri, modified) => {
+  return invoke('Main.handleModifiedStatusChange', uri, modified);
+};
+const showContextMenu2 = async (uid, menuId, x, y, args) => {
+  number(uid);
+  number(menuId);
+  number(x);
+  number(y);
+  await invoke('ContextMenu.show2', uid, menuId, x, y, args);
+};
+const sendMessagePortToClipBoardWorker$1 = async (port, rpcId) => {
+  const command = 'ClipBoard.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToClipBoardWorker', port, command, rpcId);
+};
+const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = 'IconTheme.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+};
+const readFile = async uri => {
+  return invoke('FileSystem.readFile', uri);
+};
+const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const writeClipBoardText = async text => {
+  await invoke('ClipBoard.writeText', /* text */text);
+};
+
+const getGroupIndexById = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  return groups.findIndex(group => group.id === groupId);
+};
+
+const redistributeSizesWithRounding = groups => {
+  return groups.map(group => ({
+    ...group,
+    size: Math.round(100 / groups.length)
+  }));
+};
+
+const withGroupsAndActiveGroup = (state, groups, activeGroupId) => {
+  return {
+    ...state,
+    layout: {
+      ...state.layout,
+      activeGroupId,
+      groups
+    }
+  };
+};
+
+const withEmptyGroups = state => {
+  return withGroupsAndActiveGroup(state, [], undefined);
+};
+
+const withGroups = (state, groups) => {
+  return {
+    ...state,
+    layout: {
+      ...state.layout,
+      groups
+    }
+  };
+};
+
+const closeTab = (state, groupId, tabId) => {
+  const {
+    activeGroupId,
+    groups
+  } = state.layout;
+
+  // Find the group to close the tab from
+  const groupIndex = getGroupIndexById(state, groupId);
+  if (groupIndex === -1) {
+    return state;
+  }
+  const group = groups[groupIndex];
+  // Check if the tab exists in the group
+  const tabWasRemoved = group.tabs.some(tab => tab.id === tabId);
+  if (!tabWasRemoved) {
+    return state;
+  }
+  const newGroups = groups.map(grp => {
+    if (grp.id === groupId) {
+      const newTabs = grp.tabs.filter(tab => tab.id !== tabId);
+      let newActiveTabId = grp.activeTabId;
+      if (grp.activeTabId === tabId) {
+        const tabIndex = grp.tabs.findIndex(tab => tab.id === tabId);
+        if (newTabs.length > 0) {
+          newActiveTabId = newTabs[Math.min(tabIndex, newTabs.length - 1)].id;
+        } else {
+          newActiveTabId = undefined;
+        }
+      }
+      return {
+        ...grp,
+        activeTabId: newActiveTabId,
+        isEmpty: newTabs.length === 0,
+        tabs: newTabs
+      };
+    }
+    return grp;
+  });
+
+  // If the group has no tabs left after closing, remove the group
+  const groupIsNowEmpty = newGroups[groupIndex].tabs.length === 0;
+  if (groupIsNowEmpty) {
+    const remainingGroups = newGroups.filter(group => group.id !== groupId);
+
+    // If there are remaining groups, redistribute sizes
+    if (remainingGroups.length > 0) {
+      const redistributedGroups = redistributeSizesWithRounding(remainingGroups);
+      const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0]?.id : activeGroupId;
+      return withGroupsAndActiveGroup(state, redistributedGroups, newActiveGroupId);
+    }
+
+    // If no remaining groups, return empty layout
+    return withEmptyGroups(state);
+  }
+  return withGroups(state, newGroups);
+};
+
+const findTabInState = (state, groupId, tabId) => {
+  const {
+    layout
+  } = state;
+  const group = layout.groups.find(g => g.id === groupId);
+  return group?.tabs.find(t => t.id === tabId);
+};
+
+const saveEditor = async editorUid => {
+  return invoke('Editor.save', editorUid);
+};
+
+const closeTabAndSave = async (state, groupId, tabId) => {
+  const tab = findTabInState(state, groupId, tabId);
+  if (!tab) {
+    return state;
+  }
+  if (tab.editorUid !== -1) {
+    const editorState = await saveEditor(tab.editorUid);
+    if (!editorState?.modified && tab.uri) {
+      await handleModifiedStatusChange$1(tab.uri, false);
+    }
+  }
+  return closeTab(state, groupId, tabId);
+};
+
+const getFocusedGroup = state => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  return groups.find(group => group.focused);
+};
+
+const closeActiveEditor = async state => {
+  const focusedGroup = getFocusedGroup(state);
+  if (!focusedGroup) {
+    return state;
+  }
+  const {
+    activeTabId
+  } = focusedGroup;
+  if (activeTabId === undefined) {
+    return state;
+  }
+  return closeTabAndSave(state, focusedGroup.id, activeTabId);
+};
+
+const closeAll$1 = state => {
+  return withEmptyGroups(state);
+};
+
+const redistributeSizesWithRemainder = groups => {
+  const baseSize = Math.floor(100 / groups.length);
+  const remainder = 100 % groups.length;
+  return groups.map((group, index) => ({
+    ...group,
+    size: baseSize + (index === groups.length - 1 ? remainder : 0)
+  }));
+};
+
+const closeEditorGroup$1 = (state, groupId) => {
+  if (Number.isNaN(groupId)) {
+    return state;
+  }
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const groupIndex = getGroupIndexById(state, groupId);
+  if (groupIndex === -1 || groups.length <= 1) {
+    return state;
+  }
+  const remainingGroups = groups.filter(group => group.id !== groupId);
+  const redistributedGroups = redistributeSizesWithRemainder(remainingGroups);
+  const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0].id : activeGroupId;
+  return withGroupsAndActiveGroup(state, redistributedGroups, newActiveGroupId);
+};
+
+const isFocused = group => {
+  return group.focused;
+};
+const closeFocusedTab = async state => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const focusedGroup = groups.find(isFocused);
+  if (!focusedGroup) {
+    return state;
+  }
+  const {
+    activeTabId
+  } = focusedGroup;
+  if (activeTabId === undefined) {
+    return state;
+  }
+  return closeTabAndSave(state, focusedGroup.id, activeTabId);
+};
+
+const closeOtherTabs = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const targetGroupId = groupId ?? activeGroupId;
+  if (targetGroupId === undefined) {
+    return state;
+  }
+  const group = groups.find(g => g.id === targetGroupId);
+  if (!group) {
+    return state;
+  }
+  const {
+    activeTabId
+  } = group;
+  if (activeTabId === undefined) {
+    return state;
+  }
+  const newGroups = groups.map(g => {
+    if (g.id === targetGroupId) {
+      const newTabs = g.tabs.filter(tab => tab.id === activeTabId);
+      return {
+        ...g,
+        activeTabId,
+        isEmpty: newTabs.length === 0,
+        tabs: newTabs
+      };
+    }
+    return g;
+  });
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      groups: newGroups
+    }
+  };
+};
+
+const getNextActiveTabId = (tabs, newTabs, activeTabId) => {
+  if (activeTabId === undefined) {
+    return undefined;
+  }
+  if (newTabs.some(tab => tab.id === activeTabId)) {
+    return activeTabId;
+  }
+  const activeTabIndex = tabs.findIndex(tab => tab.id === activeTabId);
+  if (activeTabIndex === -1 || newTabs.length === 0) {
+    return undefined;
+  }
+  return newTabs[Math.min(activeTabIndex, newTabs.length - 1)].id;
 };
-const sendMessagePortToClipBoardWorker$1 = async (port, rpcId) => {
-  const command = 'ClipBoard.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToClipBoardWorker', port, command, rpcId);
+const closeSavedInGroup = group => {
+  const {
+    activeTabId,
+    tabs
+  } = group;
+  const newTabs = tabs.filter(tab => tab.isDirty);
+  if (newTabs.length === tabs.length) {
+    return group;
+  }
+  const newActiveTabId = getNextActiveTabId(tabs, newTabs, activeTabId);
+  return {
+    ...group,
+    activeTabId: newActiveTabId,
+    isEmpty: newTabs.length === 0,
+    tabs: newTabs
+  };
 };
-const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
-  const command = 'IconTheme.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+const closeSaved$1 = state => {
+  const {
+    groups
+  } = state.layout;
+  const newGroups = groups.map(closeSavedInGroup);
+  return withGroups(state, newGroups);
 };
-const readFile = async uri => {
-  return invoke('FileSystem.readFile', uri);
+
+const closeTabsByUris = (state, uris) => {
+  let currentState = state;
+  for (const uri of uris) {
+    while (true) {
+      const matchingGroup = currentState.layout.groups.find(group => {
+        return group.tabs.some(tab => tab.uri === uri);
+      });
+      if (!matchingGroup) {
+        break;
+      }
+      const matchingTab = matchingGroup.tabs.find(tab => tab.uri === uri);
+      if (!matchingTab) {
+        break;
+      }
+      currentState = closeTab(currentState, matchingGroup.id, matchingTab.id);
+    }
+  }
+  return currentState;
 };
-const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+
+const getGroupById = (state, groupId) => {
+  return state.layout.groups.find(group => group.id === groupId);
 };
-const writeClipBoardText = async text => {
-  await invoke('ClipBoard.writeText', /* text */text);
+
+const closeTabsRight = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const group = getGroupById(state, groupId);
+  if (!group) {
+    return state;
+  }
+  const {
+    activeTabId,
+    tabs
+  } = group;
+  if (activeTabId === undefined) {
+    return state;
+  }
+  const activeTabIndex = tabs.findIndex(tab => tab.id === activeTabId);
+  if (activeTabIndex === -1) {
+    return state;
+  }
+  const newTabs = tabs.slice(0, activeTabIndex + 1);
+  if (newTabs.length === tabs.length) {
+    return state;
+  }
+  const newGroups = groups.map(g => {
+    if (g.id === groupId) {
+      return {
+        ...g,
+        isEmpty: newTabs.length === 0,
+        tabs: newTabs
+      };
+    }
+    return g;
+  });
+  return withGroups(state, newGroups);
 };
 
 const copyPath$1 = async (state, path) => {
@@ -1947,6 +1996,15 @@ const loadFileContent = async path => {
   const content = await readFile(path);
   return content;
 };
+const getLoadFileErrorMessage = error => {
+  if (!(error instanceof Error)) {
+    return 'Failed to load file content';
+  }
+  if (error.message.includes('EISDIR') || error.message.includes('illegal operation on a directory') || error.message.includes('is a directory')) {
+    return 'Expected a file but received a folder';
+  }
+  return error.message;
+};
 const loadTabContentAsync = async (tabId, path, requestId, getLatestState) => {
   try {
     await loadFileContent(path);
@@ -1984,7 +2042,7 @@ const loadTabContentAsync = async (tabId, path, requestId, getLatestState) => {
     if (latestTab.loadingState !== 'loading') {
       return latestState;
     }
-    const errorMessage = error instanceof Error ? error.message : 'Failed to load file content';
+    const errorMessage = getLoadFileErrorMessage(error);
     return updateTab(latestState, tabId, {
       errorMessage,
       loadingState: 'error'
@@ -2167,6 +2225,7 @@ const getViewletModuleId$1 = async uri => {
 };
 
 const DiffEditor = 'DiffEditor';
+const EditorText = 'Editor';
 const ExtensionDetail = 'ExtensionDetail';
 const QuickPick = 'QuickPick';
 
@@ -2487,6 +2546,89 @@ const parseRawGroupId = rawGroupId => {
   return Number.isNaN(groupId) ? undefined : groupId;
 };
 
+const findTabByUri = (state, uri) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  for (const group of groups) {
+    const tab = group.tabs.find(t => t.uri === uri);
+    if (tab) {
+      return {
+        groupId: group.id,
+        tab
+      };
+    }
+  }
+  return undefined;
+};
+
+const focusEditorGroup = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const updatedGroups = groups.map(group => ({
+    ...group,
+    focused: group.id === groupId
+  }));
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      activeGroupId: groupId,
+      groups: updatedGroups
+    }
+  };
+};
+
+const getActiveTabId = state => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const activeGroup = groups.find(g => g.id === activeGroupId);
+  return activeGroup?.activeTabId;
+};
+
+const getTabCount = state => {
+  return state.layout.groups.reduce((sum, group) => sum + group.tabs.length, 0);
+};
+
+const getCurrentState = state => {
+  const {
+    uid
+  } = state;
+  const stateFromStore = get(uid);
+  if (!stateFromStore) {
+    set(uid, state, state);
+    return state;
+  }
+  const storedState = stateFromStore.newState;
+  if (getTabCount(storedState) > getTabCount(state)) {
+    return storedState;
+  }
+  set(uid, state, state);
+  return state;
+};
+
+const getEditorInputEditorType = editorInput => {
+  switch (editorInput.type) {
+    case 'diff-editor':
+    case 'extension-detail-view':
+      return 'custom';
+    case 'editor':
+      return 'text';
+  }
+};
+
 const getBasename$1 = uri => {
   const lastSlashIndex = uri.lastIndexOf('/');
   if (lastSlashIndex === -1) {
@@ -2521,6 +2663,32 @@ const getLabel = uri => {
   return getBasename$1(uri);
 };
 
+const getEditorInputTitle = editorInput => {
+  switch (editorInput.type) {
+    case 'diff-editor':
+      {
+        const leftTitle = getLabel(editorInput.uriLeft);
+        const rightTitle = getLabel(editorInput.uriRight);
+        return `${leftTitle} - ${rightTitle}`;
+      }
+    case 'editor':
+      return getLabel(editorInput.uri);
+    case 'extension-detail-view':
+      return editorInput.extensionId;
+  }
+};
+
+const getEditorInputUri = editorInput => {
+  switch (editorInput.type) {
+    case 'diff-editor':
+      return `diff://?left=${encodeURIComponent(editorInput.uriLeft)}&right=${encodeURIComponent(editorInput.uriRight)}`;
+    case 'editor':
+      return editorInput.uri;
+    case 'extension-detail-view':
+      return `extension-detail://${editorInput.extensionId}`;
+  }
+};
+
 const createEmptyGroup = (state, uri, requestId, preview = false, title = getLabel(uri), editorType = 'text', editorInput) => {
   const {
     layout
@@ -2679,94 +2847,85 @@ const ensureActiveGroup = (state, uri, preview = false, title = getLabel(uri), e
   return newState;
 };
 
-const findTabByUri = (state, uri) => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  for (const group of groups) {
-    const tab = group.tabs.find(t => t.uri === uri);
-    if (tab) {
-      return {
-        groupId: group.id,
-        tab
-      };
-    }
+const getStateWithTab = (currentState, editorInput, existingTab, shouldRetryExistingTab, uri, preview, title, editorType) => {
+  if (shouldRetryExistingTab && existingTab) {
+    const focusedState = focusEditorGroup(currentState, existingTab.groupId);
+    return {
+      stateWithTab: updateTab(focusedState, existingTab.tab.id, {
+        editorInput,
+        errorMessage: '',
+        loadingState: 'loading',
+        title,
+        uri
+      }),
+      tabId: existingTab.tab.id
+    };
   }
-  return undefined;
+  const stateWithTab = ensureActiveGroup(currentState, uri, preview, title, editorType, editorInput);
+  return {
+    stateWithTab,
+    tabId: getActiveTabId(stateWithTab)
+  };
 };
 
-const focusEditorGroup = (state, groupId) => {
+const Directory = 3;
+const DirectoryExpanded = 4;
+
+const isLocalEditorInput = editorInput => {
+  if (editorInput.type !== 'editor') {
+    return false;
+  }
+  return editorInput.uri.startsWith('file://') || !editorInput.uri.includes('://');
+};
+
+const shouldCheckDirectoryEditorInput = editorInput => {
+  if (!isLocalEditorInput(editorInput)) {
+    return false;
+  }
+  const baseName = editorInput.uri.slice(editorInput.uri.lastIndexOf('/') + 1);
+  return baseName.endsWith('/') || baseName !== '' && !baseName.includes('.');
+};
+
+const isDirectoryEditorInput = async editorInput => {
+  if (!shouldCheckDirectoryEditorInput(editorInput)) {
+    return false;
+  }
+  try {
+    const type = await invoke('FileSystem.stat', editorInput.uri);
+    return type === Directory;
+  } catch {
+    return false;
+  }
+};
+
+const switchTab = (state, groupId, tabId) => {
   const {
     layout
   } = state;
   const {
     groups
   } = layout;
-  const updatedGroups = groups.map(group => ({
-    ...group,
-    focused: group.id === groupId
-  }));
+  const updatedGroups = groups.map(group => {
+    if (group.id === groupId) {
+      const tabExists = group.tabs.some(tab => tab.id === tabId);
+      if (tabExists) {
+        return {
+          ...group,
+          activeTabId: tabId
+        };
+      }
+    }
+    return group;
+  });
   return {
     ...state,
     layout: {
       ...layout,
-      activeGroupId: groupId,
       groups: updatedGroups
     }
   };
 };
 
-const getActiveTabId = state => {
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    groups
-  } = layout;
-  const activeGroup = groups.find(g => g.id === activeGroupId);
-  return activeGroup?.activeTabId;
-};
-
-const getEditorInputEditorType = editorInput => {
-  switch (editorInput.type) {
-    case 'diff-editor':
-    case 'extension-detail-view':
-      return 'custom';
-    case 'editor':
-      return 'text';
-  }
-};
-
-const getEditorInputTitle = editorInput => {
-  switch (editorInput.type) {
-    case 'diff-editor':
-      {
-        const leftTitle = getLabel(editorInput.uriLeft);
-        const rightTitle = getLabel(editorInput.uriRight);
-        return `${leftTitle} - ${rightTitle}`;
-      }
-    case 'editor':
-      return getLabel(editorInput.uri);
-    case 'extension-detail-view':
-      return editorInput.extensionId;
-  }
-};
-
-const getEditorInputUri = editorInput => {
-  switch (editorInput.type) {
-    case 'diff-editor':
-      return `diff://?left=${encodeURIComponent(editorInput.uriLeft)}&right=${encodeURIComponent(editorInput.uriRight)}`;
-    case 'editor':
-      return editorInput.uri;
-    case 'extension-detail-view':
-      return `extension-detail://${editorInput.extensionId}`;
-  }
-};
-
 const getIconsCached = (dirents, fileIconCache) => {
   return dirents.map(dirent => fileIconCache[dirent]);
 };
@@ -2801,9 +2960,6 @@ const getMissingIconRequestsForTabs = (tabs, fileIconCache) => {
   return iconRequests;
 };
 
-const Directory = 3;
-const DirectoryExpanded = 4;
-
 const getSimpleIconRequestType = direntType => {
   if (direntType === Directory || direntType === DirectoryExpanded) {
     return 2;
@@ -2854,73 +3010,6 @@ const getFileIconsForTabs = async (tabs, fileIconCache) => {
   };
 };
 
-const switchTab = (state, groupId, tabId) => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  const updatedGroups = groups.map(group => {
-    if (group.id === groupId) {
-      const tabExists = group.tabs.some(tab => tab.id === tabId);
-      if (tabExists) {
-        return {
-          ...group,
-          activeTabId: tabId
-        };
-      }
-    }
-    return group;
-  });
-  return {
-    ...state,
-    layout: {
-      ...layout,
-      groups: updatedGroups
-    }
-  };
-};
-
-const getTabCount = state => {
-  return state.layout.groups.reduce((sum, group) => sum + group.tabs.length, 0);
-};
-const getCurrentState = state => {
-  const {
-    uid
-  } = state;
-  const stateFromStore = get(uid);
-  if (!stateFromStore) {
-    set(uid, state, state);
-    return state;
-  }
-  const storedState = stateFromStore.newState;
-  if (getTabCount(storedState) > getTabCount(state)) {
-    return storedState;
-  }
-  set(uid, state, state);
-  return state;
-};
-const getStateWithTab = (currentState, editorInput, existingTab, shouldRetryExistingTab, uri, preview, title, editorType) => {
-  if (shouldRetryExistingTab && existingTab) {
-    const focusedState = focusEditorGroup(currentState, existingTab.groupId);
-    return {
-      stateWithTab: updateTab(focusedState, existingTab.tab.id, {
-        editorInput,
-        errorMessage: '',
-        loadingState: 'loading',
-        title,
-        uri
-      }),
-      tabId: existingTab.tab.id
-    };
-  }
-  const stateWithTab = ensureActiveGroup(currentState, uri, preview, title, editorType, editorInput);
-  return {
-    stateWithTab,
-    tabId: getActiveTabId(stateWithTab)
-  };
-};
 const updateTabIcon = async (uid, state, readyState, tabId) => {
   const newTab = findTabById(readyState, tabId);
   if (!newTab || !newTab.tab.uri) {
@@ -2954,6 +3043,7 @@ const updateTabIcon = async (uid, state, readyState, tabId) => {
     return undefined;
   }
 };
+
 const openInput = async (state, options) => {
   object(state);
   object(options);
@@ -2967,19 +3057,30 @@ const openInput = async (state, options) => {
   const uri = getEditorInputUri(editorInput);
   const title = getEditorInputTitle(editorInput);
   const editorType = getEditorInputEditorType(editorInput);
-  const existingTab = findTabByUri(state, uri);
+  const currentState = getCurrentState(state);
+  const existingTab = findTabByUri(currentState, uri);
   const shouldRetryExistingTab = !!existingTab && existingTab.tab.loadingState === 'error';
   if (existingTab && !shouldRetryExistingTab) {
-    const focusedState = focusEditorGroup(state, existingTab.groupId);
+    const focusedState = focusEditorGroup(currentState, existingTab.groupId);
     return switchTab(focusedState, existingTab.groupId, existingTab.tab.id);
   }
-  const previousTabId = getActiveTabId(state);
-  const currentState = getCurrentState(state);
+  const previousTabId = getActiveTabId(currentState);
   const {
     stateWithTab,
     tabId
   } = getStateWithTab(currentState, editorInput, existingTab, shouldRetryExistingTab, uri, preview, title, editorType);
   set(uid, state, stateWithTab);
+  if (await isDirectoryEditorInput(editorInput)) {
+    const {
+      newState: latestState
+    } = get(uid);
+    const errorState = updateTab(latestState, tabId, {
+      errorMessage: 'Expected a file but received a folder',
+      loadingState: 'error'
+    });
+    set(uid, state, errorState);
+    return errorState;
+  }
   try {
     const viewletModuleId = await getViewletModuleIdForEditorInput(editorInput);
     const {
@@ -3363,7 +3464,7 @@ const handleClickAction = async (state, action, rawGroupId) => {
   }
 };
 
-const handleClickCloseTab = (state, rawGroupIndex, rawIndex) => {
+const handleClickCloseTab = async (state, rawGroupIndex, rawIndex) => {
   if (!rawGroupIndex || !rawIndex) {
     return state;
   }
@@ -3387,7 +3488,7 @@ const handleClickCloseTab = (state, rawGroupIndex, rawIndex) => {
   const tab = group.tabs[index];
   const groupId = group.id;
   const tabId = tab.id;
-  return closeTab(state, groupId, tabId);
+  return closeTabAndSave(state, groupId, tabId);
 };
 
 const handleClickTab = async (state, groupIndexRaw, indexRaw) => {
@@ -3534,6 +3635,7 @@ const newFile = async state => {
     x: stateWithNewTab.x,
     y: stateWithNewTab.y + stateWithNewTab.tabHeight
   };
+  const viewletModuleId = EditorText;
   const stateWithViewlet = createViewletForTab(stateWithNewTab, tabId);
   let intermediateState = stateWithViewlet;
 
@@ -3555,7 +3657,7 @@ const newFile = async state => {
   if (actualEditorUid === -1) {
     throw new Error(`invalid editorUid`);
   }
-  await createViewlet('Editor', actualEditorUid, tabId, bounds, newTab.uri || '');
+  await createViewlet(viewletModuleId, actualEditorUid, tabId, bounds, newTab.uri || '');
 
   // After viewlet is created, get the latest state and mark it as ready
   const {
@@ -4183,6 +4285,7 @@ const Pin = 'Pin';
 const SplitAndMove = 'Split & Move';
 const MoveIntoNewWindow = 'Move into New Window';
 const CopyIntoNewWindow = 'Copy into New Window';
+const NewTextFile = 'New Text File';
 const NewWindow = 'New Window';
 const OpenFile = 'Open File';
 const SplitDown = 'Split Down';
@@ -4214,6 +4317,9 @@ const splitEditorGroup = () => {
 const newWindow$1 = () => {
   return i18nString(NewWindow);
 };
+const newTextFile = () => {
+  return i18nString(NewTextFile);
+};
 const close = () => {
   return i18nString(Close);
 };
@@ -4300,6 +4406,11 @@ const getNewWindowMenuEntries = state => {
 const getMenuEntries$2 = (state, groupId) => {
   const groupArgs = getMenuEntryArgs(groupId);
   const entries = [{
+    command: 'MainArea.newFile',
+    flags: None,
+    id: 'newTextFile',
+    label: newTextFile()
+  }, {
     args: [QuickPick, 'file'],
     command: 'Viewlet.openWidget',
     flags: None,
@@ -4552,30 +4663,40 @@ const getSashOffset = (layout, groupIndex, width) => {
 const escapeCssAttributeValue = value => {
   return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
 };
-const getSashCss = (layout, width = 0) => {
-  if (layout.groups.length <= 1) {
-    return [];
-  }
-  const rules = [];
+const toSashProperty = direction => {
+  return direction === Horizontal ? 'left' : 'top';
+};
+const renderSashCss = ({
+  property,
+  sashId,
+  value
+}) => {
+  const escapedSashId = escapeCssAttributeValue(sashId);
+  return `[data-sash-id="${escapedSashId}"] {
+  ${property}: ${value};
+}`;
+};
+const getProtoSashCss = (layout, width) => {
   const segments = getGroupSegments(layout.groups, layout.direction);
-  const sashPositionProperty = layout.direction === Horizontal ? 'left' : 'top';
+  const hasNestedSegments = segments.some(segment => segment.direction !== undefined);
+  const rules = [];
   let segmentOffset = 0;
   for (let i = 1; i < segments.length; i++) {
     segmentOffset += getSegmentSize(segments[i - 1]);
     const beforeGroupId = segments[i - 1].groups.at(-1)?.id || 0;
     const afterGroupId = segments[i].groups[0].id;
     const sashId = create(beforeGroupId, afterGroupId);
-    const escapedSashId = escapeCssAttributeValue(sashId);
-    const sashOffset = segments.some(segment => segment.direction !== undefined) || layout.direction !== Horizontal || !width ? `${segmentOffset}%` : getSashOffset(layout, i, width);
-    rules.push(`[data-sashId="${escapedSashId}"] {
-  ${sashPositionProperty}: ${sashOffset};
-}`);
+    const value = hasNestedSegments || layout.direction !== Horizontal || !width ? `${segmentOffset}%` : getSashOffset(layout, i, width);
+    rules.push({
+      property: toSashProperty(layout.direction),
+      sashId,
+      value
+    });
   }
   for (const segment of segments) {
     if (segment.direction === undefined || segment.groups.length <= 1) {
       continue;
     }
-    const nestedProperty = segment.direction === Horizontal ? 'left' : 'top';
     const segmentSize = getSegmentSize(segment);
     let nestedOffset = 0;
     for (let i = 1; i < segment.groups.length; i++) {
@@ -4583,20 +4704,35 @@ const getSashCss = (layout, width = 0) => {
       const beforeGroupId = segment.groups[i - 1].id;
       const afterGroupId = segment.groups[i].id;
       const sashId = create(beforeGroupId, afterGroupId);
-      const escapedSashId = escapeCssAttributeValue(sashId);
-      const relativeOffset = Number((nestedOffset / segmentSize * 100).toFixed(6));
-      rules.push(`[data-sashId="${escapedSashId}"] {
-  ${nestedProperty}: ${relativeOffset}%;
-}`);
+      const value = `${Number((nestedOffset / segmentSize * 100).toFixed(6))}%`;
+      rules.push({
+        property: toSashProperty(segment.direction),
+        sashId,
+        value
+      });
     }
   }
   return rules;
 };
+const getSashCss = (layout, width = 0) => {
+  if (layout.groups.length <= 1) {
+    return [];
+  }
+  return getProtoSashCss(layout, width).map(renderSashCss);
+};
 
 const getCss = (layout, width = 0) => {
   const rules = [`.MainArea {
 }`, `.editor-groups-container {
   overflow: auto;
+}`, `.SashBorder {
+  background: var(--SashBorder, gray);
+}`, `.SashBorderHorizontal {
+  width: 100%;
+  height: 1px;
+}`, `.SashBorderVertical {
+  width: 1px;
+  height: 100%;
 }`, `.EditorGroup {
   min-width: 250px;
   width: var(--EditorGroupWidth, auto);
@@ -5217,6 +5353,9 @@ const getSashClassName = direction => {
   return direction === Horizontal ? 'Sash SashVertical' : 'Sash SashHorizontal';
 };
 
+const getSashBorderClassName = direction => {
+  return direction === 1 ? 'SashBorder SashBorderVertical' : 'SashBorder SashBorderHorizontal';
+};
 const renderSash = (direction, sashId) => {
   return [{
     childCount: 1,
@@ -5227,7 +5366,7 @@ const renderSash = (direction, sashId) => {
     type: Button$2
   }, {
     childCount: 0,
-    className: 'SashBorder',
+    className: getSashBorderClassName(direction),
     type: Div
   }];
 };
@@ -5445,42 +5584,69 @@ const renderEventListeners = () => {
   }];
 };
 
-const saveEditor = async editorUid => {
-  await invoke('Editor.save', editorUid);
-};
-const getEditorSaveState = async editorUid => {
-  return invoke('Editor.saveState', editorUid);
+const getLatestStoredState = (uid, fallbackState, referenceTabId, referenceTabUri, allowMissingReference = false) => {
+  const stateFromStore = get(uid);
+  if (!stateFromStore) {
+    return fallbackState;
+  }
+  const storedState = stateFromStore.newState;
+  const storedActiveTabData = getActiveTab(storedState);
+  if (!storedActiveTabData) {
+    return fallbackState;
+  }
+  if (allowMissingReference && referenceTabId === undefined && referenceTabUri === undefined) {
+    return storedState;
+  }
+  if (storedActiveTabData.tab.id === referenceTabId) {
+    return storedState;
+  }
+  if (referenceTabUri && storedActiveTabData.tab.uri === referenceTabUri) {
+    return storedState;
+  }
+  return fallbackState;
 };
-
 const save = async state => {
-  const activeTabData = getActiveTab(state);
+  const requestedActiveTabData = getActiveTab(state);
+  const currentState = getLatestStoredState(state.uid, state, requestedActiveTabData?.tab.id, requestedActiveTabData?.tab.uri, !requestedActiveTabData);
+  const activeTabData = getActiveTab(currentState);
   if (!activeTabData) {
-    return state;
+    return currentState;
   }
   const {
     tab
   } = activeTabData;
   if (tab.loadingState === 'loading') {
-    return state;
+    return currentState;
   }
-  await saveEditor(tab.editorUid);
   if (!tab.isDirty) {
-    return state;
+    await saveEditor(tab.editorUid);
+    return getLatestStoredState(state.uid, currentState, tab.id, tab.uri);
   }
-  const editorState = await getEditorSaveState(tab.editorUid);
-  if (editorState.modified) {
-    return state;
+  const editorState = await saveEditor(tab.editorUid);
+  const latestState = getLatestStoredState(state.uid, currentState, tab.id, tab.uri);
+  if (editorState?.modified) {
+    return latestState;
   }
-  return updateTab(state, tab.id, {
+  if (tab.uri) {
+    await handleModifiedStatusChange$1(tab.uri, false);
+  }
+  const stateAfterModifiedStatusChange = getLatestStoredState(state.uid, latestState, tab.id, tab.uri);
+  return updateTab(stateAfterModifiedStatusChange, tab.id, {
     isDirty: false
   });
 };
 
 const getFilteredGroups = groups => {
-  return groups.map(group => ({
-    ...group,
-    tabs: group.tabs.filter(tab => !tab.uri?.startsWith('untitled://')).map(normalizeTabEditorInput)
-  })).filter(group => group.tabs.length > 0);
+  return groups.map(group => {
+    const tabs = group.tabs.filter(tab => !tab.uri?.startsWith('untitled://')).map(normalizeTabEditorInput);
+    const activeTabId = tabs.some(tab => tab.id === group.activeTabId) ? group.activeTabId : tabs[0]?.id;
+    return {
+      ...group,
+      activeTabId,
+      isEmpty: tabs.length === 0,
+      tabs
+    };
+  });
 };
 
 const saveState = state => {
@@ -5640,6 +5806,27 @@ const splitUp = (state, groupId) => {
 };
 
 const commandMap = {
+  'Main.closeActiveEditor': wrapCommand(closeActiveEditor),
+  'Main.closeAll': wrapCommand(closeAll$1),
+  'Main.closeAllEditors': wrapCommand(closeAll$1),
+  'Main.closeFocusedTab': wrapCommand(closeFocusedTab),
+  'Main.closeOthers': wrapCommand(closeOtherTabs),
+  'Main.closeSaved': wrapCommand(closeSaved$1),
+  'Main.closeTabsByUris': wrapCommand(closeTabsByUris),
+  'Main.closeTabsRight': wrapCommand(closeTabsRight),
+  'Main.copyPath': wrapCommand(copyPath$1),
+  'Main.copyRelativePath': wrapCommand(copyRelativePath$1),
+  'Main.focusNext': wrapCommand(focusNextTab),
+  'Main.focusNextTab': wrapCommand(focusNextTab),
+  'Main.focusPrevious': wrapCommand(focusPreviousTab),
+  'Main.focusPreviousTab': wrapCommand(focusPreviousTab),
+  'Main.handleModifiedStatusChange': wrapCommand(handleModifiedStatusChange),
+  'Main.handleTabContextMenu': wrapCommand(handleTabContextMenu),
+  'Main.openInput': wrapCommand(openInput),
+  'Main.openUri': wrapCommand(openUri),
+  'Main.openUris': wrapCommand(openUris),
+  'Main.save': wrapCommand(save),
+  'Main.splitRight': wrapCommand(splitRight),
   'MainArea.closeActiveEditor': wrapCommand(closeActiveEditor),
   'MainArea.closeAll': wrapCommand(closeAll$1),
   'MainArea.closeAllEditors': wrapCommand(closeAll$1),
@@ -5647,6 +5834,7 @@ const commandMap = {
   'MainArea.closeFocusedTab': wrapCommand(closeFocusedTab),
   'MainArea.closeOthers': wrapCommand(closeOtherTabs),
   'MainArea.closeSaved': wrapCommand(closeSaved$1),
+  'MainArea.closeTabsByUris': wrapCommand(closeTabsByUris),
   'MainArea.closeTabsRight': wrapCommand(closeTabsRight),
   'MainArea.copyPath': wrapCommand(copyPath$1),
   'MainArea.copyRelativePath': wrapCommand(copyRelativePath$1),