@lvce-editor/main-area-worker 9.5.0 → 9.6.0

package/dist/mainAreaWorkerMain.js

@@ -2155,7 +2155,7 @@ const getNextRequestId = () => {
   return ++requestIdCounter;
 };
 
-const getViewletModuleId = async uri => {
+const getViewletModuleId$1 = async uri => {
   // Query RendererWorker for viewlet module ID (optional, may fail in tests)
   let viewletModuleId;
   try {
@@ -2175,7 +2175,7 @@ const getViewletModuleIdForEditorInput = async editorInput => {
     case 'diff-editor':
       return DiffEditor;
     case 'editor':
-      return getViewletModuleId(editorInput.uri);
+      return getViewletModuleId$1(editorInput.uri);
     case 'extension-detail-view':
       return ExtensionDetail;
   }
@@ -2222,6 +2222,93 @@ const getActiveTabId$1 = state => {
   const activeGroup = groups.find(g => g.id === activeGroupId);
   return activeGroup?.activeTabId;
 };
+const getSelectedTabData = (state, groupIndex, index) => {
+  const group = state.layout.groups[groupIndex];
+  if (!group || index < 0 || index >= group.tabs.length) {
+    return undefined;
+  }
+  const tab = group.tabs[index];
+  return {
+    group,
+    groupId: group.id,
+    tab,
+    tabId: tab.id
+  };
+};
+const getUpdatedGroups = (groups, groupIndex, needsLoading, tabId) => {
+  return groups.map((group, index) => {
+    if (index !== groupIndex) {
+      return {
+        ...group,
+        focused: false
+      };
+    }
+    const tabs = needsLoading ? group.tabs.map(tab => {
+      if (tab.id !== tabId) {
+        return tab;
+      }
+      return {
+        ...tab,
+        errorMessage: '',
+        loadingState: 'loading'
+      };
+    }) : group.tabs;
+    return {
+      ...group,
+      activeTabId: tabId,
+      focused: true,
+      tabs
+    };
+  });
+};
+const shouldCreateViewletForSelectedTab = tab => {
+  return Boolean(tab.uri) && (tab.editorUid === -1 || !tab.loadingState || tab.loadingState === 'loading');
+};
+const getSelectedTabBounds = state => {
+  return {
+    height: state.height - state.tabHeight,
+    width: state.width,
+    x: state.x,
+    y: state.y + state.tabHeight
+  };
+};
+const getViewletModuleId = async tab => {
+  return tab.editorInput ? getViewletModuleIdForEditorInput(tab.editorInput) : invoke('Layout.getModuleId', tab.uri);
+};
+const maybeStartLoading = async (state, newState, tabId, tab, needsLoading, requestId) => {
+  if (needsLoading && tab.uri) {
+    return startContentLoading(state, newState, tabId, tab.uri, requestId);
+  }
+  return newState;
+};
+const maybeCreateViewletForSelectedTab = async (state, newState, groupIndex, index, tabId, tab, uid, needsLoading, requestId, switchCommands) => {
+  const selectedTab = newState.layout.groups[groupIndex].tabs[index];
+  if (!shouldCreateViewletForSelectedTab(selectedTab)) {
+    return undefined;
+  }
+  const viewletModuleId = await getViewletModuleId(selectedTab);
+  if (!viewletModuleId) {
+    return undefined;
+  }
+  const bounds = getSelectedTabBounds(newState);
+  let stateWithViewlet = createViewletForTab(newState, tabId);
+  set(uid, state, stateWithViewlet);
+  if (switchCommands.length > 0) {
+    await executeViewletCommands(switchCommands);
+  }
+  const tabWithViewlet = findTabById(stateWithViewlet, tabId);
+  if (tabWithViewlet) {
+    const {
+      editorUid
+    } = tabWithViewlet.tab;
+    if (editorUid !== -1 && selectedTab.uri) {
+      await createViewlet(viewletModuleId, editorUid, tabId, bounds, selectedTab.uri);
+      stateWithViewlet = handleViewletReady(stateWithViewlet, editorUid);
+      set(uid, state, stateWithViewlet);
+    }
+  }
+  return maybeStartLoading(state, stateWithViewlet, tabId, tab, needsLoading, requestId);
+};
 const selectTab = async (state, groupIndex, index) => {
   const {
     layout,
@@ -2230,60 +2317,27 @@ const selectTab = async (state, groupIndex, index) => {
   const {
     groups
   } = layout;
-
-  // Validate indexes
   if (groupIndex < 0 || groupIndex >= groups.length) {
     return state;
   }
-  const group = groups[groupIndex];
-  if (index < 0 || index >= group.tabs.length) {
+  const selectedTabData = getSelectedTabData(state, groupIndex, index);
+  if (!selectedTabData) {
     return state;
   }
-  const tab = group.tabs[index];
-  const groupId = group.id;
-  const tabId = tab.id;
+  const {
+    group,
+    groupId,
+    tab,
+    tabId
+  } = selectedTabData;
   const isAlreadyActive = layout.activeGroupId === groupId && group.activeTabId === tabId;
-
-  // Allow restored tabs without a live editor to recover even if they are already selected.
   if (isAlreadyActive && !shouldLoadContentForTab(tab)) {
     return state;
   }
-
-  // Get previous active tab ID for viewlet switching
   getActiveTabId$1(state);
-
-  // Check if we need to load content for the newly selected tab
   const needsLoading = shouldLoadContentForTab(tab);
   const requestId = needsLoading ? getNextRequestId() : 0;
-
-  // Update the groups array with the new active tab and active group
-  // Also set loading state if needed
-  const updatedGroups = groups.map((g, i) => {
-    if (i !== groupIndex) {
-      return {
-        ...g,
-        focused: false
-      };
-    }
-
-    // This is the group being selected
-    const updatedTabs = needsLoading ? g.tabs.map(t => {
-      if (t.id === tabId) {
-        return {
-          ...t,
-          errorMessage: '',
-          loadingState: 'loading'
-        };
-      }
-      return t;
-    }) : g.tabs;
-    return {
-      ...g,
-      activeTabId: tabId,
-      focused: true,
-      tabs: updatedTabs
-    };
-  });
+  const updatedGroups = getUpdatedGroups(groups, groupIndex, needsLoading, tabId);
   let newState = {
     ...state,
     layout: {
@@ -2292,75 +2346,20 @@ const selectTab = async (state, groupIndex, index) => {
       groups: updatedGroups
     }
   };
-
-  // Switch viewlet: detach old, attach new (if ready)
   const {
     commands: switchCommands,
     newState: stateWithViewlet
   } = switchViewlet(newState);
   newState = stateWithViewlet;
-
-  // If new tab's viewlet isn't ready yet, trigger creation (idempotent)
-  const newTab = newState.layout.groups[groupIndex].tabs[index];
-  if (newTab.uri && (newTab.editorUid === -1 || !newTab.loadingState || newTab.loadingState === 'loading')) {
-    const viewletModuleId = newTab.editorInput ? await getViewletModuleIdForEditorInput(newTab.editorInput) : await invoke('Layout.getModuleId', newTab.uri);
-    if (viewletModuleId) {
-      // Calculate bounds: use main area bounds minus 35px for tab height
-      const TAB_HEIGHT = 35;
-      const bounds = {
-        height: newState.height - TAB_HEIGHT,
-        width: newState.width,
-        x: newState.x,
-        y: newState.y + TAB_HEIGHT
-      };
-      const createdState = createViewletForTab(newState, tabId);
-      newState = createdState;
-
-      // Store updated state before creating viewlet
-      set(uid, state, newState);
-
-      // Execute viewlet commands if any
-      if (switchCommands.length > 0) {
-        await executeViewletCommands(switchCommands);
-      }
-
-      // Get the tab to extract editorUid for viewlet creation
-      const tabWithViewlet = findTabById(newState, tabId);
-      if (tabWithViewlet) {
-        const {
-          editorUid
-        } = tabWithViewlet.tab;
-        if (editorUid !== -1 && newTab.uri) {
-          // Create the actual viewlet instance
-          await createViewlet(viewletModuleId, editorUid, tabId, bounds, newTab.uri);
-
-          // Mark viewlet as ready
-          newState = handleViewletReady(newState, editorUid);
-          set(uid, state, newState);
-        }
-      }
-
-      // Start loading content in the background if needed
-      if (needsLoading && tab.uri) {
-        const latestState = await startContentLoading(state, newState, tabId, tab.uri, requestId);
-        return latestState;
-      }
-      return newState;
-    }
+  const maybeCreatedState = await maybeCreateViewletForSelectedTab(state, newState, groupIndex, index, tabId, tab, uid, needsLoading, requestId, switchCommands);
+  if (maybeCreatedState) {
+    return maybeCreatedState;
   }
   set(uid, state, newState);
-
-  // Execute viewlet commands if any
   if (switchCommands.length > 0) {
     await executeViewletCommands(switchCommands);
   }
-
-  // Start loading content in the background if needed
-  if (needsLoading && tab.uri) {
-    const latestState = await startContentLoading(state, newState, tabId, tab.uri, requestId);
-    return latestState;
-  }
-  return newState;
+  return maybeStartLoading(state, newState, tabId, tab, needsLoading, requestId);
 };
 
 const focusNextTab = async state => {
@@ -2875,6 +2874,78 @@ const switchTab = (state, groupId, tabId) => {
   };
 };
 
+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) {
+    return undefined;
+  }
+  try {
+    const {
+      newFileIconCache
+    } = await getFileIconsForTabs([newTab.tab], readyState.fileIconCache);
+    const {
+      newState: stateBeforeIconUpdate
+    } = get(uid);
+    const icon = newFileIconCache[newTab.tab.uri] || '';
+    const stateWithIcon = {
+      ...stateBeforeIconUpdate,
+      fileIconCache: newFileIconCache,
+      layout: {
+        ...stateBeforeIconUpdate.layout,
+        groups: stateBeforeIconUpdate.layout.groups.map(group => ({
+          ...group,
+          tabs: group.tabs.map(tab => tab.id === tabId ? {
+            ...tab,
+            icon
+          } : tab)
+        }))
+      }
+    };
+    set(uid, state, stateWithIcon);
+    return stateWithIcon;
+  } catch {
+    return undefined;
+  }
+};
 const openInput = async (state, options) => {
   object(state);
   object(options);
@@ -2889,44 +2960,17 @@ const openInput = async (state, options) => {
   const title = getEditorInputTitle(editorInput);
   const editorType = getEditorInputEditorType(editorInput);
   const existingTab = findTabByUri(state, uri);
-  const shouldRetryExistingTab = existingTab && existingTab.tab.loadingState === 'error';
+  const shouldRetryExistingTab = !!existingTab && existingTab.tab.loadingState === 'error';
   if (existingTab && !shouldRetryExistingTab) {
     const focusedState = focusEditorGroup(state, existingTab.groupId);
     return switchTab(focusedState, existingTab.groupId, existingTab.tab.id);
   }
   const previousTabId = getActiveTabId(state);
-  const stateFromStore = get(uid);
-  let currentState;
-  if (stateFromStore) {
-    const storedState = stateFromStore.newState;
-    const storedTabCount = storedState.layout.groups.reduce((sum, group) => sum + group.tabs.length, 0);
-    const passedTabCount = state.layout.groups.reduce((sum, group) => sum + group.tabs.length, 0);
-    if (storedTabCount > passedTabCount) {
-      currentState = storedState;
-    } else {
-      currentState = state;
-      set(uid, state, state);
-    }
-  } else {
-    currentState = state;
-    set(uid, state, state);
-  }
-  let tabId;
-  let stateWithTab;
-  if (shouldRetryExistingTab && existingTab) {
-    const focusedState = focusEditorGroup(currentState, existingTab.groupId);
-    stateWithTab = updateTab(focusedState, existingTab.tab.id, {
-      editorInput,
-      errorMessage: '',
-      loadingState: 'loading',
-      title,
-      uri
-    });
-    tabId = existingTab.tab.id;
-  } else {
-    stateWithTab = ensureActiveGroup(currentState, uri, preview, title, editorType, editorInput);
-    tabId = getActiveTabId(stateWithTab);
-  }
+  const currentState = getCurrentState(state);
+  const {
+    stateWithTab,
+    tabId
+  } = getStateWithTab(currentState, editorInput, existingTab, shouldRetryExistingTab, uri, preview, title, editorType);
   set(uid, state, stateWithTab);
   try {
     const viewletModuleId = await getViewletModuleIdForEditorInput(editorInput);
@@ -2968,35 +3012,9 @@ const openInput = async (state, options) => {
     } = get(uid);
     const readyState = handleViewletReady(latestState, editorUid);
     set(uid, state, readyState);
-    try {
-      const newTab = findTabById(readyState, tabId);
-      if (newTab && newTab.tab.uri) {
-        const {
-          newFileIconCache
-        } = await getFileIconsForTabs([newTab.tab], readyState.fileIconCache);
-        const {
-          newState: stateBeforeIconUpdate
-        } = get(uid);
-        const icon = newFileIconCache[newTab.tab.uri] || '';
-        const stateWithIcon = {
-          ...stateBeforeIconUpdate,
-          fileIconCache: newFileIconCache,
-          layout: {
-            ...stateBeforeIconUpdate.layout,
-            groups: stateBeforeIconUpdate.layout.groups.map(group => ({
-              ...group,
-              tabs: group.tabs.map(tab => tab.id === tabId ? {
-                ...tab,
-                icon
-              } : tab)
-            }))
-          }
-        };
-        set(uid, state, stateWithIcon);
-        return stateWithIcon;
-      }
-    } catch {
-      // ignore
+    const stateWithIcon = await updateTabIcon(uid, state, readyState, tabId);
+    if (stateWithIcon) {
+      return stateWithIcon;
     }
     const {
       newState: finalState
@@ -3823,7 +3841,7 @@ 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(activeTab.uri);
+      const viewletModuleId = activeTab.editorInput ? await getViewletModuleIdForEditorInput(activeTab.editorInput) : await getViewletModuleId$1(activeTab.uri);
       if (viewletModuleId) {
         viewletModuleIds[activeTab.id] = viewletModuleId;
       }
@@ -5004,6 +5022,12 @@ const renderSingleEditorGroup = (layout, splitButtonEnabled, sizeProperty = 'wid
   }, ...renderEditorGroup(layout.groups[0], 0, splitButtonEnabled, sizeProperty)];
 };
 
+const getDirectionClassName = (direction, isSplit) => {
+  if (!isSplit) {
+    return '';
+  }
+  return direction === Horizontal ? EditorGroupsVertical : EditorGroupsHorizontal;
+};
 const getMainAreaVirtualDom = (layout, splitButtonEnabled = false, width = 0) => {
   const {
     direction,
@@ -5015,7 +5039,7 @@ const getMainAreaVirtualDom = (layout, splitButtonEnabled = false, width = 0) =>
   }
   const children = [];
   const isSplit = groups.length > 1;
-  const directionClassName = isSplit ? direction === Horizontal ? EditorGroupsVertical : EditorGroupsHorizontal : '';
+  const directionClassName = getDirectionClassName(direction, isSplit);
   const editorGroupsContainerClassName = directionClassName ? `${EDITOR_GROUPS_CONTAINER} ${directionClassName}` : EDITOR_GROUPS_CONTAINER;
   if (groups.length === 0) {
     return [{

package/package.json

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