@lvce-editor/main-area-worker 5.13.0 → 6.0.0

package/dist/mainAreaWorkerMain.js

@@ -1576,6 +1576,7 @@ const closeTab = (state, groupId, tabId) => {
       return {
         ...grp,
         activeTabId: newActiveTabId,
+        isEmpty: newTabs.length === 0,
         tabs: newTabs
       };
     }
@@ -1705,10 +1706,41 @@ const handleClick = async (state, name) => {
   return state;
 };
 
+const closeEditorGroup = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const groupIndex = groups.findIndex(group => group.id === groupId);
+  if (groupIndex === -1 || groups.length <= 1) {
+    return state;
+  }
+  const remainingGroups = groups.filter(group => group.id !== groupId);
+  const baseSize = Math.floor(100 / remainingGroups.length);
+  const remainder = 100 % remainingGroups.length;
+  const redistributedGroups = remainingGroups.map((group, index) => ({
+    ...group,
+    size: baseSize + (index === remainingGroups.length - 1 ? remainder : 0)
+  }));
+  const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0].id : activeGroupId;
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      activeGroupId: newActiveGroupId,
+      groups: redistributedGroups
+    }
+  };
+};
+
 const getActiveGroup = (groups, activeGroupId) => {
   return groups.find(g => g.id === activeGroupId);
 };
 
