@lvce-editor/main-area-worker 8.22.0 → 9.1.0

package/dist/mainAreaWorkerMain.js

@@ -2153,35 +2153,62 @@ const getNextRequestId = () => {
   return ++requestIdCounter;
 };
 
-const startContentLoading = async (oldState, state, tabId, path, requestId) => {
+const getViewletModuleId = async uri => {
+  // Query RendererWorker for viewlet module ID (optional, may fail in tests)
+  let viewletModuleId;
   try {
-    const getLatestState = () => {
-      return get(state.uid).newState;
-    };
-    set(state.uid, oldState, state);
-    const newState = await loadTabContentAsync(tabId, path, requestId, getLatestState);
-    return newState;
+    viewletModuleId = await invoke('Layout.getModuleId', uri);
   } catch {
-    // Silently ignore errors - the tab may have been closed or the component unmounted
+    // Viewlet creation is optional - silently ignore if RendererWorker isn't available
   }
-  return state;
+  return viewletModuleId;
 };
 
-const shouldLoadContent = tab => {
-  // Load if:
-  // - Has a path (file-based tab)
-  // - Not already loaded or currently loading
+const DiffEditor = 'DiffEditor';
+const ExtensionDetail = 'ExtensionDetail';
+const QuickPick = 'QuickPick';
+
+const getViewletModuleIdForEditorInput = async editorInput => {
+  switch (editorInput.type) {
+    case 'diff-editor':
+      return DiffEditor;
+    case 'editor':
+      return getViewletModuleId(editorInput.uri);
+    case 'extension-detail-view':
+      return ExtensionDetail;
+  }
+};
+
+const shouldLoadContentForTab = tab => {
+  if (tab.editorInput && tab.editorInput.type !== 'editor') {
+    return false;
+  }
   if (!tab.uri) {
     return false;
   }
   if (tab.loadingState === 'loading') {
     return false;
   }
-  if (tab.loadingState === 'loaded') {
+  if (tab.loadingState === 'loaded' && tab.editorUid !== -1) {
     return false;
   }
   return true;
 };
+
+const startContentLoading = async (oldState, state, tabId, path, requestId) => {
+  try {
+    const getLatestState = () => {
+      return get(state.uid).newState;
+    };
+    set(state.uid, oldState, state);
+    const newState = await loadTabContentAsync(tabId, path, requestId, getLatestState);
+    return newState;
+  } catch {
+    // Silently ignore errors - the tab may have been closed or the component unmounted
+  }
+  return state;
+};
+
 const getActiveTabId$1 = state => {
   const {
     layout
@@ -2213,9 +2240,10 @@ const selectTab = async (state, groupIndex, index) => {
   const tab = group.tabs[index];
   const groupId = group.id;
   const tabId = tab.id;
+  const isAlreadyActive = layout.activeGroupId === groupId && group.activeTabId === tabId;
 
-  // Return same state if this group and tab are already active
-  if (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;
   }
 
@@ -2223,7 +2251,7 @@ const selectTab = async (state, groupIndex, index) => {
   getActiveTabId$1(state);
 
   // Check if we need to load content for the newly selected tab
-  const needsLoading = shouldLoadContent(tab);
+  const needsLoading = shouldLoadContentForTab(tab);
   const requestId = needsLoading ? getNextRequestId() : 0;
 
   // Update the groups array with the new active tab and active group
@@ -2272,10 +2300,8 @@ const selectTab = async (state, groupIndex, index) => {
 
   // If new tab's viewlet isn't ready yet, trigger creation (idempotent)
   const newTab = newState.layout.groups[groupIndex].tabs[index];
-  if (newTab.uri && (!newTab.loadingState || newTab.loadingState === 'loading')) {
-    // Query RendererWorker for viewlet module ID
-
-    const viewletModuleId = await invoke('Layout.getModuleId', newTab.uri);
+  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;
@@ -2459,6 +2485,14 @@ const getBasename$1 = uri => {
   }
   return uri.slice(lastSlashIndex + 1);
 };
+const inlineDiffPrefix = 'inline-diff://';
+const diffSeparator = '<->';
+const getInlineDiffLabel = uri => {
+  const content = uri.slice(inlineDiffPrefix.length);
+  const separatorIndex = content.indexOf(diffSeparator);
+  const workingTreeUri = separatorIndex === -1 ? content : content.slice(separatorIndex + diffSeparator.length);
+  return `${getBasename$1(workingTreeUri)} (Working Tree)`;
+};
 const getLabel = uri => {
   if (uri.startsWith('settings://')) {
     return 'Settings';
@@ -2472,10 +2506,13 @@ const getLabel = uri => {
   if (uri.startsWith('language-models://')) {
     return 'Language Models';
   }
+  if (uri.startsWith(inlineDiffPrefix)) {
+    return getInlineDiffLabel(uri);
+  }
   return getBasename$1(uri);
 };
 
-const createEmptyGroup = (state, uri, requestId, preview = false) => {
+const createEmptyGroup = (state, uri, requestId, preview = false, title = getLabel(uri), editorType = 'text', editorInput) => {
   const {
     layout
   } = state;
@@ -2483,11 +2520,11 @@ const createEmptyGroup = (state, uri, requestId, preview = false) => {
     groups
   } = layout;
   const groupId = create$1();
-  const title = getLabel(uri);
   const tabId = create$1();
   const editorUid = create$1();
   const newTab = {
-    editorType: 'text',
+    editorInput,
+    editorType,
     editorUid,
     errorMessage: '',
     icon: '',
@@ -2553,7 +2590,7 @@ const openTab = (state, groupId, tab) => {
   };
 };
 
-const ensureActiveGroup = (state, uri, preview = false) => {
+const ensureActiveGroup = (state, uri, preview = false, title = getLabel(uri), editorType = 'text', editorInput) => {
   // Find the active group (by activeGroupId or focused flag)
   const {
     layout
@@ -2572,7 +2609,6 @@ const ensureActiveGroup = (state, uri, preview = false) => {
   if (activeGroup) {
     const activeTab = activeGroup.tabs.find(tab => tab.id === activeGroup.activeTabId);
     if (activeTab?.isPreview) {
-      const title = getLabel(uri);
       const updatedGroups = groups.map(group => {
         if (group.id !== activeGroup.id) {
           return group;
@@ -2583,6 +2619,8 @@ const ensureActiveGroup = (state, uri, preview = false) => {
           }
           return {
             ...tab,
+            editorInput,
+            editorType,
             errorMessage: '',
             icon: '',
             isDirty: false,
@@ -2609,11 +2647,11 @@ const ensureActiveGroup = (state, uri, preview = false) => {
     }
 
     // Create a new tab with the URI in the active group
-    const title = getLabel(uri);
     const tabId = create$1();
     const editorUid = create$1();
     const newTab = {
-      editorType: 'text',
+      editorInput,
+      editorType,
       editorUid,
       errorMessage: '',
       icon: '',
@@ -2627,7 +2665,7 @@ const ensureActiveGroup = (state, uri, preview = false) => {
     };
     newState = openTab(state, activeGroup.id, newTab);
   } else {
-    newState = createEmptyGroup(state, uri, requestId, preview);
+    newState = createEmptyGroup(state, uri, requestId, preview, title, editorType, editorInput);
   }
   return newState;
 };
@@ -2684,6 +2722,42 @@ const getActiveTabId = state => {
   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]);
 };
@@ -2771,24 +2845,6 @@ const getFileIconsForTabs = async (tabs, fileIconCache) => {
   };
 };
 
-const getOptionUriOptions = options => {
-  if (typeof options === 'string') {
-    return options;
-  }
-  return options.uri;
-};
-
-const getViewletModuleId = async uri => {
-  // Query RendererWorker for viewlet module ID (optional, may fail in tests)
-  let viewletModuleId;
-  try {
-    viewletModuleId = await invoke('Layout.getModuleId', uri);
-  } catch {
-    // Viewlet creation is optional - silently ignore if RendererWorker isn't available
-  }
-  return viewletModuleId;
-};
-
 const switchTab = (state, groupId, tabId) => {
   const {
     layout
@@ -2817,46 +2873,39 @@ const switchTab = (state, groupId, tabId) => {
   };
 };
 
-const openUri = async (state, options) => {
+const openInput = async (state, options) => {
   object(state);
+  object(options);
   const {
     uid
   } = state;
-  const uri = getOptionUriOptions(options);
-  const preview = typeof options === 'string' ? false : options.preview ?? false;
-
-  // Check if a tab with this URI already exists in the passed-in state
+  const {
+    editorInput
+  } = options;
+  const preview = options.preview ?? false;
+  const uri = getEditorInputUri(editorInput);
+  const title = getEditorInputTitle(editorInput);
+  const editorType = getEditorInputEditorType(editorInput);
   const existingTab = findTabByUri(state, uri);
   const shouldRetryExistingTab = existingTab && existingTab.tab.loadingState === 'error';
   if (existingTab && !shouldRetryExistingTab) {
-    // Tab exists, switch to it and focus its group
     const focusedState = focusEditorGroup(state, existingTab.groupId);
     return switchTab(focusedState, existingTab.groupId, existingTab.tab.id);
   }
-
-  // Get previous active tab ID for viewlet switching
   const previousTabId = getActiveTabId(state);
-
-  // Check if there's existing state in the global store
   const stateFromStore = get(uid);
   let currentState;
   if (stateFromStore) {
     const storedState = stateFromStore.newState;
-    // Use the stored state if it has more tabs than the passed-in state
-    // (indicating concurrent calls have already added tabs)
-    // Otherwise use the passed-in state (test setup with initial data)
-    const storedTabCount = storedState.layout.groups.reduce((sum, g) => sum + g.tabs.length, 0);
-    const passedTabCount = state.layout.groups.reduce((sum, g) => sum + g.tabs.length, 0);
+    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) {
-      // Stored state has more tabs - concurrent calls have added tabs
       currentState = storedState;
     } else {
-      // Passed-in state has same or more tabs, use it (likely fresh test setup)
       currentState = state;
       set(uid, state, state);
     }
   } else {
-    // No state in store yet, register the passed-in state
     currentState = state;
     set(uid, state, state);
   }
@@ -2865,22 +2914,20 @@ const openUri = async (state, options) => {
   if (shouldRetryExistingTab && existingTab) {
     const focusedState = focusEditorGroup(currentState, existingTab.groupId);
     stateWithTab = updateTab(focusedState, existingTab.tab.id, {
+      editorInput,
       errorMessage: '',
-      loadingState: 'loading'
+      loadingState: 'loading',
+      title,
+      uri
     });
     tabId = existingTab.tab.id;
   } else {
-    // Add tab to state BEFORE any async calls to prevent race conditions
-    stateWithTab = ensureActiveGroup(currentState, uri, preview);
+    stateWithTab = ensureActiveGroup(currentState, uri, preview, title, editorType, editorInput);
     tabId = getActiveTabId(stateWithTab);
   }
-
-  // Save state immediately after adding tab or retrying
   set(uid, state, stateWithTab);
   try {
-    const viewletModuleId = await getViewletModuleId(uri);
-
-    // After async call, get the latest state to account for any concurrent changes
+    const viewletModuleId = await getViewletModuleIdForEditorInput(editorInput);
     const {
       newState: stateAfterModuleId
     } = get(uid);
@@ -2890,8 +2937,6 @@ const openUri = async (state, options) => {
         loadingState: 'error'
       });
     }
-
-    // Calculate bounds: use main area bounds minus tab height
     const bounds = {
       height: stateAfterModuleId.height - stateAfterModuleId.tabHeight,
       width: stateAfterModuleId.width,
@@ -2899,55 +2944,38 @@ const openUri = async (state, options) => {
       y: stateAfterModuleId.y + stateAfterModuleId.tabHeight
     };
     const stateWithViewlet = createViewletForTab(stateAfterModuleId, tabId, viewletModuleId, bounds);
-    let intermediateState1 = stateWithViewlet;
-
-    // Switch viewlet (detach old, attach new if ready)
+    let intermediateState = stateWithViewlet;
     const {
       newState: switchedState
-    } = switchViewlet(intermediateState1, previousTabId, tabId);
-    intermediateState1 = switchedState;
-    set(uid, state, intermediateState1);
-
-    // Get the tab to extract editorUid
-    const tabWithViewlet = findTabById(intermediateState1, tabId);
+    } = switchViewlet(intermediateState, previousTabId, tabId);
+    intermediateState = switchedState;
+    set(uid, state, intermediateState);
+    const tabWithViewlet = findTabById(intermediateState, tabId);
     if (!tabWithViewlet) {
-      return intermediateState1;
+      return intermediateState;
     }
     const {
       editorUid
     } = tabWithViewlet.tab;
     if (editorUid === -1) {
-      throw new Error(`invalid editorUid`);
+      throw new Error('invalid editorUid');
     }
     await createViewlet(viewletModuleId, editorUid, tabId, bounds, uri);
-
-    // After viewlet is created, get the latest state and mark it as ready
-    // This ensures we have any state updates that occurred during viewlet creation
     const {
       newState: latestState
     } = get(uid);
-
-    // Attachment is handled automatically by virtual DOM reference nodes
     const readyState = handleViewletReady(latestState, editorUid);
-
-    // Save state before async icon request
     set(uid, state, readyState);
-
-    // Request file icon for the newly opened tab
     try {
       const newTab = findTabById(readyState, tabId);
       if (newTab && newTab.tab.uri) {
         const {
           newFileIconCache
         } = await getFileIconsForTabs([newTab.tab], readyState.fileIconCache);
-
-        // After async call, get the latest state again
         const {
           newState: stateBeforeIconUpdate
         } = get(uid);
         const icon = newFileIconCache[newTab.tab.uri] || '';
-
-        // Update the tab with the icon in the latest state
         const stateWithIcon = {
           ...stateBeforeIconUpdate,
           fileIconCache: newFileIconCache,
@@ -2962,16 +2990,12 @@ const openUri = async (state, options) => {
             }))
           }
         };
-
-        // Save the state with icon update so concurrent calls can see it
         set(uid, state, stateWithIcon);
         return stateWithIcon;
       }
     } catch {
-      // If icon request fails, continue without icon
+      // ignore
     }
-
-    // Get final latest state
     const {
       newState: finalState
     } = get(uid);
@@ -2990,6 +3014,26 @@ const openUri = async (state, options) => {
   }
 };
 
+const getOptionUriOptions = options => {
+  if (typeof options === 'string') {
+    return options;
+  }
+  return options.uri;
+};
+
+const openUri = async (state, options) => {
+  const uri = getOptionUriOptions(options);
+  const preview = typeof options === 'string' ? false : options.preview ?? false;
+  return openInput(state, {
+    editorInput: {
+      type: 'editor',
+      uri
+    },
+    focu: typeof options === 'string' ? false : options.focu,
+    preview
+  });
+};
+
 const retryOpen = async state => {
   const activeTabData = getActiveTab(state);
   if (!activeTabData) {
@@ -2998,6 +3042,13 @@ const retryOpen = async state => {
   const {
     tab
   } = activeTabData;
+  if (tab.editorInput) {
+    return openInput(state, {
+      editorInput: tab.editorInput,
+      focu: false,
+      preview: tab.isPreview
+    });
+  }
   if (!tab.uri) {
     return state;
   }
@@ -3693,6 +3744,19 @@ const isValidMainAreaLayout = layout => {
   return true;
 };
 
+const normalizeRestoredTab = tab => {
+  const {
+    errorMessage: _errorMessage,
+    loadingState: _loadingState,
+    ...rest
+  } = tab ?? {};
+  return {
+    ...rest,
+    editorUid: -1,
+    isDirty: false,
+    isPreview: typeof tab?.isPreview === 'boolean' ? tab.isPreview : false
+  };
+};
 const tryRestoreLayout = savedState => {
   if (savedState === undefined || savedState === null) {
     return undefined;
@@ -3727,12 +3791,7 @@ const tryRestoreLayout = savedState => {
         ...(groupDirection === undefined ? {} : {
           direction: groupDirection
         }),
-        tabs: Array.isArray(group?.tabs) ? group.tabs.map(tab => ({
-          ...tab,
-          editorUid: -1,
-          isDirty: false,
-          isPreview: typeof tab?.isPreview === 'boolean' ? tab.isPreview : false
-        })) : []
+        tabs: Array.isArray(group?.tabs) ? group.tabs.map(normalizeRestoredTab) : []
       };
     })
   };
@@ -3762,8 +3821,8 @@ const getViewletModuleIds = async layout => {
       tabs
     } = group;
     const activeTab = tabs.find(tab => tab.id === group.activeTabId);
-    if (activeTab && activeTab.uri) {
-      const viewletModuleId = await getViewletModuleId(activeTab.uri);
+    if (activeTab && (activeTab.editorInput || activeTab.uri)) {
+      const viewletModuleId = activeTab.editorInput ? await getViewletModuleIdForEditorInput(activeTab.editorInput) : await getViewletModuleId(activeTab.uri);
       if (viewletModuleId) {
         viewletModuleIds[activeTab.id] = viewletModuleId;
       }
@@ -4006,8 +4065,6 @@ const menuEntrySeparator = {
   label: ''
 };
 
-const QuickPick = 'QuickPick';
-
 const getArgs = groupId => {
   if (groupId === undefined) {
     return undefined;
@@ -5258,6 +5315,7 @@ const commandMap = {
   'MainArea.initialize': initialize,
   'MainArea.loadContent': wrapCommand(loadContent),
   'MainArea.newFile': wrapCommand(newFile),
+  'MainArea.openInput': wrapCommand(openInput),
   'MainArea.openUri': wrapCommand(openUri),
   'MainArea.openUris': wrapCommand(openUris),
   'MainArea.refresh': wrapCommand(refresh),

package/package.json

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