@lvce-editor/static-server 0.71.9 → 0.71.11

package/static/{522e297 → 8762c8a}/packages/main-area-worker/dist/mainAreaWorkerMain.js

@@ -98,10 +98,23 @@ const closeAll$1 = state => {
   };
 };
 
+const Button$1 = '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 IconThemeWorker = 7009;
 const RendererWorker = 1;
 
+const SetDom2 = 'Viewlet.setDom2';
+const SetPatches = 'Viewlet.setPatches';
+
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -167,7 +180,7 @@ class AssertionError extends Error {
 const Object$1 = 1;
 const Number$1 = 2;
 const Array$1 = 3;
-const String = 4;
+const String$1 = 4;
 const Boolean = 5;
 const Function = 6;
 const Null = 7;
@@ -179,7 +192,7 @@ const getType = value => {
     case 'function':
       return Function;
     case 'string':
-      return String;
+      return String$1;
     case 'object':
       if (value === null) {
         return Null;
@@ -1528,12 +1541,24 @@ const closeTab = (state, groupId, tabId) => {
     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;
-      if (group.activeTabId === tabId) {
-        const tabIndex = group.tabs.findIndex(tab => tab.id === tabId);
+
+  // Find the group to close the tab from
+  const groupIndex = groups.findIndex(g => g.id === groupId);
+  if (groupIndex === -1) {
+    return state;
+  }
+  const group = groups[groupIndex];
+  // Check if the tab exists in the group
+  const tabWasRemoved = group.tabs.some(tab => tab.id === tabId);
+  if (!tabWasRemoved) {
+    return state;
+  }
+  const newGroups = groups.map(grp => {
+    if (grp.id === groupId) {
+      const newTabs = grp.tabs.filter(tab => tab.id !== tabId);
+      let newActiveTabId = grp.activeTabId;
+      if (grp.activeTabId === tabId) {
+        const tabIndex = grp.tabs.findIndex(tab => tab.id === tabId);
         if (newTabs.length > 0) {
           newActiveTabId = newTabs[Math.min(tabIndex, newTabs.length - 1)].id;
         } else {
@@ -1541,29 +1566,43 @@ const closeTab = (state, groupId, tabId) => {
         }
       }
       return {
-        ...group,
+        ...grp,
         activeTabId: newActiveTabId,
         tabs: newTabs
       };
     }
-    return group;
+    return grp;
   });
 
-  // 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) {
+  // If the group has no tabs left after closing, remove the group
+  const groupIsNowEmpty = newGroups[groupIndex].tabs.length === 0;
+  if (groupIsNowEmpty) {
     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;
+
+    // If there are remaining groups, redistribute sizes
+    if (remainingGroups.length > 0) {
+      const redistributedGroups = remainingGroups.map(grp => ({
+        ...grp,
+        size: Math.round(100 / remainingGroups.length)
+      }));
+      const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0]?.id : activeGroupId;
+      return {
+        ...state,
+        layout: {
+          ...layout,
+          activeGroupId: newActiveGroupId,
+          groups: redistributedGroups
+        }
+      };
+    }
+
+    // If no remaining groups, return empty layout
     return {
       ...state,
       layout: {
         ...layout,
-        activeGroupId: newActiveGroupId,
-        groups: redistributedGroups
+        activeGroupId: undefined,
+        groups: []
       }
     };
   }
@@ -1607,6 +1646,7 @@ const create = (uid, uri, x, y, width, height, platform, assetDir, tabHeight = 3
       groups: []
     },
     platform,
+    splitButtonEnabled: false,
     tabHeight,
     uid,
     width,
@@ -1621,6 +1661,7 @@ const isEqual = (oldState, newState) => {
 };
 
 const RenderItems = 4;
+const RenderIncremental = 11;
 
 const modules = [isEqual];
 const numbers = [RenderItems];
@@ -1645,18 +1686,6 @@ const diff2 = uid => {
   return result;
 };
 
-const Button$1 = '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 SetDom2 = 'Viewlet.setDom2';
-
 const getMenuIds = () => {
   return [Tab];
 };
@@ -1668,6 +1697,73 @@ const handleClick = async (state, name) => {
   return state;
 };
 
+const getActiveGroup = (groups, activeGroupId) => {
+  return groups.find(g => g.id === activeGroupId);
+};
+
+const Right = 'right';
+
+const splitEditorGroup$1 = (state, groupId, direction) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const sourceGroup = groups.find(group => group.id === groupId);
+  if (!sourceGroup) {
+    return state;
+  }
+  const newGroupId = create$1();
+  const isHorizontalSplit = direction === Right;
+  const newLayoutDirection = isHorizontalSplit ? 'horizontal' : 'vertical';
+  const updatedGroups = groups.map(group => {
+    if (group.id === groupId) {
+      return {
+        ...group,
+        focused: false,
+        size: 50
+      };
+    }
+    return group;
+  });
+  const newGroup = {
+    activeTabId: undefined,
+    focused: true,
+    id: newGroupId,
+    size: 50,
+    tabs: []
+  };
+  let reorderedGroups;
+  {
+    reorderedGroups = [...updatedGroups, newGroup];
+  }
+  return {
+    ...state,
+    layout: {
+      activeGroupId: newGroupId,
+      direction: newLayoutDirection,
+      groups: reorderedGroups
+    }
+  };
+};
+
+const handleClickAction = async (state, action) => {
+  if (!action) {
+    return state;
+  }
+  const activeGroup = getActiveGroup(state.layout.groups, state.layout.activeGroupId);
+  if (!activeGroup) {
+    return state;
+  }
+  switch (action) {
+    case 'split-right':
+      return splitEditorGroup$1(state, activeGroup.id, Right);
+    default:
+      return state;
+  }
+};
+
 const handleClickCloseTab = (state, rawGroupIndex, rawIndex) => {
   if (!rawGroupIndex || !rawIndex) {
     return state;
@@ -1940,6 +2036,17 @@ const handleTabContextMenu = async (state, x, y) => {
   return state;
 };
 
+const handleWorkspaceChange = state => {
+  return {
+    ...state,
+    layout: {
+      ...state.layout,
+      activeGroupId: undefined,
+      groups: []
+    }
+  };
+};
+
 const id = 7201;
 const sendMessagePortToExtensionHostWorker = async port => {
   await sendMessagePortToExtensionHostWorker$1(port, id);
@@ -2287,7 +2394,11 @@ const CloseOthers = 'Close Others';
 const CloseToTheRight = 'Close To The Right';
 const FindFileReferences = 'Find File References';
 const RevealInExplorer = 'Reveal in Explorer';
+const SplitEditorGroup = 'Split Editor Group';
 
+const splitEditorGroup = () => {
+  return i18nString(SplitEditorGroup);
+};
 const close = () => {
   return i18nString(Close);
 };
@@ -2723,6 +2834,283 @@ const text = data => {
   };
 };
 
+const SetText = 1;
+const Replace = 2;
+const SetAttribute = 3;
+const RemoveAttribute = 4;
+const Add = 6;
+const NavigateChild = 7;
+const NavigateParent = 8;
+const RemoveChild = 9;
+const NavigateSibling = 10;
+
+const isKey = key => {
+  return key !== 'type' && key !== 'childCount';
+};
+
+const getKeys = node => {
+  const keys = Object.keys(node).filter(isKey);
+  return keys;
+};
+
+const arrayToTree = nodes => {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    const {
+      children,
+      nodesConsumed
+    } = getChildrenWithCount(nodes, i + 1, node.childCount || 0);
+    result.push({
+      node,
+      children
+    });
+    i += 1 + nodesConsumed;
+  }
+  return result;
+};
+const getChildrenWithCount = (nodes, startIndex, childCount) => {
+  if (childCount === 0) {
+    return {
+      children: [],
+      nodesConsumed: 0
+    };
+  }
+  const children = [];
+  let i = startIndex;
+  let remaining = childCount;
+  let totalConsumed = 0;
+  while (remaining > 0 && i < nodes.length) {
+    const node = nodes[i];
+    const nodeChildCount = node.childCount || 0;
+    const {
+      children: nodeChildren,
+      nodesConsumed
+    } = getChildrenWithCount(nodes, i + 1, nodeChildCount);
+    children.push({
+      node,
+      children: nodeChildren
+    });
+    const nodeSize = 1 + nodesConsumed;
+    i += nodeSize;
+    totalConsumed += nodeSize;
+    remaining--;
+  }
+  return {
+    children,
+    nodesConsumed: totalConsumed
+  };
+};
+
+const compareNodes = (oldNode, newNode) => {
+  const patches = [];
+  // Check if node type changed - return null to signal incompatible nodes
+  // (caller should handle this with a Replace operation)
+  if (oldNode.type !== newNode.type) {
+    return null;
+  }
+  // Handle text nodes
+  if (oldNode.type === Text && newNode.type === Text) {
+    if (oldNode.text !== newNode.text) {
+      patches.push({
+        type: SetText,
+        value: newNode.text
+      });
+    }
+    return patches;
+  }
+  // Compare attributes
+  const oldKeys = getKeys(oldNode);
+  const newKeys = getKeys(newNode);
+  // Check for attribute changes
+  for (const key of newKeys) {
+    if (oldNode[key] !== newNode[key]) {
+      patches.push({
+        type: SetAttribute,
+        key,
+        value: newNode[key]
+      });
+    }
+  }
+  // Check for removed attributes
+  for (const key of oldKeys) {
+    if (!(key in newNode)) {
+      patches.push({
+        type: RemoveAttribute,
+        key
+      });
+    }
+  }
+  return patches;
+};
+
+const treeToArray = node => {
+  const result = [node.node];
+  for (const child of node.children) {
+    result.push(...treeToArray(child));
+  }
+  return result;
+};
+
+const diffChildren = (oldChildren, newChildren, patches) => {
+  const maxLength = Math.max(oldChildren.length, newChildren.length);
+  // Track where we are: -1 means at parent, >= 0 means at child index
+  let currentChildIndex = -1;
+  // Collect indices of children to remove (we'll add these patches at the end in reverse order)
+  const indicesToRemove = [];
+  for (let i = 0; i < maxLength; i++) {
+    const oldNode = oldChildren[i];
+    const newNode = newChildren[i];
+    if (!oldNode && !newNode) {
+      continue;
+    }
+    if (!oldNode) {
+      // Add new node - we should be at the parent
+      if (currentChildIndex >= 0) {
+        // Navigate back to parent
+        patches.push({
+          type: NavigateParent
+        });
+        currentChildIndex = -1;
+      }
+      // Flatten the entire subtree so renderInternal can handle it
+      const flatNodes = treeToArray(newNode);
+      patches.push({
+        type: Add,
+        nodes: flatNodes
+      });
+    } else if (newNode) {
+      // Compare nodes to see if we need any patches
+      const nodePatches = compareNodes(oldNode.node, newNode.node);
+      // If nodePatches is null, the node types are incompatible - need to replace
+      if (nodePatches === null) {
+        // Navigate to this child
+        if (currentChildIndex === -1) {
+          patches.push({
+            type: NavigateChild,
+            index: i
+          });
+          currentChildIndex = i;
+        } else if (currentChildIndex !== i) {
+          patches.push({
+            type: NavigateSibling,
+            index: i
+          });
+          currentChildIndex = i;
+        }
+        // Replace the entire subtree
+        const flatNodes = treeToArray(newNode);
+        patches.push({
+          type: Replace,
+          nodes: flatNodes
+        });
+        // After replace, we're at the new element (same position)
+        continue;
+      }
+      // Check if we need to recurse into children
+      const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+      // Only navigate to this element if we need to do something
+      if (nodePatches.length > 0 || hasChildrenToCompare) {
+        // Navigate to this child if not already there
+        if (currentChildIndex === -1) {
+          patches.push({
+            type: NavigateChild,
+            index: i
+          });
+          currentChildIndex = i;
+        } else if (currentChildIndex !== i) {
+          patches.push({
+            type: NavigateSibling,
+            index: i
+          });
+          currentChildIndex = i;
+        }
+        // Apply node patches (these apply to the current element, not children)
+        if (nodePatches.length > 0) {
+          patches.push(...nodePatches);
+        }
+        // Compare children recursively
+        if (hasChildrenToCompare) {
+          diffChildren(oldNode.children, newNode.children, patches);
+        }
+      }
+    } else {
+      // Remove old node - collect the index for later removal
+      indicesToRemove.push(i);
+    }
+  }
+  // Navigate back to parent if we ended at a child
+  if (currentChildIndex >= 0) {
+    patches.push({
+      type: NavigateParent
+    });
+    currentChildIndex = -1;
+  }
+  // Add remove patches in reverse order (highest index first)
+  // This ensures indices remain valid as we remove
+  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
+    patches.push({
+      type: RemoveChild,
+      index: indicesToRemove[j]
+    });
+  }
+};
+const diffTrees = (oldTree, newTree, patches, path) => {
+  // At the root level (path.length === 0), we're already AT the element
+  // So we compare the root node directly, then compare its children
+  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
+    const oldNode = oldTree[0];
+    const newNode = newTree[0];
+    // Compare root nodes
+    const nodePatches = compareNodes(oldNode.node, newNode.node);
+    // If nodePatches is null, the root node types are incompatible - need to replace
+    if (nodePatches === null) {
+      const flatNodes = treeToArray(newNode);
+      patches.push({
+        type: Replace,
+        nodes: flatNodes
+      });
+      return;
+    }
+    if (nodePatches.length > 0) {
+      patches.push(...nodePatches);
+    }
+    // Compare children
+    if (oldNode.children.length > 0 || newNode.children.length > 0) {
+      diffChildren(oldNode.children, newNode.children, patches);
+    }
+  } else {
+    // Non-root level or multiple root elements - use the regular comparison
+    diffChildren(oldTree, newTree, patches);
+  }
+};
+
+const removeTrailingNavigationPatches = patches => {
+  // Find the last non-navigation patch
+  let lastNonNavigationIndex = -1;
+  for (let i = patches.length - 1; i >= 0; i--) {
+    const patch = patches[i];
+    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling) {
+      lastNonNavigationIndex = i;
+      break;
+    }
+  }
+  // Return patches up to and including the last non-navigation patch
+  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 1);
+};
+
+const diffTree = (oldNodes, newNodes) => {
+  // Step 1: Convert flat arrays to tree structures
+  const oldTree = arrayToTree(oldNodes);
+  const newTree = arrayToTree(newNodes);
+  // Step 3: Compare the trees
+  const patches = [];
+  diffTrees(oldTree, newTree, patches, []);
+  // Remove trailing navigation patches since they serve no purpose
+  return removeTrailingNavigationPatches(patches);
+};
+
 const CSS_CLASSES = {
   EDITOR_GROUPS_CONTAINER: 'editor-groups-container'};
 
@@ -2798,6 +3186,7 @@ const renderEditor = tab => {
   return renderContent(tab.content || '');
 };
 
+const HandleClickAction = 10;
 const HandleClick = 11;
 const HandleClickClose = 12;
 const HandleClickTab = 13;
@@ -2805,6 +3194,7 @@ const HandleTabContextMenu = 14;
 
 const renderTab = (tab, isActive, tabIndex, groupIndex) => {
   return [{
+    'aria-selected': isActive,
     childCount: 3,
     className: isActive ? 'MainTab MainTabSelected' : 'MainTab',
     'data-groupIndex': groupIndex,
@@ -2817,6 +3207,7 @@ const renderTab = (tab, isActive, tabIndex, groupIndex) => {
   }, {
     childCount: 0,
     className: 'TabIcon',
+    role: 'none',
     src: tab.icon,
     type: Img
   }, {
@@ -2824,6 +3215,7 @@ const renderTab = (tab, isActive, tabIndex, groupIndex) => {
     className: 'TabTitle',
     type: Span
   }, text(tab.isDirty ? `*${tab.title}` : tab.title), {
+    'aria-label': 'Close',
     childCount: 1,
     className: 'EditorTabCloseButton',
     'data-groupIndex': groupIndex,
@@ -2837,28 +3229,60 @@ const renderTab = (tab, isActive, tabIndex, groupIndex) => {
   }];
 };
 
-const renderTabBar = (group, groupIndex) => {
+const getTabsVirtualDom = (group, groupIndex, tabsChildCount) => {
   return [{
-    childCount: group.tabs.length,
+    childCount: tabsChildCount,
     className: 'MainTabs',
+    role: 'tablist',
     type: Div
   }, ...group.tabs.flatMap((tab, tabIndex) => renderTab(tab, tab.id === group.activeTabId, tabIndex, groupIndex))];
 };
 
-const renderEditorGroup = (group, groupIndex) => {
+const renderEditorGroupActions = (group, groupIndex, splitButtonEnabled) => {
+  if (!splitButtonEnabled) {
+    return [];
+  }
+  return [{
+    childCount: 1,
+    className: 'EditorGroupActions',
+    role: 'toolbar',
+    type: Div
+  }, {
+    childCount: 1,
+    className: 'EditorGroupActionButton SplitEditorGroupButton',
+    'data-action': 'split-right',
+    'data-groupId': String(group.id),
+    onClick: HandleClickAction,
+    title: splitEditorGroup(),
+    type: Button
+  }, text('split')];
+};
+
+const renderEditorGroupHeader = (group, groupIndex, splitButtonEnabled) => {
+  const tabsChildCount = group.tabs.length;
+  const actions = renderEditorGroupActions(group, groupIndex, splitButtonEnabled);
+  return [{
+    childCount: actions.length > 0 ? 2 : 1,
+    className: 'EditorGroupHeader',
+    role: 'none',
+    type: Div
+  }, ...getTabsVirtualDom(group, groupIndex, tabsChildCount), ...actions];
+};
+
+const renderEditorGroup = (group, groupIndex, splitButtonEnabled = false) => {
   const activeTab = group.tabs.find(tab => tab.id === group.activeTabId);
   return [{
     childCount: 2,
     className: 'EditorGroup',
     type: Div
-  }, ...renderTabBar(group, groupIndex), {
+  }, ...renderEditorGroupHeader(group, groupIndex, splitButtonEnabled), {
     childCount: activeTab ? 1 : 1,
     className: 'EditorContainer',
     type: Div
   }, ...renderEditor(activeTab)];
 };
 
-const getMainAreaVirtualDom = layout => {
+const getMainAreaVirtualDom = (layout, splitButtonEnabled = false) => {
   return [{
     childCount: 1,
     className: 'Main',
@@ -2866,21 +3290,32 @@ const getMainAreaVirtualDom = layout => {
   }, {
     childCount: layout.groups.length,
     className: CSS_CLASSES.EDITOR_GROUPS_CONTAINER,
+    role: 'none',
     type: Div
-  }, ...layout.groups.flatMap((group, groupIndex) => renderEditorGroup(group, groupIndex))];
+  }, ...layout.groups.flatMap((group, groupIndex) => renderEditorGroup(group, groupIndex, splitButtonEnabled))];
 };
 
 const renderItems = (oldState, newState) => {
   const {
     layout,
+    splitButtonEnabled,
     uid
   } = newState;
-  const dom = getMainAreaVirtualDom(layout);
+  const dom = getMainAreaVirtualDom(layout, splitButtonEnabled);
   return [SetDom2, uid, dom];
 };
 
+const renderIncremental = (oldState, newState) => {
+  const oldDom = renderItems(oldState, oldState)[2];
+  const newDom = renderItems(newState, newState)[2];
+  const patches = diffTree(oldDom, newDom);
+  return [SetPatches, newState.uid, patches];
+};
+
 const getRenderer = diffType => {
   switch (diffType) {
+    case RenderIncremental:
+      return renderIncremental;
     case RenderItems:
       return renderItems;
     default:
@@ -2924,6 +3359,9 @@ const renderEventListeners = () => {
     name: HandleTabContextMenu,
     params: ['handleTabContextMenu', Button$1, ClientX, ClientY],
     preventDefault: true
+  }, {
+    name: HandleClickAction,
+    params: ['handleClickAction', 'event.target.dataset.action']
   }];
 };
 
@@ -2934,6 +3372,44 @@ const resize = (state, dimensions) => {
   };
 };
 
+const getActiveTab = state => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const activeGroup = groups.find(group => group.focused);
+  if (!activeGroup || !activeGroup.activeTabId) {
+    return undefined;
+  }
+  const activeTab = activeGroup.tabs.find(tab => tab.id === activeGroup.activeTabId);
+  if (!activeTab) {
+    return undefined;
+  }
+  return {
+    groupId: activeGroup.id,
+    tab: activeTab
+  };
+};
+
+const save = async state => {
+  const activeTabData = getActiveTab(state);
+  if (!activeTabData) {
+    return state;
+  }
+  const {
+    tab
+  } = activeTabData;
+  if (tab.loadingState !== 'loaded') {
+    return state;
+  }
+  await invoke('Editor.save', tab.editorUid);
+  return updateTab(state, tab.id, {
+    isDirty: false
+  });
+};
+
 const saveState = state => {
   const {
     layout
@@ -2952,9 +3428,11 @@ const commandMap = {
   'MainArea.getMenuEntries': wrapGetter(getMenuEntries),
   'MainArea.getMenuIds': getMenuIds,
   'MainArea.handleClick': wrapCommand(handleClick),
+  'MainArea.handleClickAction': wrapCommand(handleClickAction),
   'MainArea.handleClickCloseTab': wrapCommand(handleClickCloseTab),
   'MainArea.handleClickTab': wrapCommand(handleClickTab),
   'MainArea.handleTabContextMenu': wrapCommand(handleTabContextMenu),
+  'MainArea.handleWorkspaceChange': wrapCommand(handleWorkspaceChange),
   'MainArea.initialize': initialize,
   'MainArea.loadContent': wrapCommand(loadContent),
   'MainArea.openUri': wrapCommand(openUri),
@@ -2962,6 +3440,7 @@ const commandMap = {
   'MainArea.render2': render2,
   'MainArea.renderEventListeners': renderEventListeners,
   'MainArea.resize': wrapCommand(resize),
+  'MainArea.save': wrapCommand(save),
   'MainArea.saveState': wrapGetter(saveState),
   'MainArea.selectTab': wrapCommand(selectTab),
   'MainArea.terminate': terminate