+const Left = 'left';
 const Right = 'right';
 
 const splitEditorGroup$1 = (state, groupId, direction) => {
@@ -1723,7 +1755,7 @@ const splitEditorGroup$1 = (state, groupId, direction) => {
     return state;
   }
   const newGroupId = create$1();
-  const isHorizontalSplit = direction === Right;
+  const isHorizontalSplit = direction === Left || direction === Right;
   const newLayoutDirection = isHorizontalSplit ? 'horizontal' : 'vertical';
   const updatedGroups = groups.map(group => {
     if (group.id === groupId) {
@@ -1739,12 +1771,16 @@ const splitEditorGroup$1 = (state, groupId, direction) => {
     activeTabId: undefined,
     focused: true,
     id: newGroupId,
+    isEmpty: true,
     size: 50,
     tabs: []
   };
   let reorderedGroups;
-  {
+  if (direction === Right || direction === 'down') {
     reorderedGroups = [...updatedGroups, newGroup];
+  } else {
+    const sourceIndex = updatedGroups.findIndex(group => group.id === groupId);
+    reorderedGroups = [...updatedGroups.slice(0, sourceIndex), newGroup, ...updatedGroups.slice(sourceIndex)];
   }
   return {
     ...state,
@@ -1756,15 +1792,26 @@ const splitEditorGroup$1 = (state, groupId, direction) => {
   };
 };
 
-const handleClickAction = async (state, action) => {
+const handleClickAction = async (state, action, rawGroupId) => {
   if (!action) {
     return state;
   }
+  if (state.layout.activeGroupId === undefined) {
+    return state;
+  }
   const activeGroup = getActiveGroup(state.layout.groups, state.layout.activeGroupId);
   if (!activeGroup) {
     return state;
   }
   switch (action) {
+    case 'close-group':
+      if (rawGroupId) {
+        const groupId = Number.parseInt(rawGroupId, 10);
+        if (!Number.isNaN(groupId)) {
+          return closeEditorGroup(state, groupId);
+        }
+      }
+      return state;
     case 'split-right':
       return splitEditorGroup$1(state, activeGroup.id, Right);
     default:
@@ -1948,56 +1995,52 @@ 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.loadingState || newTab.loadingState === 'loading') {
-    try {
-      // Query RendererWorker for viewlet module ID
-      // @ts-ignore
-      const viewletModuleId = await invoke('Layout.getModuleId', newTab.uri);
-      if (viewletModuleId) {
-        // Calculate bounds: use main area bounds minus 35px for tab height
-        const TAB_HEIGHT = 35;
-        const bounds = {
-          height: newState.height - TAB_HEIGHT,
-          width: newState.width,
-          x: newState.x,
-          y: newState.y + TAB_HEIGHT
-        };
-        const createdState = createViewletForTab(newState, tabId, viewletModuleId, bounds);
-        newState = createdState;
+  if (newTab.uri && (!newTab.loadingState || newTab.loadingState === 'loading')) {
+    // Query RendererWorker for viewlet module ID
+    // @ts-ignore
+    const viewletModuleId = await invoke('Layout.getModuleId', newTab.uri);
+    if (viewletModuleId) {
+      // Calculate bounds: use main area bounds minus 35px for tab height
+      const TAB_HEIGHT = 35;
+      const bounds = {
+        height: newState.height - TAB_HEIGHT,
+        width: newState.width,
+        x: newState.x,
+        y: newState.y + TAB_HEIGHT
+      };
+      const createdState = createViewletForTab(newState, tabId);
+      newState = createdState;
 
-        // Store updated state before creating viewlet
-        set(uid, state, newState);
+      // Store updated state before creating viewlet
+      set(uid, state, newState);
 
-        // Execute viewlet commands if any
-        if (switchCommands.length > 0) {
-          await executeViewletCommands(switchCommands);
-        }
+      // Execute viewlet commands if any
+      if (switchCommands.length > 0) {
+        await executeViewletCommands(switchCommands);
+      }
 
-        // Get the tab to extract editorUid for viewlet creation
-        const tabWithViewlet = findTabById(newState, tabId);
-        if (tabWithViewlet) {
-          const {
-            editorUid
-          } = tabWithViewlet.tab;
-          if (editorUid !== -1 && newTab.uri) {
-            // Create the actual viewlet instance
-            await createViewlet(viewletModuleId, editorUid, tabId, bounds, newTab.uri);
-
-            // Mark viewlet as ready
-            newState = handleViewletReady(newState, editorUid);
-            set(uid, state, newState);
-          }
+      // Get the tab to extract editorUid for viewlet creation
+      const tabWithViewlet = findTabById(newState, tabId);
+      if (tabWithViewlet) {
+        const {
+          editorUid
+        } = tabWithViewlet.tab;
+        if (editorUid !== -1 && newTab.uri) {
+          // Create the actual viewlet instance
+          await createViewlet(viewletModuleId, editorUid, tabId, bounds, newTab.uri);
+
+          // Mark viewlet as ready
+          newState = handleViewletReady(newState, editorUid);
+          set(uid, state, newState);
         }
+      }
 
-        // Start loading content in the background if needed
-        if (needsLoading && tab.uri) {
-          const latestState = await startContentLoading(state, newState, tabId, tab.uri, requestId);
-          return latestState;
-        }
-        return newState;
+      // Start loading content in the background if needed
+      if (needsLoading && tab.uri) {
+        const latestState = await startContentLoading(state, newState, tabId, tab.uri, requestId);
+        return latestState;
       }
-    } catch {
-      // Viewlet creation is optional - silently ignore if RendererWorker isn't available
+      return newState;
     }
   }
   set(uid, state, newState);
@@ -2024,6 +2067,44 @@ const handleClickTab = async (state, groupIndexRaw, indexRaw) => {
   return selectTab(state, groupIndex, index);
 };
 
+const handleResize = async (state, x, y, width, height) => {
+  number(x);
+  number(y);
+  number(width);
+  number(height);
+  const newState = {
+    ...state,
+    height,
+    width,
+    x,
+    y
+  };
+
+  // Resize all editor children to their new bounds
+  const {
+    layout,
+    tabHeight
+  } = state;
+  const {
+    groups
+  } = layout;
+  const contentHeight = height - tabHeight;
+  for (const group of groups) {
+    for (const tab of group.tabs) {
+      if (tab.editorUid !== -1) {
+        // @ts-ignore
+        await invoke('Viewlet.setBounds', tab.editorUid, {
+          height: contentHeight,
+          width,
+          x,
+          y: y + tabHeight
+        });
+      }
+    }
+  }
+  return newState;
+};
+
 const show2 = async (uid, menuId, x, y, args) => {
   await showContextMenu2(uid, menuId, x, y, args);
 };
@@ -2078,7 +2159,7 @@ const isValidTab = tab => {
 };
 
 const isValidEditorGroup = group => {
-  return group && typeof group.id === 'number' && Array.isArray(group.tabs) && group.tabs.every(isValidTab) && (group.activeTabId === undefined || typeof group.activeTabId === 'number') && typeof group.focused === 'boolean' && typeof group.size === 'number' && group.size > 0;
+  return group && typeof group.id === 'number' && Array.isArray(group.tabs) && group.tabs.every(isValidTab) && (group.activeTabId === undefined || typeof group.activeTabId === 'number') && typeof group.focused === 'boolean' && typeof group.size === 'number' && group.size > 0 && typeof group.isEmpty === 'boolean';
 };
 
 const isValidMainAreaLayout = layout => {
@@ -2540,6 +2621,7 @@ const createEmptyGroup = (state, uri, requestId) => {
     activeTabId: newTab.id,
     focused: true,
     id: groupId,
+    isEmpty: false,
     size: 100,
     tabs: [newTab]
   };
@@ -2566,10 +2648,12 @@ const openTab = (state, groupId, tab) => {
   } = layout;
   const updatedGroups = groups.map(group => {
     if (group.id === groupId) {
+      const newTabs = [...group.tabs, newTab];
       return {
         ...group,
         activeTabId: newTab.id,
-        tabs: [...group.tabs, newTab]
+        isEmpty: newTabs.length === 0,
+        tabs: newTabs
       };
     }
     return group;
@@ -3363,7 +3447,7 @@ const renderEventListeners = () => {
     preventDefault: true
   }, {
     name: HandleClickAction,
-    params: ['handleClickAction', 'event.target.dataset.action']
+    params: ['handleClickAction', 'event.target.dataset.action', 'event.target.dataset.groupId']
   }];
 };
 
@@ -3421,6 +3505,76 @@ const saveState = state => {
   };
 };
 
+const splitDown = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+
+  // If there are no groups, create an initial empty group first
+  if (groups.length === 0) {
+    const initialGroupId = create$1();
+    const initialGroup = {
+      activeTabId: undefined,
+      focused: true,
+      id: initialGroupId,
+      isEmpty: true,
+      size: 100,
+      tabs: []
+    };
+    const stateWithInitialGroup = {
+      ...state,
+      layout: {
+        ...layout,
+        activeGroupId: initialGroupId,
+        groups: [initialGroup]
+      }
+    };
+    return splitEditorGroup$1(stateWithInitialGroup, initialGroupId, 'down');
+  }
+  const resolvedGroupId = groupId ?? state.layout.activeGroupId;
+  if (!resolvedGroupId) {
+    return state;
+  }
+  return splitEditorGroup$1(state, resolvedGroupId, 'down');
+};
+
+const splitRight = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+
+  // If there are no groups, create an initial empty group first
+  if (groups.length === 0) {
+    const initialGroupId = create$1();
+    const initialGroup = {
+      activeTabId: undefined,
+      focused: true,
+      id: initialGroupId,
+      isEmpty: true,
+      size: 100,
+      tabs: []
+    };
+    const stateWithInitialGroup = {
+      ...state,
+      layout: {
+        ...layout,
+        activeGroupId: initialGroupId,
+        groups: [initialGroup]
+      }
+    };
+    return splitEditorGroup$1(stateWithInitialGroup, initialGroupId, Right);
+  }
+  const targetGroupId = groupId ?? activeGroupId ?? groups[0]?.id ?? 0;
+  return splitEditorGroup$1(state, targetGroupId, Right);
+};
+
 const commandMap = {
   'MainArea.closeAll': wrapCommand(closeAll$1),
   'MainArea.closeFocusedTab': wrapCommand(closeFocusedTab),
@@ -3433,6 +3587,7 @@ const commandMap = {
   'MainArea.handleClickAction': wrapCommand(handleClickAction),
   'MainArea.handleClickCloseTab': wrapCommand(handleClickCloseTab),
   'MainArea.handleClickTab': wrapCommand(handleClickTab),
+  'MainArea.handleResize': wrapCommand(handleResize),
   'MainArea.handleTabContextMenu': wrapCommand(handleTabContextMenu),
   'MainArea.handleWorkspaceChange': wrapCommand(handleWorkspaceChange),
   'MainArea.initialize': initialize,
@@ -3445,6 +3600,8 @@ const commandMap = {
   'MainArea.save': wrapCommand(save),
   'MainArea.saveState': wrapGetter(saveState),
   'MainArea.selectTab': wrapCommand(selectTab),
+  'MainArea.splitDown': wrapCommand(splitDown),
+  'MainArea.splitRight': wrapCommand(splitRight),
   'MainArea.terminate': terminate
 };
 

package/package.json

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