@lvce-editor/main-area-worker 1.9.0 → 1.11.0

package/dist/mainAreaWorkerMain.js

@@ -96,6 +96,12 @@ const object = value => {
     throw new AssertionError('expected value to be of type object');
   }
 };
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
 
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
@@ -450,7 +456,7 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1 = 3;
-const create$5 = async ({
+const create$5$1 = async ({
   isMessagePortOpen,
   messagePort
 }) => {
@@ -501,7 +507,7 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5,
+  create: create$5$1,
   signal: signal$1,
   wrap: wrap$5
 };
@@ -720,7 +726,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$2(id, errorProperty);
 };
-const create$3 = (message, result) => {
+const create$5 = (message, result) => {
   return {
     jsonrpc: Two$1,
     id: message.id,
@@ -729,7 +735,7 @@ const create$3 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$3(message, resultProperty);
+  return create$5(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -1028,14 +1034,22 @@ const createMockRpc = ({
   return mockRpc;
 };
 
-const Button = 1;
+const Button$1 = 1;
 const Div = 4;
 const Span = 8;
 const Text = 12;
 const Pre = 51;
 
+const Button = 'event.button';
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
 const TargetName = 'event.target.name';
 
+const Tab = 13;
+
+const Separator = 1;
+const None = 0;
+
 const ExtensionHostWorker = 44;
 const RendererWorker = 1;
 
@@ -1053,7 +1067,7 @@ const remove = id => {
 };
 
 /* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create$2 = rpcId => {
+const create$3 = rpcId => {
   return {
     async dispose() {
       const rpc = get$1(rpcId);
@@ -1091,12 +1105,21 @@ const create$2 = rpcId => {
 
 const {
   set: set$2
-} = create$2(ExtensionHostWorker);
+} = create$3(ExtensionHostWorker);
 
 const {
+  invoke,
   invokeAndTransfer,
   set: set$1
-} = create$2(RendererWorker);
+} = create$3(RendererWorker);
+const showContextMenu2 = async (uid, menuId, x, y, args) => {
+  number(uid);
+  number(menuId);
+  number(x);
+  number(y);
+  // @ts-ignore
+  await invoke('ContextMenu.show2', uid, menuId, x, y, args);
+};
 const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
@@ -1106,7 +1129,7 @@ const toCommandId = key => {
   const dotIndex = key.indexOf('.');
   return key.slice(dotIndex + 1);
 };
-const create$1 = () => {
+const create$2 = () => {
   const states = Object.create(null);
   const commandMapRef = {};
   return {
@@ -1192,13 +1215,15 @@ const {
   getCommandIds,
   registerCommands,
   set,
-  wrapCommand} = create$1();
+  wrapCommand,
+  wrapGetter
+} = create$2();
 
-const create = (uid, uri, x, y, width, height, platform, assetDir) => {
+const create$1 = (uid, uri, x, y, width, height, platform, assetDir) => {
   const state = {
     assetDir,
     layout: {
-      activeGroupId: '',
+      activeGroupId: undefined,
       direction: 'horizontal',
       groups: []
     },
@@ -1237,6 +1262,10 @@ const diff2 = uid => {
   return result;
 };
 
+const getMenuIds = () => {
+  return [Tab];
+};
+
 const handleClick = async (state, name) => {
   if (!name) {
     return state;
@@ -1245,7 +1274,14 @@ const handleClick = async (state, name) => {
 };
 
 const closeTab = (state, groupId, tabId) => {
-  const groups = state.layout.groups.map(group => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const newGroups = groups.map(group => {
     if (group.id === groupId) {
       const newTabs = group.tabs.filter(tab => tab.id !== tabId);
       let newActiveTabId = group.activeTabId;
@@ -1265,18 +1301,58 @@ const closeTab = (state, groupId, tabId) => {
     }
     return group;
   });
+
+  // If the group has no tabs left and there are other groups, remove the group
+  const groupWithNoTabs = newGroups.find(group => group.id === groupId && group.tabs.length === 0);
+  if (groupWithNoTabs && newGroups.length > 1) {
+    const remainingGroups = newGroups.filter(group => group.id !== groupId);
+    const redistributedGroups = remainingGroups.map(group => ({
+      ...group,
+      size: Math.round(100 / remainingGroups.length)
+    }));
+    const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0]?.id : activeGroupId;
+    return {
+      ...state,
+      layout: {
+        ...layout,
+        activeGroupId: newActiveGroupId,
+        groups: redistributedGroups
+      }
+    };
+  }
   return {
     ...state,
     layout: {
-      ...state.layout,
-      groups
+      ...layout,
+      groups: newGroups
     }
   };
 };
 
-const handleClickCloseTab = (state, rawGroupId, rawTabId) => {
-  const groupId = Number.parseInt(rawGroupId);
-  const tabId = Number.parseInt(rawTabId);
+const handleClickCloseTab = (state, rawGroupIndex, rawIndex) => {
+  if (!rawGroupIndex || !rawIndex) {
+    return state;
+  }
+  const groupIndex = Number.parseInt(rawGroupIndex);
+  const index = Number.parseInt(rawIndex);
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+
+  // Validate indexes
+  if (groupIndex < 0 || groupIndex >= groups.length) {
+    return state;
+  }
+  const group = groups[groupIndex];
+  if (index < 0 || index >= group.tabs.length) {
+    return state;
+  }
+  const tab = group.tabs[index];
+  const groupId = group.id;
+  const tabId = tab.id;
   return closeTab(state, groupId, tabId);
 };
 
@@ -1330,6 +1406,22 @@ const handleClickTab = async (state, groupIndexRaw, indexRaw) => {
   return selectTab(state, groupIndex, index);
 };
 
+const show2 = async (uid, menuId, x, y, args) => {
+  await showContextMenu2(uid, menuId, x, y, args);
+};
+
+const handleTabContextMenu = async (state, x, y) => {
+  number(x);
+  number(y);
+  const {
+    uid
+  } = state;
+  await show2(uid, Tab, x, y, {
+    menuId: Tab
+  });
+  return state;
+};
+
 const id = 7201;
 const sendMessagePortToExtensionHostWorker = async port => {
   await sendMessagePortToExtensionHostWorker$1(port, id);
@@ -1356,15 +1448,39 @@ const getTabs = async () => {
   const tabs = [{
     content: '',
     editorType: 'text',
-    id: '1',
+    id: 1,
     isDirty: false,
     title: 'tab 1'
   }, {
     content: '',
     editorType: 'text',
-    id: '2',
+    id: 2,
     isDirty: false,
     title: 'tab 2'
+  }, {
+    content: '',
+    editorType: 'text',
+    id: 3,
+    isDirty: false,
+    title: 'tab 3'
+  }, {
+    content: '',
+    editorType: 'text',
+    id: 4,
+    isDirty: false,
+    title: 'tab 4'
+  }, {
+    content: '',
+    editorType: 'text',
+    id: 5,
+    isDirty: false,
+    title: 'tab 5'
+  }, {
+    content: '',
+    editorType: 'text',
+    id: 6,
+    isDirty: false,
+    title: 'tab 6'
   }];
   return tabs;
 };
@@ -1374,13 +1490,13 @@ const loadContent = async state => {
   return {
     ...state,
     layout: {
-      activeGroupId: '0',
+      activeGroupId: 0,
       direction: 'horizontal',
       groups: [{
         activeTabId: tabs.length > 0 ? tabs[0].id : undefined,
         direction: 'horizontal',
         focused: false,
-        id: '0',
+        id: 0,
         size: 300,
         tabs
       }]
@@ -1388,14 +1504,306 @@ const loadContent = async state => {
   };
 };
 
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+/**
+ * @enum {string}
+ */
+const UiStrings = {
+  Close: 'Close',
+  CloseAll: 'Close All',
+  CloseOthers: 'Close Others',
+  CloseToTheRight: 'Close To The Right',
+  FindFileReferences: 'Find File References',
+  RevealInExplorer: 'Reveal in Explorer'};
+const close = () => {
+  return i18nString(UiStrings.Close);
+};
+const closeOthers = () => {
+  return i18nString(UiStrings.CloseOthers);
+};
+const closeAll = () => {
+  return i18nString(UiStrings.CloseAll);
+};
+const revealInExplorer = () => {
+  return i18nString(UiStrings.RevealInExplorer);
+};
+const closeToTheRight = () => {
+  return i18nString(UiStrings.CloseToTheRight);
+};
+const findFileReferences = () => {
+  return i18nString(UiStrings.FindFileReferences);
+};
+
+const menuEntrySeparator = {
+  command: '',
+  flags: Separator,
+  id: 'separator',
+  label: ''
+};
+
+// TODO should pass tab uri as argument or tab index
+const getMenuEntries$1 = state => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const group = groups[activeGroupId || 0];
+  const {
+    activeTabId,
+    tabs
+  } = group;
+  const tab = tabs[activeTabId || 0];
+  object(tab);
+  const {
+    path
+  } = tab;
+  return [{
+    command: 'Main.closeFocusedTab',
+    flags: None,
+    id: 'tabClose',
+    label: close()
+  }, {
+    command: 'Main.closeOthers',
+    flags: None,
+    id: 'tabCloseOthers',
+    label: closeOthers()
+  }, {
+    command: 'Main.closeTabsRight',
+    flags: None,
+    id: 'tabCloseToTheRight',
+    label: closeToTheRight()
+  }, {
+    command: 'Main.closeAllEditors',
+    flags: None,
+    id: 'tabCloseAll',
+    label: closeAll()
+  }, menuEntrySeparator, {
+    args: [path],
+    command: 'Explorer.revealItem',
+    flags: None,
+    id: 'revealInExplorer',
+    label: revealInExplorer()
+  }, menuEntrySeparator, {
+    args: [/* id */'References', /* focus */true, path],
+    command: 'SideBar.show',
+    flags: None,
+    id: 'findFileReferences',
+    label: findFileReferences()
+  }];
+};
+
+const getMenuEntries = async (state, props) => {
+  switch (props.menuId) {
+    case Tab:
+      return getMenuEntries$1(state);
+    default:
+      return [];
+  }
+};
+
+const findTabByUri = (state, uri) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  for (const group of groups) {
+    const tab = group.tabs.find(t => t.path === uri);
+    if (tab) {
+      return {
+        groupId: group.id,
+        tab
+      };
+    }
+  }
+  return undefined;
+};
+
+const focusEditorGroup = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const updatedGroups = groups.map(group => ({
+    ...group,
+    focused: group.id === groupId
+  }));
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      activeGroupId: groupId,
+      groups: updatedGroups
+    }
+  };
+};
+
+let idCounter = 0;
+const create = () => {
+  idCounter++;
+  return idCounter;
+};
+
+const openTab = (state, groupId, tab) => {
+  const newTab = {
+    ...tab,
+    id: create()
+  };
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const updatedGroups = groups.map(group => {
+    if (group.id === groupId) {
+      return {
+        ...group,
+        activeTabId: newTab.id,
+        tabs: [...group.tabs, newTab]
+      };
+    }
+    return group;
+  });
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      groups: updatedGroups
+    }
+  };
+};
+
+const getBasename = uri => {
+  const lastSlashIndex = uri.lastIndexOf('/');
+  if (lastSlashIndex === -1) {
+    return uri;
+  }
+  return uri.slice(lastSlashIndex + 1);
+};
+const getLabel = uri => {
+  if (uri.startsWith('settings://')) {
+    return 'Settings';
+  }
+  if (uri.startsWith('simple-browser://')) {
+    return 'Simple Browser';
+  }
+  return getBasename(uri);
+};
+
+const switchTab = (state, groupId, tabId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const updatedGroups = groups.map(group => {
+    if (group.id === groupId) {
+      const tabExists = group.tabs.some(tab => tab.id === tabId);
+      if (tabExists) {
+        return {
+          ...group,
+          activeTabId: tabId
+        };
+      }
+    }
+    return group;
+  });
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      groups: updatedGroups
+    }
+  };
+};
+
+/* eslint-disable prefer-destructuring */
+
 const openUri = async (state, options) => {
   object(state);
-  object(options);
+  let uri = '';
+  if (typeof options === 'string') {
+    uri = options;
+  } else {
+    uri = options.uri;
+  }
 
-  // TODO
-  return {
-    ...state
+  // Check if a tab with this URI already exists
+  const existingTab = findTabByUri(state, uri);
+  if (existingTab) {
+    // Tab exists, switch to it and focus its group
+    const focusedState = focusEditorGroup(state, existingTab.groupId);
+    return switchTab(focusedState, existingTab.groupId, existingTab.tab.id);
+  }
+
+  // Find the active group (by activeGroupId or focused flag)
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const activeGroup = activeGroupId === undefined ? groups.find(group => group.focused) : groups.find(group => group.id === activeGroupId);
+
+  // If no active group exists, create one
+  if (!activeGroup) {
+    const groupId = create();
+    const title = getLabel(uri);
+    const newTab = {
+      content: '',
+      editorType: 'text',
+      id: create(),
+      isDirty: false,
+      path: uri,
+      title
+    };
+    const newGroup = {
+      activeTabId: newTab.id,
+      focused: true,
+      id: groupId,
+      size: 100,
+      tabs: [newTab]
+    };
+    return {
+      ...state,
+      layout: {
+        ...layout,
+        activeGroupId: groupId,
+        groups: [...groups, newGroup]
+      }
+    };
+  }
+
+  // Create a new tab with the URI in the active group
+  const title = getLabel(uri);
+  const newTab = {
+    content: '',
+    editorType: 'text',
+    isDirty: false,
+    path: uri,
+    title
   };
+  return openTab(state, activeGroup.id, newTab);
 };
 
 const text = data => {
@@ -1411,7 +1819,15 @@ const CSS_CLASSES = {
 
 const renderEditor = tab => {
   if (!tab) {
-    return [text('Tab not found')];
+    return [{
+      childCount: 1,
+      className: 'TextEditor',
+      type: Div
+    }, {
+      childCount: 1,
+      className: 'EditorContent',
+      type: Pre
+    }, text('')];
   }
   if (tab.editorType === 'custom') {
     return [{
@@ -1434,6 +1850,7 @@ const renderEditor = tab => {
 const HandleClick = 11;
 const HandleClickClose = 12;
 const HandleClickTab = 13;
+const HandleTabContextMenu = 14;
 
 const renderTab = (tab, isActive, tabIndex, groupIndex) => {
   return [{
@@ -1442,7 +1859,9 @@ const renderTab = (tab, isActive, tabIndex, groupIndex) => {
     'data-groupIndex': groupIndex,
     'data-index': tabIndex,
     onClick: HandleClickTab,
+    onContextMenu: HandleTabContextMenu,
     role: 'tab',
+    title: tab.path || tab.title,
     type: Div
   }, {
     childCount: 1,
@@ -1454,7 +1873,7 @@ const renderTab = (tab, isActive, tabIndex, groupIndex) => {
     'data-groupIndex': groupIndex,
     'data-index': tabIndex,
     onClick: HandleClickClose,
-    type: Button
+    type: Button$1
   }, text('×')];
 };
 
@@ -1541,6 +1960,10 @@ const renderEventListeners = () => {
   }, {
     name: HandleClickTab,
     params: ['handleClickTab', 'event.target.dataset.groupIndex', 'event.target.dataset.index']
+  }, {
+    name: HandleTabContextMenu,
+    params: ['handleTabContextMenu', Button, ClientX, ClientY],
+    preventDefault: true
   }];
 };
 
@@ -1561,12 +1984,15 @@ const saveState = state => {
 };
 
 const commandMap = {
-  'MainArea.create': create,
+  'MainArea.create': create$1,
   'MainArea.diff2': diff2,
   'MainArea.getCommandIds': getCommandIds,
+  'MainArea.getMenuEntries': wrapGetter(getMenuEntries),
+  'MainArea.getMenuIds': getMenuIds,
   'MainArea.handleClick': wrapCommand(handleClick),
   'MainArea.handleClickCloseTab': wrapCommand(handleClickCloseTab),
   'MainArea.handleClickTab': wrapCommand(handleClickTab),
+  'MainArea.handleTabContextMenu': wrapCommand(handleTabContextMenu),
   'MainArea.initialize': initialize,
   'MainArea.loadContent': wrapCommand(loadContent),
   'MainArea.openUri': wrapCommand(openUri),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-area-worker",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "Main Area Worker",
   "repository": {
     "type": "git",
@@ -11,6 +11,6 @@
   "type": "module",
   "main": "dist/mainAreaWorkerMain.js",
   "dependencies": {
-    "@lvce-editor/virtual-dom-worker": "^5.1.0"
+    "@lvce-editor/virtual-dom-worker": "^6.2.0"
   }
 }