@lvce-editor/main-area-worker 9.41.0 → 9.42.0

package/dist/mainAreaWorkerMain.js

@@ -2951,6 +2951,7 @@ const getNextRequestId = () => {
 
 const getEditorInputEditorType = editorInput => {
   switch (editorInput.type) {
+    case 'binary':
     case 'diff-editor':
     case 'extension-detail-view':
     case 'image':
@@ -2966,6 +2967,8 @@ const getEditorInputEditorType = editorInput => {
 
 const getEditorInputUri = editorInput => {
   switch (editorInput.type) {
+    case 'binary':
+      return editorInput.uri;
     case 'diff-editor':
       return `diff://?left=${encodeURIComponent(editorInput.uriLeft)}&right=${encodeURIComponent(editorInput.uriRight)}`;
     case 'editor':
@@ -2984,6 +2987,7 @@ const getEditorInputUri = editorInput => {
 
 const imageExtensions = new Set(['.avif', '.bmp', '.gif', '.ico', '.jpeg', '.jpg', '.png', '.svg', '.tif', '.tiff', '.webp']);
 const videoExtensions = new Set(['.avi', '.m4v', '.mkv', '.mov', '.mp4', '.mpeg', '.mpg', '.ogv', '.webm']);
+const binaryFileSuffixes = ['.7z', '.apk', '.br', '.bz2', '.deb', '.gz', '.jar', '.pdf', '.rar', '.rpm', '.tar', '.tar.br', '.tar.bz2', '.tar.gz', '.tar.xz', '.tar.zst', '.tbr', '.tgz', '.war', '.xz', '.zip', '.zst'];
 const getPathEndIndex = pathName => {
   const queryIndex = pathName.indexOf('?');
   const hashIndex = pathName.indexOf('#');
@@ -3016,6 +3020,12 @@ const getLowerCaseExtension = uri => {
   }
   return cleanPath.slice(lastDotIndex).toLowerCase();
 };
+const hasBinaryFileSuffix = uri => {
+  const pathName = getPathName(uri);
+  const endIndex = getPathEndIndex(pathName);
+  const cleanPath = pathName.slice(0, endIndex).toLowerCase();
+  return binaryFileSuffixes.some(suffix => cleanPath.endsWith(suffix));
+};
 const getEditorInputFromUri = uri => {
   if (uri.startsWith('diff://?')) {
     try {
@@ -3066,6 +3076,12 @@ const getEditorInputFromUri = uri => {
       uri
     };
   }
+  if (hasBinaryFileSuffix(uri)) {
+    return {
+      type: 'binary',
+      uri
+    };
+  }
   return {
     type: 'editor',
     uri
@@ -3106,6 +3122,10 @@ const normalizeTabEditorInput = tab => {
     ...tab,
     editorInput,
     editorType: getEditorInputEditorType(editorInput),
+    ...(editorInput.type === 'binary' && {
+      editorUid: -1,
+      loadingState: 'binary'
+    }),
     uri
   };
 };
@@ -3240,6 +3260,8 @@ const QuickPick = 'QuickPick';
 
 const getViewletModuleIdForEditorInput = async editorInput => {
   switch (editorInput.type) {
+    case 'binary':
+      return undefined;
     case 'diff-editor':
       return DiffEditor;
     case 'editor':
@@ -3467,19 +3489,12 @@ const handleClickTogglePreview = async state => {
 };
 
 const CloseGroup = 'close-group';
+const OpenInTextEditor$1 = 'open-in-text-editor';
 const RetryOpen = 'retry-open';
 const RestoreClosedTab = 'restore-closed-tab';
 const SplitRight$1 = 'split-right';
 const TogglePreview$1 = 'toggle-preview';
 
-const parseRawGroupId = rawGroupId => {
-  if (!rawGroupId) {
-    return undefined;
-  }
-  const groupId = Number(rawGroupId);
-  return Number.isNaN(groupId) ? undefined : groupId;
-};
-
 const findTabByUri = (state, uri) => {
   const {
     layout
@@ -3499,192 +3514,6 @@ 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 => {
-  const {
-    closedTabs
-  } = state;
-  return {
-    ...state,
-    closedTabs: closedTabs.slice(0, -1)
-  };
-};
-const restoreExistingUri = (state, entry) => {
-  const {
-    layout
-  } = state;
-  const {
-    groups: layoutGroups
-  } = layout;
-  if (!entry.tab.uri) {
-    return undefined;
-  }
-  const existing = findTabByUri(state, entry.tab.uri);
-  if (!existing) {
-    return undefined;
-  }
-  const groupIndex = layoutGroups.findIndex(group => group.id === existing.groupId);
-  if (groupIndex === -1) {
-    return undefined;
-  }
-  const tabIndex = layoutGroups[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 {
-    layout
-  } = state;
-  const {
-    groups
-  } = 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 {
-    closedTabs
-  } = state;
-  const entry = 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;
-  }
-  const newState = await selectTab(restored.newState, restored.groupIndex, restored.tabIndex);
-  set(state.uid, state, newState);
-  return newState;
-};
-
 const focusEditorGroup = (state, groupId) => {
   const {
     layout
@@ -3800,6 +3629,8 @@ const getLabel = uri => {
 
 const getEditorInputTitle = editorInput => {
   switch (editorInput.type) {
+    case 'binary':
+      return getLabel(editorInput.uri);
     case 'diff-editor':
       {
         const leftTitle = getLabel(editorInput.uriLeft);
@@ -4033,6 +3864,7 @@ const getStateWithTab = (currentState, editorInput, existingTab, shouldRetryExis
     return {
       stateWithTab: updateTab(focusedState, existingTab.tab.id, {
         editorInput,
+        editorType,
         errorMessage: '',
         loadingState: 'loading',
         title,
@@ -4254,6 +4086,12 @@ const getActivePreviewEditorUid = state => {
   const activeTab = activeGroup?.tabs.find(tab => tab.id === activeGroup.activeTabId);
   return activeTab?.isPreview ? activeTab.editorUid : -1;
 };
+const shouldRetryExistingTab = (existingTab, editorInput) => {
+  if (!existingTab) {
+    return false;
+  }
+  return existingTab.tab.loadingState === 'error' || editorInput.type === 'editor' && editorInput.forceText === true && existingTab.tab.editorInput?.type === 'binary';
+};
 const openInputWithContext = async (context, options) => {
   const state = context.getState();
   object(state);
@@ -4267,8 +4105,8 @@ const openInputWithContext = async (context, options) => {
   const editorType = getEditorInputEditorType(editorInput);
   const currentState = state;
   const existingTab = options.reuseExisting === false ? undefined : findTabByUri(currentState, uri);
-  const shouldRetryExistingTab = !!existingTab && existingTab.tab.loadingState === 'error';
-  if (existingTab && !shouldRetryExistingTab) {
+  const shouldRetry = shouldRetryExistingTab(existingTab, editorInput);
+  if (existingTab && !shouldRetry) {
     const switchedState = getExistingTabState(currentState, existingTab, preview);
     await context.updateState(() => switchedState);
     return;
@@ -4278,7 +4116,7 @@ const openInputWithContext = async (context, options) => {
   const {
     stateWithTab,
     tabId
-  } = getStateWithTab(currentState, editorInput, existingTab, shouldRetryExistingTab, uri, preview, title, editorType);
+  } = getStateWithTab(currentState, editorInput, existingTab, shouldRetry, uri, preview, title, editorType);
   await context.updateState(() => stateWithTab);
   if (replacedEditorUid !== -1) {
     await disposeEditors([replacedEditorUid]);
@@ -4292,6 +4130,15 @@ const openInputWithContext = async (context, options) => {
     await context.updateState(() => errorState);
     return;
   }
+  if (editorInput.type === 'binary') {
+    const latestState = context.getState();
+    const binaryState = updateTab(latestState, tabId, {
+      editorUid: -1,
+      loadingState: 'binary'
+    });
+    await context.updateState(() => binaryState);
+    return;
+  }
   try {
     const viewletModuleId = await getViewletModuleIdForEditorInput(editorInput);
     const stateAfterModuleId = context.getState();
@@ -4369,6 +4216,220 @@ const openInput = async (state, options) => {
   return context.getState();
 };
 
+const openBinaryAsText = async state => {
+  const activeTabData = getActiveTab(state);
+  const editorInput = activeTabData?.tab.editorInput;
+  if (!activeTabData || editorInput?.type !== 'binary') {
+    return state;
+  }
+  const {
+    tab
+  } = activeTabData;
+  return openInput(state, {
+    editorInput: {
+      forceText: true,
+      type: 'editor',
+      uri: editorInput.uri
+    },
+    focus: false,
+    preview: tab.isPreview
+  });
+};
+
+const parseRawGroupId = rawGroupId => {
+  if (!rawGroupId) {
+    return undefined;
+  }
+  const groupId = Number(rawGroupId);
+  return Number.isNaN(groupId) ? undefined : groupId;
+};
+
+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 => {
+  const {
+    closedTabs
+  } = state;
+  return {
+    ...state,
+    closedTabs: closedTabs.slice(0, -1)
+  };
+};
+const restoreExistingUri = (state, entry) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups: layoutGroups
+  } = layout;
+  if (!entry.tab.uri) {
+    return undefined;
+  }
+  const existing = findTabByUri(state, entry.tab.uri);
+  if (!existing) {
+    return undefined;
+  }
+  const groupIndex = layoutGroups.findIndex(group => group.id === existing.groupId);
+  if (groupIndex === -1) {
+    return undefined;
+  }
+  const tabIndex = layoutGroups[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 {
+    layout
+  } = state;
+  const {
+    groups
+  } = 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 {
+    closedTabs
+  } = state;
+  const entry = 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;
+  }
+  const newState = await selectTab(restored.newState, restored.groupIndex, restored.tabIndex);
+  set(state.uid, state, newState);
+  return newState;
+};
+
 const getOptionUriOptions = options => {
   if (typeof options === 'string') {
     return options;
@@ -4660,6 +4721,8 @@ const handleClickAction = async (state, action, rawGroupId) => {
         }
         return closeEditorGroup$1(state, groupId);
       }
+    case OpenInTextEditor$1:
+      return openBinaryAsText(state);
     case RetryOpen:
       return retryOpen(state);
     case SplitRight$1:
@@ -5144,6 +5207,8 @@ const TextEditorLoading = 'TextEditor TextEditor--loading';
 const EditorContentLoading = 'EditorContent EditorContent--loading';
 const TextEditorError = 'TextEditor TextEditorError';
 const EditorContentError = 'EditorContent EditorContentError';
+const TextEditorBinary = 'TextEditor TextEditorError TextEditorBinary';
+const EditorContentBinary = 'EditorContent EditorContentError EditorContentBinary';
 const DragOverlay = 'DragOverlay';
 const Main = 'Main';
 const EDITOR_GROUPS_CONTAINER = 'editor-groups-container';
@@ -6184,6 +6249,8 @@ const CopyIntoNewWindow = 'Copy into New Window';
 const NewTextFile = 'New Text File';
 const NewWindow = 'New Window';
 const OpenFile = 'Open File';
+const OpenInTextEditor = 'Open in Text Editor';
+const BinaryFileNotDisplayed = 'The file is not displayed in the text editor because its contents are binary.';
 const SplitDown = 'Split Down';
 const SplitEditorGroup = 'Split Editor Group';
 const SplitLeft = 'Split Left';
@@ -6195,6 +6262,12 @@ const Retry = 'Retry';
 const openFile = () => {
   return i18nString(OpenFile);
 };
+const openInTextEditor = () => {
+  return i18nString(OpenInTextEditor);
+};
+const binaryFileNotDisplayed = () => {
+  return i18nString(BinaryFileNotDisplayed);
+};
 const splitUp = () => {
   return i18nString(SplitUp);
 };
@@ -7007,6 +7080,32 @@ const getDragOverlayVirtualDom = () => {
   return dragOverlayVirtualDom;
 };
 
+const textEditorBinaryNode = {
+  childCount: 1,
+  className: TextEditorBinary,
+  type: Div
+};
+const editorContentBinaryNode = {
+  childCount: 2,
+  className: EditorContentBinary,
+  type: Div
+};
+const paragraphNode$1 = {
+  childCount: 1,
+  type: P
+};
+const openInTextEditorButtonNode = {
+  childCount: 1,
+  className: mergeClassNames(Button, ButtonSecondary),
+  'data-action': OpenInTextEditor$1,
+  name: OpenInTextEditor$1,
+  onClick: HandleClickAction,
+  type: Button$2
+};
+const renderBinary = () => {
+  return [textEditorBinaryNode, editorContentBinaryNode, paragraphNode$1, text(binaryFileNotDisplayed()), openInTextEditorButtonNode, text(openInTextEditor())];
+};
+
 const textEditorNode = {
   childCount: 1,
   className: TextEditor,
@@ -7080,6 +7179,9 @@ const renderEditor = tab => {
   if (tab.loadingState === 'loading') {
     return renderLoading();
   }
+  if (tab.loadingState === 'binary') {
+    return renderBinary();
+  }
 
   // Viewlet is ready - render a reference node
   // Frontend will append the pre-created component at this position using the uid

package/package.json

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