@lvce-editor/main-area-worker 9.28.0 → 9.28.1

package/dist/mainAreaWorkerMain.js

@@ -2295,7 +2295,21 @@ const closeActiveEditor = async state => {
   return closeTabAndSave(state, focusedGroup.id, activeTabId);
 };
 
-const closeAll$1 = state => {
+const disposeEditors = async editorUids => {
+  // Dispose all child viewlets in the renderer worker
+  for (const editorUid of editorUids) {
+    try {
+      await invoke('Viewlet.dispose', editorUid);
+    } catch {
+      // Silently ignore errors during disposal
+      // Viewlet may already be disposed or renderer worker may not be available
+    }
+  }
+};
+
+const closeAll$1 = async state => {
+  const editorUids = state.layout.groups.flatMap(group => group.tabs.map(tab => tab.editorUid)).filter(editorUid => editorUid !== -1);
+  await disposeEditors(editorUids);
   const entries = state.layout.groups.flatMap((group, groupIndex) => {
     return group.tabs.map((tab, tabIndex) => ({
       group,
@@ -2671,6 +2685,7 @@ const getEditorInputEditorType = editorInput => {
     case 'process-explorer':
     case 'running-extensions':
     case 'video':
+    case 'webview':
       return 'custom';
     case 'editor':
       return 'text';
@@ -2684,6 +2699,7 @@ const getEditorInputUri = editorInput => {
     case 'editor':
     case 'image':
     case 'video':
+    case 'webview':
       return editorInput.uri;
     case 'extension-detail-view':
       return `extension-detail://${editorInput.extensionId}`;
@@ -2788,6 +2804,9 @@ const getNormalizedEditorInput = tab => {
     editorInput: tabEditorInput,
     uri: tabUri
   } = tab ?? {};
+  if (tabEditorInput?.type === 'editor' && tabEditorInput.forceText || tabEditorInput?.type === 'webview') {
+    return tabEditorInput;
+  }
   let uri;
   if (typeof tabUri === 'string') {
     uri = tabUri;
@@ -2916,11 +2935,11 @@ const getSelectedTabBounds = state => {
   };
 };
 
-const getViewletModuleId$1 = async uri => {
+const getViewletModuleId$1 = async (uri, opener) => {
   // Query RendererWorker for viewlet module ID (optional, may fail in tests)
   let viewletModuleId;
   try {
-    viewletModuleId = await invoke('Layout.getModuleId', uri);
+    viewletModuleId = opener === undefined ? await invoke('Layout.getModuleId', uri) : await invoke('Layout.getModuleId', uri, opener);
   } catch {
     // Viewlet creation is optional - silently ignore if RendererWorker isn't available
   }
@@ -2939,15 +2958,18 @@ const getViewletModuleIdForEditorInput = async editorInput => {
     case 'diff-editor':
       return DiffEditor;
     case 'editor':
+      return editorInput.forceText ? EditorText : getViewletModuleId$1(editorInput.uri);
+    case 'extension-detail-view':
+      return ExtensionDetail;
     case 'image':
     case 'video':
       return getViewletModuleId$1(editorInput.uri);
-    case 'extension-detail-view':
-      return ExtensionDetail;
     case 'process-explorer':
       return ProcessExplorer;
     case 'running-extensions':
       return RunningExtensions;
+    case 'webview':
+      return getViewletModuleId$1(editorInput.uri, editorInput.providerId);
   }
 };
 
@@ -3496,6 +3518,7 @@ const getEditorInputTitle = editorInput => {
     case 'editor':
     case 'image':
     case 'video':
+    case 'webview':
       return getLabel(editorInput.uri);
     case 'extension-detail-view':
       return editorInput.extensionId;
@@ -5203,7 +5226,7 @@ const copyPath = () => {
 const copyRelativePath = () => {
   return i18nString(CopyRelativePath);
 };
-const reopenEditorWith = () => {
+const reopenEditorWith$1 = () => {
   return i18nString(ReopenEditorWith);
 };
 const share = () => {
@@ -5370,10 +5393,10 @@ const getMenuEntries$1 = state => {
     id: 'copyRelativePath',
     label: copyRelativePath()
   }, menuEntrySeparator, {
-    command: '',
+    command: 'Main.reopenEditorWith',
     flags: None,
     id: 'reopenEditorWith',
-    label: reopenEditorWith()
+    label: reopenEditorWith$1()
   }, menuEntrySeparator, {
     command: '',
     flags: None,
@@ -6458,6 +6481,101 @@ const renderEventListeners = () => {
   }];
 };
 
+const getViewProviderEntries = async uri => {
+  const textEditorEntry = {
+    id: 'editor',
+    label: 'Text Editor',
+    type: 'editor'
+  };
+  try {
+    const providers = await invoke('WebView.getWebViews');
+    const matchingProviders = providers.filter(provider => provider?.id && provider.selector?.some(selector => uri.endsWith(selector)));
+    return [textEditorEntry, ...matchingProviders.map(provider => {
+      const titleElement = provider.elements?.find(element => element.type === 'title');
+      return {
+        id: provider.id,
+        label: provider.name || provider.title || titleElement?.value || provider.id,
+        type: 'webview'
+      };
+    })];
+  } catch {
+    return [textEditorEntry];
+  }
+};
+const reopenEditorWith = async context => {
+  const initialState = context.getState();
+  const {
+    activeGroupId,
+    groups
+  } = initialState.layout;
+  const activeGroup = groups.find(group => group.id === activeGroupId);
+  const initialTab = activeGroup?.tabs.find(tab => tab.id === activeGroup.activeTabId);
+  if (!initialTab?.uri) {
+    return;
+  }
+  const entries = await getViewProviderEntries(initialTab.uri);
+  const items = entries.map(entry => ({
+    description: '',
+    label: entry.label,
+    value: entry
+  }));
+  const selected = await invoke('ExtensionHostQuickPick.showQuickPick', {
+    items,
+    placeholder: 'Select Editor'
+  });
+  if (!selected) {
+    return;
+  }
+  const editorInput = selected.type === 'editor' ? {
+    forceText: true,
+    type: 'editor',
+    uri: initialTab.uri
+  } : {
+    providerId: selected.id,
+    type: 'webview',
+    uri: initialTab.uri
+  };
+  const viewletModuleId = await getViewletModuleIdForEditorInput(editorInput);
+  if (!viewletModuleId) {
+    return;
+  }
+  const latestState = context.getState();
+  const latestTab = findTabById(latestState, initialTab.id);
+  if (!latestTab) {
+    return;
+  }
+  const oldEditorUid = latestTab.tab.editorUid;
+  const resetState = updateTab(latestState, initialTab.id, {
+    editorInput,
+    editorType: getEditorInputEditorType(editorInput),
+    editorUid: -1,
+    errorMessage: undefined,
+    loadingState: undefined
+  });
+  const bounds = {
+    height: resetState.height - resetState.tabHeight,
+    width: resetState.width,
+    x: resetState.x,
+    y: resetState.y + resetState.tabHeight
+  };
+  const stateWithViewlet = createViewletForTab(resetState, initialTab.id);
+  await context.updateState(() => stateWithViewlet);
+  const tabWithViewlet = findTabById(stateWithViewlet, initialTab.id);
+  if (!tabWithViewlet || tabWithViewlet.tab.editorUid === -1) {
+    return;
+  }
+  const renderedTitle = await createViewlet(viewletModuleId, tabWithViewlet.tab.editorUid, initialTab.id, bounds, initialTab.uri);
+  const readyState = handleViewletReady(context.getState(), tabWithViewlet.tab.editorUid, renderedTitle);
+  await context.updateState(() => readyState);
+  if (oldEditorUid !== -1) {
+    try {
+      await invoke('Viewlet.dispose', oldEditorUid);
+    } catch {
+      // Reopening should still proceed if the previous viewlet was already disposed.
+    }
+  }
+};
+
 const getLatestStoredState = (uid, fallbackState, referenceTabId, referenceTabUri, allowMissingReference = false) => {
   const stateFromStore = get(uid);
   if (!stateFromStore) {
@@ -6940,6 +7058,7 @@ const commandMap = {
   'MainArea.refresh': wrapSerialCommand(refresh),
   'MainArea.render2': render2,
   'MainArea.renderEventListeners': renderEventListeners,
+  'MainArea.reopenEditorWith': wrapSerialAsyncCommand(reopenEditorWith),
   'MainArea.resize': wrapGetter(handleResize),
   'MainArea.restoreClosedTab': wrapSerialCommand(restoreClosedTab),
   'MainArea.save': wrapSerialCommand(save),

package/package.json

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