@lvce-editor/main-area-worker 9.64.3 → 9.66.0

package/dist/mainAreaWorkerMain.js

@@ -662,6 +662,23 @@ const restoreMessageError = (error, _currentStack) => {
   }
   return restoredError;
 };
+const getFallbackMessage = error => {
+  if (error && typeof error.message === 'string' && error.message) {
+    return error.message;
+  }
+  if (error && error.data) {
+    return getFallbackMessage(error.data);
+  }
+  const stringified = String(error);
+  if (stringified !== '[object Object]') {
+    return stringified;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return stringified;
+  }
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
@@ -670,13 +687,13 @@ const restoreJsonRpcError = error => {
   if (error && error.code && error.code === MethodNotFound) {
     return restoreMethodNotFoundError(error, currentStack);
   }
+  if (error && error.error) {
+    return restoreJsonRpcError(error.error);
+  }
   if (error && error.message) {
     return restoreMessageError(error);
   }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
-  }
-  return new Error(`JsonRpc Error: ${error}`);
+  return new Error(`JsonRpc Error: ${getFallbackMessage(error)}`);
 };
 const unwrapJsonRpcResult = responseMessage => {
   if ('error' in responseMessage) {
@@ -1465,8 +1482,8 @@ const {
   invoke: invoke$5,
   set: set$5
 } = create$3(DragAndDropWorker);
-const getDroppedUrisByDropId = async (dropId, isElectron) => {
-  return invoke$5('DragAndDrop.getDroppedUrisByDropId', dropId, isElectron);
+const getDroppedItemsByDropId = async (dropId, isElectron) => {
+  return invoke$5('DragAndDrop.getDroppedItemsByDropId', dropId, isElectron);
 };
 
 const {
@@ -1628,7 +1645,7 @@ const addClosedTabs = (state, entries) => {
   if (entries.length === 0) {
     return state;
   }
-  void add(state.uid, entries);
+  void add(state.uid, entries.filter(entry => !entry.tab.terminal));
   return state;
 };
 
@@ -1786,7 +1803,7 @@ const getActiveFileUri = state => {
   } = layout;
   const activeGroup = groups.find(group => group.id === activeGroupId);
   const activeTab = activeGroup?.tabs.find(tab => tab.id === activeGroup.activeTabId);
-  if (!activeTab) {
+  if (!activeTab || activeTab.terminal) {
     return '';
   }
   if (typeof activeTab.uri === 'string') {
@@ -1821,7 +1838,7 @@ const getActiveTab = state => {
 
 const hasActiveTextEditor = state => {
   const activeTab = getActiveTab(state);
-  return activeTab?.tab.editorInput?.type === 'editor';
+  return !activeTab?.tab.terminal && activeTab?.tab.editorInput?.type === 'editor';
 };
 
 const notifyActiveEditorChange = async (oldState, newState) => {
@@ -2818,11 +2835,12 @@ const focus = async state => {
   if (typeof editorUid !== 'number' || editorUid < 0) {
     return state;
   }
+  const selector = activeTab?.tab.terminal ? '.xterm-helper-textarea' : '[name="editor"]';
   if (isConnected()) {
-    await invoke('Viewlet.focusSelector', editorUid, '[name="editor"]');
-    await invoke('Viewlet.focusSelectorAfterRender', editorUid, '[name="editor"]');
+    await invoke('Viewlet.focusSelector', editorUid, selector);
+    await invoke('Viewlet.focusSelectorAfterRender', editorUid, selector);
   } else {
-    await invoke$2('Viewlet.focusSelector', editorUid, '[name="editor"]');
+    await invoke$2('Viewlet.focusSelector', editorUid, selector);
   }
   return state;
 };
@@ -5005,7 +5023,7 @@ const getMaxFileSize = async () => {
   return defaultMaxFileSizeMb * bytesPerMegabyte;
 };
 const getLargeFileSize = async (editorInput, forceOpen = false, applicationId) => {
-  if (editorInput.type !== 'editor' || forceOpen || !editorInput.uri.startsWith('file://')) {
+  if (editorInput.type !== 'editor' || forceOpen) {
     return undefined;
   }
   try {
@@ -5468,6 +5486,15 @@ const shouldRetryExistingTab = (existingTab, editorInput, forceOpen) => {
   }
   return existingTab.tab.loadingState === 'error' || forceOpen && existingTab.tab.loadingState === 'large' || editorInput.type === 'editor' && editorInput.forceText === true && existingTab.tab.editorInput?.type === 'binary';
 };
+const getViewletArgs = options => {
+  if (options.forceOpen !== true || options.editorInput.type !== 'editor') {
+    return options.args;
+  }
+  return [{
+    ...options.args?.[0],
+    largeFile: true
+  }, ...(options.args?.slice(1) || [])];
+};
 const openInputWithContext = async (context, options) => {
   const state = context.getState();
   object(state);
@@ -5557,7 +5584,8 @@ const openInputWithContext = async (context, options) => {
     if (editorUid === -1) {
       throw new Error('invalid editorUid');
     }
-    await createViewletContent(viewletModuleId, editorUid, tabId, bounds, uri, options.args, state.applicationId);
+    const args = getViewletArgs(options);
+    await createViewletContent(viewletModuleId, editorUid, tabId, bounds, uri, args, state.applicationId);
     const latestState = context.getState();
     let readyState = handleViewletReady(latestState, editorUid);
     await context.updateState(() => readyState);
@@ -6399,6 +6427,114 @@ const resetPointerDown = state => {
   };
 };
 
+const parseTerminalDrag = strings => {
+  const value = strings.find(item => item.startsWith('lvce-terminal:'));
+  if (!value) {
+    return undefined;
+  }
+  try {
+    const data = JSON.parse(value.slice('lvce-terminal:'.length));
+    if (Number.isSafeInteger(data.sourceUid) && data.sourceUid > 0 && Number.isSafeInteger(data.terminalUid) && data.terminalUid > 0) {
+      return data;
+    }
+  } catch {
+    // Foreign or malformed drag data is not a terminal transfer.
+  }
+  return undefined;
+};
+const receiveTerminal = async (context, drag, targetGroupId) => {
+  const initial = context.getState();
+  const descriptor = await invoke$2('TerminalTransfer.takePanelTerminal', initial.uid, drag.sourceUid, drag.terminalUid);
+  if (!descriptor) {
+    return;
+  }
+  let tabId = -1;
+  try {
+    let state = context.getState();
+    if (targetGroupId !== undefined) {
+      state = focusEditorGroup(state, targetGroupId);
+    }
+    // Pin an existing preview so adoption never replaces and leaks its viewlet.
+    const activeId = getActiveTabId(state);
+    if (activeId !== undefined) {
+      state = updateTab(state, activeId, {
+        isPreview: false
+      });
+    }
+    state = ensureActiveGroup(state, `terminal://${drag.terminalUid}`, false, descriptor.label);
+    tabId = getActiveTabId(state);
+    state = updateTab(state, tabId, {
+      editorUid: drag.terminalUid,
+      icon: descriptor.icon,
+      loadingState: 'loaded',
+      terminal: true
+    });
+    const location = findTabById(state, tabId);
+    const bounds = getSelectedTabBounds(state, location.groupId);
+    await invoke$2('TerminalTransfer.resize', drag.terminalUid, bounds);
+    await context.updateState(() => state);
+    await invoke$1(state.applicationId, 'Layout.renderMainAreaPending', state.uid);
+    await focus(state);
+    await invoke$2('TerminalTransfer.commit', drag.terminalUid, initial.uid);
+  } catch (error) {
+    if (tabId !== -1) {
+      await context.updateState(state => {
+        const location = findTabById(state, tabId);
+        return location ? closeTab(state, location.groupId, tabId) : state;
+      });
+    }
+    try {
+      await invoke$1(initial.applicationId, 'Layout.renderMainAreaPending', initial.uid);
+    } finally {
+      await invoke$2('TerminalTransfer.rollback', drag.terminalUid);
+    }
+    throw error;
+  }
+};
+const releaseTerminal = async (context, terminalUid, panelUid) => {
+  const state = context.getState();
+  const group = state.layout.groups.find(item => item.tabs.some(tab => tab.terminal && tab.editorUid === terminalUid));
+  const tab = group?.tabs.find(item => item.terminal && item.editorUid === terminalUid);
+  if (!group || !tab) {
+    return;
+  }
+  const accepted = await invoke$2('TerminalTransfer.beginPanelTransfer', state.uid, panelUid, terminalUid);
+  if (!accepted) {
+    return;
+  }
+  try {
+    await context.updateState(latest => closeTab(latest, group.id, tab.id));
+    // Remove the old reference before reparenting the live DOM node.
+    await invoke$1(state.applicationId, 'Layout.renderMainAreaPending', state.uid);
+    await invoke$2('TerminalTransfer.attachPanelTerminal', state.uid, panelUid, terminalUid, tab.title, tab.icon);
+  } catch (error) {
+    const live = await invoke$2('TerminalTransfer.cancelPanelTransfer', terminalUid);
+    if (live) {
+      await context.updateState(latest => ({
+        ...latest,
+        layout: state.layout
+      }));
+      await invoke$1(state.applicationId, 'Layout.renderMainAreaPending', state.uid);
+    }
+    throw error;
+  }
+};
+const handleTerminalExit = (state, terminalUid) => {
+  const group = state.layout.groups.find(item => item.tabs.some(tab => tab.terminal && tab.editorUid === terminalUid));
+  const tab = group?.tabs.find(item => item.terminal && item.editorUid === terminalUid);
+  return group && tab ? closeTab(state, group.id, tab.id) : state;
+};
+const handlePanelDrop = async (context, panelUid, dropId) => {
+  const {
+    strings
+  } = await getDroppedItemsByDropId(dropId, false);
+  const drag = parseTerminalDrag(strings);
+  if (drag?.sourceUid !== context.getState().uid) {
+    return;
+  }
+  await releaseTerminal(context, drag.terminalUid, panelUid);
+};
+
 const openUrisWithContext = async (context, uris, reuseExisting = true) => {
   for (const uri of uris) {
     await openUriWithContext(context, {
@@ -6737,7 +6873,23 @@ const handleDrop = async (context, dropId) => {
     platform
   } = context.getState();
   const isElectron = platform === Electron;
-  const uris = await getDroppedUrisByDropId(dropId, isElectron);
+  const {
+    strings,
+    uris
+  } = await getDroppedItemsByDropId(dropId, isElectron);
+  const terminal = parseTerminalDrag(strings);
+  if (terminal) {
+    if (terminal.sourceUid === initialState.uid) {
+      const source = initialState.layout.groups.find(group => group.tabs.some(tab => tab.terminal && tab.editorUid === terminal.terminalUid));
+      const tab = source?.tabs.find(item => item.terminal && item.editorUid === terminal.terminalUid);
+      if (source && tab) {
+        await context.updateState(state => resetPointerDown(applyTabDrop(state, source.id, tab.id, splitDirection, tabDropIndicator?.groupId ?? targetGroupId, tabDropIndicator?.index)));
+      }
+    } else {
+      await receiveTerminal(context, terminal, tabDropIndicator?.groupId ?? targetGroupId);
+    }
+    return;
+  }
   if (draggedTab?.uri && uris.length === 1 && normalizeUri(uris[0]) === normalizeUri(draggedTab.uri)) {
     const tabTargetGroupId = tabDropIndicator?.groupId ?? targetGroupId;
     const tabTargetIndex = tabDropIndicator?.index;
@@ -8274,12 +8426,28 @@ const renderDragData = (oldState, newState) => {
     groups
   } = layout;
   if (pointerDownGroupIndex === -1 || pointerDownTabIndex === -1) {
-    return [];
+    const oldTab = oldState.layout.groups[oldState.pointerDownGroupIndex]?.tabs[oldState.pointerDownTabIndex];
+    return oldTab?.terminal ? ['Viewlet.setDragData', uid, {
+      items: [],
+      label: ''
+    }] : [];
   }
   const tab = groups[pointerDownGroupIndex]?.tabs[pointerDownTabIndex];
   if (!tab?.uri) {
     return [];
   }
+  if (tab.terminal) {
+    return ['Viewlet.setDragData', uid, {
+      items: [{
+        data: `lvce-terminal:${JSON.stringify({
+          sourceUid: uid,
+          terminalUid: tab.editorUid
+        })}`,
+        type: 'application/x-lvce-terminal'
+      }],
+      label: tab.title
+    }];
+  }
   const data = ensureUri(tab.uri);
   return ['Viewlet.setDragData', uid, {
     items: [{
@@ -8641,7 +8809,7 @@ const getSavedTab = tab => {
 };
 const getFilteredGroups = groups => {
   return groups.map(group => {
-    const tabs = group.tabs.filter(tab => !tab.uri?.startsWith('untitled://')).map(getSavedTab);
+    const tabs = group.tabs.filter(tab => !tab.terminal && !tab.uri?.startsWith('untitled://')).map(getSavedTab);
     const activeTabId = tabs.some(tab => tab.id === group.activeTabId) ? group.activeTabId : tabs[0]?.id ?? -1;
     return {
       ...group,
@@ -9010,6 +9178,7 @@ const commandMap = {
   'MainArea.handleIconThemeChange': wrapSerialCommand(handleIconThemeChange),
   'MainArea.handleMessagePort': handleDirectMessagePort,
   'MainArea.handleModifiedStatusChange': wrapAsyncCommand(handleModifiedStatusChangeWithContext),
+  'MainArea.handlePanelDrop': wrapSerialAsyncCommand(handlePanelDrop),
   'MainArea.handleResize': resize,
   'MainArea.handleSashCornerPointerDown': wrapSerialCommand(handleSashCornerPointerDown),
   'MainArea.handleSashCornerPointerMove': wrapSerialCommand(handleSashCornerPointerMove),
@@ -9023,6 +9192,7 @@ const commandMap = {
   'MainArea.handleTabMouseUp': wrapSerialCommand(resetPointerDown),
   'MainArea.handleTabsDragOver': wrapSerialCommand(handleTabsDragOver),
   'MainArea.handleTabsWheel': wrapSerialCommand(handleTabsWheel),
+  'MainArea.handleTerminalExit': wrapSerialCommand(handleTerminalExit),
   'MainArea.handleTestWorkerMessagePort': handleTestWorkerMessagePort,
   'MainArea.handleUriChange': wrapAsyncCommand(handleUriChangeWithContext),
   'MainArea.handleWorkspaceChange': wrapSerialCommand(handleWorkspaceChange),

package/package.json

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