@lvce-editor/main-area-worker 9.14.0 → 9.15.0

package/dist/mainAreaWorkerMain.js

@@ -1474,6 +1474,16 @@ const writeClipBoardText = async text => {
   await invoke('ClipBoard.writeText', /* text */text);
 };
 
+const addClosedTabs = (state, entries) => {
+  if (entries.length === 0) {
+    return state;
+  }
+  return {
+    ...state,
+    closedTabs: [...state.closedTabs, ...entries].slice(-20)
+  };
+};
+
 const getGroupIndexById = (state, groupId) => {
   const {
     layout
@@ -1528,17 +1538,23 @@ const closeTab = (state, groupId, tabId) => {
     return state;
   }
   const group = groups[groupIndex];
+  const tabIndex = group.tabs.findIndex(tab => tab.id === tabId);
+
   // Check if the tab exists in the group
-  const tabWasRemoved = group.tabs.some(tab => tab.id === tabId);
-  if (!tabWasRemoved) {
+  if (tabIndex === -1) {
     return state;
   }
+  const stateWithClosedTab = addClosedTabs(state, [{
+    group,
+    groupIndex,
+    tab: group.tabs[tabIndex],
+    tabIndex
+  }]);
   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 {
@@ -1564,13 +1580,13 @@ const closeTab = (state, groupId, tabId) => {
     if (remainingGroups.length > 0) {
       const redistributedGroups = redistributeSizesWithRounding(remainingGroups);
       const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0]?.id : activeGroupId;
-      return withGroupsAndActiveGroup(state, redistributedGroups, newActiveGroupId);
+      return withGroupsAndActiveGroup(stateWithClosedTab, redistributedGroups, newActiveGroupId);
     }
 
     // If no remaining groups, return empty layout
-    return withEmptyGroups(state);
+    return withEmptyGroups(stateWithClosedTab);
   }
-  return withGroups(state, newGroups);
+  return withGroups(stateWithClosedTab, newGroups);
 };
 
 const findTabInState = (state, groupId, tabId) => {
@@ -1624,7 +1640,15 @@ const closeActiveEditor = async state => {
 };
 
 const closeAll$1 = state => {
-  return withEmptyGroups(state);
+  const entries = state.layout.groups.flatMap((group, groupIndex) => {
+    return group.tabs.map((tab, tabIndex) => ({
+      group,
+      groupIndex,
+      tab,
+      tabIndex
+    }));
+  });
+  return withEmptyGroups(addClosedTabs(state, entries));
 };
 
 const redistributeSizesWithRemainder = groups => {
@@ -1702,6 +1726,12 @@ const closeOtherTabs = (state, groupId) => {
   if (activeTabId === undefined) {
     return state;
   }
+  const closedTabs = group.tabs.map((tab, tabIndex) => ({
+    group,
+    groupIndex: groups.findIndex(g => g.id === targetGroupId),
+    tab,
+    tabIndex
+  })).filter(entry => entry.tab.id !== activeTabId);
   const newGroups = groups.map(g => {
     if (g.id === targetGroupId) {
       const newTabs = g.tabs.filter(tab => tab.id === activeTabId);
@@ -1715,7 +1745,7 @@ const closeOtherTabs = (state, groupId) => {
     return g;
   });
   return {
-    ...state,
+    ...addClosedTabs(state, closedTabs),
     layout: {
       ...layout,
       groups: newGroups
@@ -1757,8 +1787,16 @@ const closeSaved$1 = state => {
   const {
     groups
   } = state.layout;
+  const closedTabs = groups.flatMap((group, groupIndex) => {
+    return group.tabs.map((tab, tabIndex) => ({
+      group,
+      groupIndex,
+      tab,
+      tabIndex
+    })).filter(entry => !entry.tab.isDirty);
+  });
   const newGroups = groups.map(closeSavedInGroup);
-  return withGroups(state, newGroups);
+  return withGroups(addClosedTabs(state, closedTabs), newGroups);
 };
 
 const closeTabsByUris = (state, uris) => {
@@ -1811,6 +1849,13 @@ const closeTabsRight = (state, groupId) => {
   if (newTabs.length === tabs.length) {
     return state;
   }
+  const groupIndex = groups.findIndex(g => g.id === groupId);
+  const closedTabs = tabs.slice(activeTabIndex + 1).map((tab, index) => ({
+    group,
+    groupIndex,
+    tab,
+    tabIndex: activeTabIndex + index + 1
+  }));
   const newGroups = groups.map(g => {
     if (g.id === groupId) {
       return {
@@ -1821,7 +1866,7 @@ const closeTabsRight = (state, groupId) => {
     }
     return g;
   });
-  return withGroups(state, newGroups);
+  return withGroups(addClosedTabs(state, closedTabs), newGroups);
 };
 
 const copyPath$1 = async (state, path) => {
@@ -1869,6 +1914,7 @@ const {
 const create$2 = (uid, uri, x, y, width, height, platform, assetDir, tabHeight = 35) => {
   const state = {
     assetDir,
+    closedTabs: [],
     fileIconCache: {},
     height,
     iframes: [],
@@ -2017,8 +2063,101 @@ const getViewletModuleIdForEditorInput = async editorInput => {
   }
 };
 
+const getEditorInputEditorType = editorInput => {
+  switch (editorInput.type) {
+    case 'diff-editor':
+    case 'extension-detail-view':
+      return 'custom';
+    case 'editor':
+      return 'text';
+  }
+};
+
+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 getEditorInputFromUri = uri => {
+  if (uri.startsWith('diff://?')) {
+    try {
+      const parsed = new URL(uri);
+      const uriLeft = parsed.searchParams.get('left');
+      const uriRight = parsed.searchParams.get('right');
+      if (uriLeft && uriRight) {
+        return {
+          type: 'diff-editor',
+          uriLeft,
+          uriRight
+        };
+      }
+    } catch {
+      // Ignore malformed legacy URIs and fall back to a text editor input.
+    }
+  }
+  if (uri.startsWith('extension-detail://')) {
+    const extensionIdWithPath = uri.slice('extension-detail://'.length);
+    const extensionId = extensionIdWithPath.split('/')[0];
+    if (extensionId) {
+      return {
+        extensionId,
+        type: 'extension-detail-view'
+      };
+    }
+  }
+  return {
+    type: 'editor',
+    uri
+  };
+};
+const getNormalizedEditorInput = tab => {
+  const {
+    editorInput: tabEditorInput,
+    uri: tabUri
+  } = tab ?? {};
+  let uri;
+  if (typeof tabUri === 'string') {
+    uri = tabUri;
+  } else if (typeof tabEditorInput?.uri === 'string') {
+    const {
+      uri: tabEditorInputUri
+    } = tabEditorInput;
+    uri = tabEditorInputUri;
+  }
+  if (uri) {
+    const inferredEditorInput = getEditorInputFromUri(uri);
+    if (inferredEditorInput.type !== 'editor') {
+      return inferredEditorInput;
+    }
+  }
+  return tab?.editorInput;
+};
+const normalizeTabEditorInput = tab => {
+  const editorInput = getNormalizedEditorInput(tab);
+  if (!editorInput) {
+    return tab;
+  }
+  const uri = typeof tab?.uri === 'string' ? tab.uri : getEditorInputUri(editorInput);
+  return {
+    ...tab,
+    editorInput,
+    editorType: getEditorInputEditorType(editorInput),
+    uri
+  };
+};
+const getNormalizedOpenEditorInput = uri => {
+  return getEditorInputFromUri(uri);
+};
+
 const getViewletModuleId = async tab => {
-  return tab.editorInput ? getViewletModuleIdForEditorInput(tab.editorInput) : invoke('Layout.getModuleId', tab.uri);
+  const normalizedTab = normalizeTabEditorInput(tab);
+  return normalizedTab.editorInput ? getViewletModuleIdForEditorInput(normalizedTab.editorInput) : invoke('Layout.getModuleId', normalizedTab.uri);
 };
 
 const createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
@@ -2326,7 +2465,7 @@ const shouldCreateViewletForSelectedTab = tab => {
 };
 
 const maybeCreateViewletForSelectedTab = async (state, newState, groupIndex, index, tabId, tab, uid, needsLoading, requestId, switchCommands) => {
-  const selectedTab = newState.layout.groups[groupIndex].tabs[index];
+  const selectedTab = normalizeTabEditorInput(newState.layout.groups[groupIndex].tabs[index]);
   if (!shouldCreateViewletForSelectedTab(selectedTab)) {
     return undefined;
   }
@@ -2397,12 +2536,13 @@ const selectTab = async (state, groupIndex, index) => {
     tab,
     tabId
   } = selectedTabData;
+  const normalizedTab = normalizeTabEditorInput(tab);
   const isAlreadyActive = layout.activeGroupId === groupId && group.activeTabId === tabId;
-  if (isAlreadyActive && !shouldLoadContentForTab(tab)) {
+  if (isAlreadyActive && !shouldLoadContentForTab(normalizedTab)) {
     return state;
   }
   getActiveTabId$1(state);
-  const needsLoading = shouldLoadContentForTab(tab);
+  const needsLoading = shouldLoadContentForTab(normalizedTab);
   const requestId = needsLoading ? getNextRequestId() : 0;
   const updatedGroups = getUpdatedGroups(groups, groupIndex, needsLoading, tabId);
   let newState = {
@@ -2418,7 +2558,7 @@ const selectTab = async (state, groupIndex, index) => {
     newState: stateWithViewlet
   } = switchViewlet(newState);
   newState = stateWithViewlet;
-  const maybeCreatedState = await maybeCreateViewletForSelectedTab(state, newState, groupIndex, index, tabId, tab, uid, needsLoading, requestId, switchCommands);
+  const maybeCreatedState = await maybeCreateViewletForSelectedTab(state, newState, groupIndex, index, tabId, normalizedTab, uid, needsLoading, requestId, switchCommands);
   if (maybeCreatedState) {
     return maybeCreatedState;
   }
@@ -2426,7 +2566,7 @@ const selectTab = async (state, groupIndex, index) => {
   if (switchCommands.length > 0) {
     await executeViewletCommands(switchCommands);
   }
-  return maybeStartLoading(state, newState, tabId, tab, needsLoading, requestId);
+  return maybeStartLoading(state, newState, tabId, normalizedTab, needsLoading, requestId);
 };
 
 const focusNextTab = async state => {
@@ -2543,6 +2683,7 @@ const handleClickTogglePreview = async state => {
 
 const CloseGroup = 'close-group';
 const RetryOpen = 'retry-open';
+const RestoreClosedTab = 'restore-closed-tab';
 const SplitRight$1 = 'split-right';
 const TogglePreview$1 = 'toggle-preview';
 
@@ -2573,6 +2714,175 @@ const findTabByUri = (state, uri) => {
   return undefined;
 };
 
+const focusGroup = (groups, groupId, activeTabId) => {
+  return groups.map(group => {
+    if (group.id === groupId) {
+      return {
+        ...group,
+        activeTabId,
+        focused: true
+      };
+    }
+    return {
+      ...group,
+      focused: false
+    };
+  });
+};
+const clampIndex = (value, min, max) => {
+  return Math.min(Math.max(value, min), max);
+};
+const getRestoredTab = tab => {
+  return {
+    ...tab,
+    editorUid: -1,
+    errorMessage: '',
+    loadingState: undefined
+  };
+};
+const getStateWithoutLastClosedTab = state => {
+  return {
+    ...state,
+    closedTabs: state.closedTabs.slice(0, -1)
+  };
+};
+const restoreExistingUri = (state, entry) => {
+  if (!entry.tab.uri) {
+    return undefined;
+  }
+  const existing = findTabByUri(state, entry.tab.uri);
+  if (!existing) {
+    return undefined;
+  }
+  const groupIndex = state.layout.groups.findIndex(group => group.id === existing.groupId);
+  if (groupIndex === -1) {
+    return undefined;
+  }
+  const tabIndex = state.layout.groups[groupIndex].tabs.findIndex(tab => tab.id === existing.tab.id);
+  if (tabIndex === -1) {
+    return undefined;
+  }
+  const newStateWithoutClosedTab = getStateWithoutLastClosedTab(state);
+  const groups = focusGroup(newStateWithoutClosedTab.layout.groups, existing.groupId, existing.tab.id);
+  return {
+    groupIndex,
+    newState: {
+      ...newStateWithoutClosedTab,
+      layout: {
+        ...newStateWithoutClosedTab.layout,
+        activeGroupId: existing.groupId,
+        groups
+      }
+    },
+    tabIndex
+  };
+};
+const restoreIntoExistingGroup = (state, entry) => {
+  const {
+    groups
+  } = state.layout;
+  const groupIndex = groups.findIndex(group => group.id === entry.group.id);
+  if (groupIndex === -1) {
+    return undefined;
+  }
+  const restoredTab = getRestoredTab(entry.tab);
+  const group = groups[groupIndex];
+  const tabIndex = clampIndex(entry.tabIndex, 0, group.tabs.length);
+  const tabs = [...group.tabs];
+  tabs.splice(tabIndex, 0, restoredTab);
+  const newStateWithoutClosedTab = getStateWithoutLastClosedTab(state);
+  const updatedGroups = groups.map((currentGroup, index) => {
+    if (index === groupIndex) {
+      return {
+        ...currentGroup,
+        activeTabId: restoredTab.id,
+        focused: true,
+        isEmpty: false,
+        tabs
+      };
+    }
+    return {
+      ...currentGroup,
+      focused: false
+    };
+  });
+  return {
+    groupIndex,
+    newState: {
+      ...newStateWithoutClosedTab,
+      layout: {
+        ...newStateWithoutClosedTab.layout,
+        activeGroupId: group.id,
+        groups: updatedGroups
+      }
+    },
+    tabIndex
+  };
+};
+const createRestoredGroup = entry => {
+  return {
+    ...entry.group,
+    activeTabId: entry.tab.id,
+    focused: true,
+    isEmpty: false,
+    tabs: [getRestoredTab(entry.tab)]
+  };
+};
+const restoreIntoRecreatedGroup = (state, entry) => {
+  const newStateWithoutClosedTab = getStateWithoutLastClosedTab(state);
+  const restoredGroup = createRestoredGroup(entry);
+  const {
+    groups
+  } = newStateWithoutClosedTab.layout;
+  if (groups.length === 0) {
+    return {
+      groupIndex: 0,
+      newState: {
+        ...newStateWithoutClosedTab,
+        layout: {
+          ...newStateWithoutClosedTab.layout,
+          activeGroupId: restoredGroup.id,
+          groups: [restoredGroup]
+        }
+      },
+      tabIndex: 0
+    };
+  }
+  const groupIndex = clampIndex(entry.groupIndex, 0, groups.length);
+  const unfocusedGroups = groups.map(group => ({
+    ...group,
+    focused: false
+  }));
+  const insertedGroups = [...unfocusedGroups.slice(0, groupIndex), restoredGroup, ...unfocusedGroups.slice(groupIndex)];
+  return {
+    groupIndex,
+    newState: {
+      ...newStateWithoutClosedTab,
+      layout: {
+        ...newStateWithoutClosedTab.layout,
+        activeGroupId: restoredGroup.id,
+        groups: redistributeSizesWithRounding(insertedGroups)
+      }
+    },
+    tabIndex: 0
+  };
+};
+const restoreClosedTabState = state => {
+  const entry = state.closedTabs.at(-1);
+  if (!entry) {
+    return undefined;
+  }
+  return restoreExistingUri(state, entry) || restoreIntoExistingGroup(state, entry) || restoreIntoRecreatedGroup(state, entry);
+};
+
+const restoreClosedTab = async state => {
+  const restored = restoreClosedTabState(state);
+  if (!restored) {
+    return state;
+  }
+  return selectTab(restored.newState, restored.groupIndex, restored.tabIndex);
+};
+
 const focusEditorGroup = (state, groupId) => {
   const {
     layout
@@ -2627,16 +2937,6 @@ const getCurrentState = 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) {
@@ -2686,17 +2986,6 @@ const getEditorInputTitle = editorInput => {
   }
 };
 
-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
@@ -3158,62 +3447,6 @@ const getOptionUriOptions = options => {
   return options.uri;
 };
 
-const getEditorInputFromUri = uri => {
-  if (uri.startsWith('diff://?')) {
-    try {
-      const parsed = new URL(uri);
-      const uriLeft = parsed.searchParams.get('left');
-      const uriRight = parsed.searchParams.get('right');
-      if (uriLeft && uriRight) {
-        return {
-          type: 'diff-editor',
-          uriLeft,
-          uriRight
-        };
-      }
-    } catch {
-      // Ignore malformed legacy URIs and fall back to a text editor input.
-    }
-  }
-  if (uri.startsWith('extension-detail://')) {
-    const extensionIdWithPath = uri.slice('extension-detail://'.length);
-    const extensionId = extensionIdWithPath.split('/')[0];
-    if (extensionId) {
-      return {
-        extensionId,
-        type: 'extension-detail-view'
-      };
-    }
-  }
-  return {
-    type: 'editor',
-    uri
-  };
-};
-const getNormalizedEditorInput = tab => {
-  if (typeof tab?.uri === 'string') {
-    const inferredEditorInput = getEditorInputFromUri(tab.uri);
-    if (inferredEditorInput.type !== 'editor') {
-      return inferredEditorInput;
-    }
-  }
-  return tab?.editorInput;
-};
-const normalizeTabEditorInput = tab => {
-  const editorInput = getNormalizedEditorInput(tab);
-  if (!editorInput) {
-    return tab;
-  }
-  return {
-    ...tab,
-    editorInput,
-    editorType: getEditorInputEditorType(editorInput)
-  };
-};
-const getNormalizedOpenEditorInput = uri => {
-  return getEditorInputFromUri(uri);
-};
-
 const openUri = async (state, options) => {
   const uri = getOptionUriOptions(options);
   const preview = typeof options === 'string' ? false : options.preview ?? false;
@@ -3445,6 +3678,9 @@ const handleClickAction = async (state, action, rawGroupId) => {
   if (!action) {
     return state;
   }
+  if (action === RestoreClosedTab) {
+    return restoreClosedTab(state);
+  }
   if (activeGroupId === undefined) {
     return state;
   }
@@ -4141,7 +4377,12 @@ const getViewletModuleIds = async layout => {
     } = group;
     const activeTab = tabs.find(tab => tab.id === group.activeTabId);
     if (activeTab && (activeTab.editorInput || activeTab.uri)) {
-      const viewletModuleId = activeTab.editorInput ? await getViewletModuleIdForEditorInput(activeTab.editorInput) : await getViewletModuleId$1(activeTab.uri);
+      const normalizedTab = normalizeTabEditorInput(activeTab);
+      const {
+        editorInput,
+        uri
+      } = normalizedTab;
+      const viewletModuleId = normalizedTab.editorInput ? await getViewletModuleIdForEditorInput(editorInput) : await getViewletModuleId$1(uri);
       if (viewletModuleId) {
         viewletModuleIds[activeTab.id] = viewletModuleId;
       }
@@ -5833,7 +6074,9 @@ const commandMap = {
   'Main.openInput': wrapCommand(openInput),
   'Main.openUri': wrapCommand(openUri),
   'Main.openUris': wrapCommand(openUris),
+  'Main.restoreClosedTab': wrapCommand(restoreClosedTab),
   'Main.save': wrapCommand(save),
+  'Main.saveState': wrapGetter(saveState),
   'Main.splitRight': wrapCommand(splitRight),
   'MainArea.closeActiveEditor': wrapCommand(closeActiveEditor),
   'MainArea.closeAll': wrapCommand(closeAll$1),
@@ -5884,6 +6127,7 @@ const commandMap = {
   'MainArea.render2': render2,
   'MainArea.renderEventListeners': renderEventListeners,
   'MainArea.resize': wrapGetter(handleResize),
+  'MainArea.restoreClosedTab': wrapCommand(restoreClosedTab),
   'MainArea.save': wrapCommand(save),
   'MainArea.saveState': wrapGetter(saveState),
   'MainArea.selectTab': wrapCommand(selectTab),

package/package.json

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