@lvce-editor/main-area-worker 6.7.0 → 7.1.0

package/dist/mainAreaWorkerMain.js

@@ -93,6 +93,7 @@ const Span = 8;
 const Text = 12;
 const Img = 17;
 const Pre = 51;
+const Reference = 100;
 
 const Button = 'event.button';
 const ClientX = 'event.clientX';
@@ -215,6 +216,12 @@ const number = value => {
     throw new AssertionError('expected value to be of type number');
   }
 };
+const string = value => {
+  const type = getType(value);
+  if (type !== String$1) {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
 
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
@@ -1666,12 +1673,64 @@ const closeFocusedTab = state => {
   return closeTab(state, focusedGroup.id, activeTabId);
 };
 
+const closeOtherTabs = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const group = groups.find(g => g.id === groupId);
+  if (!group) {
+    return state;
+  }
+  const {
+    activeTabId
+  } = group;
+  if (activeTabId === undefined) {
+    return state;
+  }
+  const newGroups = groups.map(g => {
+    if (g.id === groupId) {
+      const newTabs = g.tabs.filter(tab => tab.id === activeTabId);
+      return {
+        ...g,
+        activeTabId,
+        isEmpty: newTabs.length === 0,
+        tabs: newTabs
+      };
+    }
+    return g;
+  });
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      groups: newGroups
+    }
+  };
+};
+
+const copyPath$1 = async (state, path) => {
+  string(path);
+  await invoke('ClipBoard.writeText', path);
+  return state;
+};
+
+const copyRelativePath$1 = async (state, path) => {
+  string(path);
+  const relativePath = await invoke('Workspace.pathBaseName', path);
+  await invoke('ClipBoard.writeText', relativePath);
+  return state;
+};
+
 const create = (uid, uri, x, y, width, height, platform, assetDir, tabHeight = 35) => {
   const state = {
     assetDir,
     fileIconCache: {},
     height,
     iframes: [],
+    initial: true,
     layout: {
       activeGroupId: undefined,
       direction: 'horizontal',
@@ -1696,7 +1755,7 @@ const RenderItems = 4;
 const RenderIncremental = 11;
 
 const modules = [isEqual];
-const numbers = [RenderItems];
+const numbers = [RenderIncremental];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -2162,6 +2221,222 @@ const handleDoubleClick = async state => {
   return state;
 };
 
+const MainTabs = 'MainTabs';
+
+const getBasename$1 = 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$1(uri);
+};
+
+const createEmptyGroup = (state, uri, requestId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const groupId = create$1();
+  const title = getLabel(uri);
+  const tabId = create$1();
+  const editorUid = create$1();
+  const newTab = {
+    editorType: 'text',
+    editorUid,
+    errorMessage: '',
+    icon: '',
+    id: tabId,
+    isDirty: false,
+    language: '',
+    loadingState: 'loading',
+    title,
+    uri
+  };
+  const newGroup = {
+    activeTabId: newTab.id,
+    focused: true,
+    id: groupId,
+    isEmpty: false,
+    size: 100,
+    tabs: [newTab]
+  };
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      activeGroupId: groupId,
+      groups: [...groups, newGroup]
+    }
+  };
+};
+
+const getActiveTabId = state => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const activeGroup = groups.find(g => g.id === activeGroupId);
+  return activeGroup?.activeTabId;
+};
+
+const openTab = (state, groupId, tab) => {
+  const newTab = 'id' in tab && tab.id !== undefined ? tab : {
+    ...tab,
+    id: create$1()
+  };
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const updatedGroups = groups.map(group => {
+    if (group.id === groupId) {
+      const newTabs = [...group.tabs, newTab];
+      return {
+        ...group,
+        activeTabId: newTab.id,
+        isEmpty: newTabs.length === 0,
+        tabs: newTabs
+      };
+    }
+    return group;
+  });
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      groups: updatedGroups
+    }
+  };
+};
+
+const newFile = async state => {
+  object(state);
+  const {
+    layout,
+    uid
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+
+  // Find the active group
+  const activeGroup = activeGroupId === undefined ? groups.find(group => group.focused) : groups.find(group => group.id === activeGroupId);
+
+  // Prepare initial state
+  let newState = state;
+  let targetGroupId;
+  if (activeGroup) {
+    targetGroupId = activeGroup.id;
+  } else {
+    // No active group, create an empty one
+    newState = createEmptyGroup(state, '');
+    const updatedActiveGroupId = newState.layout.activeGroupId;
+    if (!updatedActiveGroupId) {
+      return state;
+    }
+    targetGroupId = updatedActiveGroupId;
+
+    // Remove the tab that createEmptyGroup created, we'll add our own
+    newState = {
+      ...newState,
+      layout: {
+        ...newState.layout,
+        groups: newState.layout.groups.map(group => {
+          if (group.id === targetGroupId) {
+            return {
+              ...group,
+              activeTabId: undefined,
+              tabs: []
+            };
+          }
+          return group;
+        })
+      }
+    };
+  }
+
+  // Get previous active tab ID for viewlet switching
+  getActiveTabId(newState);
+
+  // Create a new empty tab
+  const tabId = create$1();
+  const editorUid = create$1();
+  const newTab = {
+    editorType: 'text',
+    editorUid,
+    errorMessage: '',
+    icon: '',
+    id: tabId,
+    isDirty: false,
+    language: 'plaintext',
+    loadingState: 'loading',
+    title: 'Untitled',
+    uri: 'untitled:///1'
+  };
+  const stateWithNewTab = openTab(newState, targetGroupId, newTab);
+
+  // Calculate bounds: use main area bounds minus tab height
+  const bounds = {
+    height: stateWithNewTab.height - stateWithNewTab.tabHeight,
+    width: stateWithNewTab.width,
+    x: stateWithNewTab.x,
+    y: stateWithNewTab.y + stateWithNewTab.tabHeight
+  };
+  const stateWithViewlet = createViewletForTab(stateWithNewTab, tabId);
+  let intermediateState = stateWithViewlet;
+
+  // Switch viewlet (detach old, attach new if ready)
+  const {
+    newState: switchedState
+  } = switchViewlet(intermediateState);
+  intermediateState = switchedState;
+  set(uid, state, intermediateState);
+
+  // Get the tab to extract editorUid
+  const tabWithViewlet = findTabById(intermediateState, tabId);
+  if (!tabWithViewlet) {
+    return intermediateState;
+  }
+  const {
+    editorUid: actualEditorUid
+  } = tabWithViewlet.tab;
+  if (actualEditorUid === -1) {
+    throw new Error(`invalid editorUid`);
+  }
+  await createViewlet('Editor', actualEditorUid, tabId, bounds, newTab.uri || '');
+
+  // After viewlet is created, get the latest state and mark it as ready
+  const {
+    newState: latestState
+  } = get(uid);
+  const readyState = handleViewletReady(latestState, actualEditorUid);
+  return readyState;
+};
+
+const handleHeaderDoubleClick = async (state, className, groupIndexRaw) => {
+  if (className !== MainTabs) {
+    return state;
+  }
+  return newFile(state);
+};
+
 const handleModifiedStatusChange = (state, uri, newStatus) => {
   const {
     layout
@@ -2249,7 +2524,7 @@ const getIconsCached = (dirents, fileIconCache) => {
   return dirents.map(dirent => fileIconCache[dirent]);
 };
 
-const getBasename$1 = uri => {
+const getBasename = uri => {
   const lastSlashIndex = uri.lastIndexOf('/');
   if (lastSlashIndex === -1) {
     return uri;
@@ -2268,7 +2543,7 @@ const getMissingTabs = (tabs, fileIconCache) => {
 const tabToIconRequest = tab => {
   const uri = tab.uri || '';
   return {
-    name: getBasename$1(uri),
+    name: getBasename(uri),
     path: uri,
     type: 0 // file type
   };
@@ -2371,23 +2646,6 @@ const loadFileIcons = async state => {
   }
 };
 
-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 handleUriChange = async (state, oldUri, newUri) => {
   const {
     layout
@@ -2616,12 +2874,14 @@ const loadContent = async (state, savedState) => {
     const finalState = {
       ...editorState,
       fileIconCache,
+      initial: false,
       layout: updatedLayout
     };
     return finalState;
   }
   return {
     ...state,
+    initial: false,
     layout: {
       activeGroupId: undefined,
       direction: 'horizontal',
@@ -2656,6 +2916,8 @@ const Close = 'Close';
 const CloseAll = 'Close All';
 const CloseOthers = 'Close Others';
 const CloseToTheRight = 'Close To The Right';
+const CopyPath = 'Copy Path';
+const CopyRelativePath = 'Copy Relative Path';
 const FindFileReferences = 'Find File References';
 const RevealInExplorer = 'Reveal in Explorer';
 const SplitEditorGroup = 'Split Editor Group';
@@ -2681,6 +2943,12 @@ const closeToTheRight = () => {
 const findFileReferences = () => {
   return i18nString(FindFileReferences);
 };
+const copyPath = () => {
+  return i18nString(CopyPath);
+};
+const copyRelativePath = () => {
+  return i18nString(CopyRelativePath);
+};
 
 const menuEntrySeparator = {
   command: '',
@@ -2738,6 +3006,18 @@ const getMenuEntries$1 = state => {
     flags: None,
     id: 'revealInExplorer',
     label: revealInExplorer()
+  }, {
+    args: [path],
+    command: 'Main.copyPath',
+    flags: None,
+    id: 'copyPath',
+    label: copyPath()
+  }, {
+    args: [path],
+    command: 'Main.copyRelativePath',
+    flags: None,
+    id: 'copyRelativePath',
+    label: copyRelativePath()
   }, menuEntrySeparator, {
     args: [/* id */'References', /* focus */true, path],
     command: 'SideBar.show',
@@ -2756,196 +3036,6 @@ const getMenuEntries = async (state, props) => {
   }
 };
 
-const createEmptyGroup = (state, uri, requestId) => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  const groupId = create$1();
-  const title = getLabel(uri);
-  const tabId = create$1();
-  const editorUid = create$1();
-  const newTab = {
-    editorType: 'text',
-    editorUid,
-    errorMessage: '',
-    icon: '',
-    id: tabId,
-    isDirty: false,
-    language: '',
-    loadingState: 'loading',
-    title,
-    uri
-  };
-  const newGroup = {
-    activeTabId: newTab.id,
-    focused: true,
-    id: groupId,
-    isEmpty: false,
-    size: 100,
-    tabs: [newTab]
-  };
-  return {
-    ...state,
-    layout: {
-      ...layout,
-      activeGroupId: groupId,
-      groups: [...groups, newGroup]
-    }
-  };
-};
-
-const getActiveTabId = state => {
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    groups
-  } = layout;
-  const activeGroup = groups.find(g => g.id === activeGroupId);
-  return activeGroup?.activeTabId;
-};
-
-const openTab = (state, groupId, tab) => {
-  const newTab = 'id' in tab && tab.id !== undefined ? tab : {
-    ...tab,
-    id: create$1()
-  };
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  const updatedGroups = groups.map(group => {
-    if (group.id === groupId) {
-      const newTabs = [...group.tabs, newTab];
-      return {
-        ...group,
-        activeTabId: newTab.id,
-        isEmpty: newTabs.length === 0,
-        tabs: newTabs
-      };
-    }
-    return group;
-  });
-  return {
-    ...state,
-    layout: {
-      ...layout,
-      groups: updatedGroups
-    }
-  };
-};
-
-const newFile = async state => {
-  object(state);
-  const {
-    layout,
-    uid
-  } = state;
-  const {
-    activeGroupId,
-    groups
-  } = layout;
-
-  // Find the active group
-  const activeGroup = activeGroupId === undefined ? groups.find(group => group.focused) : groups.find(group => group.id === activeGroupId);
-
-  // Prepare initial state
-  let newState = state;
-  let targetGroupId;
-  if (activeGroup) {
-    targetGroupId = activeGroup.id;
-  } else {
-    // No active group, create an empty one
-    newState = createEmptyGroup(state, '');
-    const updatedActiveGroupId = newState.layout.activeGroupId;
-    if (!updatedActiveGroupId) {
-      return state;
-    }
-    targetGroupId = updatedActiveGroupId;
-
-    // Remove the tab that createEmptyGroup created, we'll add our own
-    newState = {
-      ...newState,
-      layout: {
-        ...newState.layout,
-        groups: newState.layout.groups.map(group => {
-          if (group.id === targetGroupId) {
-            return {
-              ...group,
-              activeTabId: undefined,
-              tabs: []
-            };
-          }
-          return group;
-        })
-      }
-    };
-  }
-
-  // Get previous active tab ID for viewlet switching
-  getActiveTabId(newState);
-
-  // Create a new empty tab
-  const tabId = create$1();
-  const editorUid = create$1();
-  const newTab = {
-    editorType: 'text',
-    editorUid,
-    errorMessage: '',
-    icon: '',
-    id: tabId,
-    isDirty: false,
-    language: 'plaintext',
-    loadingState: 'loading',
-    title: 'Untitled',
-    uri: 'untitled:///1'
-  };
-  const stateWithNewTab = openTab(newState, targetGroupId, newTab);
-
-  // Calculate bounds: use main area bounds minus tab height
-  const bounds = {
-    height: stateWithNewTab.height - stateWithNewTab.tabHeight,
-    width: stateWithNewTab.width,
-    x: stateWithNewTab.x,
-    y: stateWithNewTab.y + stateWithNewTab.tabHeight
-  };
-  const stateWithViewlet = createViewletForTab(stateWithNewTab, tabId);
-  let intermediateState = stateWithViewlet;
-
-  // Switch viewlet (detach old, attach new if ready)
-  const {
-    newState: switchedState
-  } = switchViewlet(intermediateState);
-  intermediateState = switchedState;
-  set(uid, state, intermediateState);
-
-  // Get the tab to extract editorUid
-  const tabWithViewlet = findTabById(intermediateState, tabId);
-  if (!tabWithViewlet) {
-    return intermediateState;
-  }
-  const {
-    editorUid: actualEditorUid
-  } = tabWithViewlet.tab;
-  if (actualEditorUid === -1) {
-    throw new Error(`invalid editorUid`);
-  }
-  await createViewlet('Editor', actualEditorUid, tabId, bounds, newTab.uri || '');
-
-  // After viewlet is created, get the latest state and mark it as ready
-  const {
-    newState: latestState
-  } = get(uid);
-  const readyState = handleViewletReady(latestState, actualEditorUid);
-  return readyState;
-};
-
 const ensureActiveGroup = (state, uri) => {
   // Find the active group (by activeGroupId or focused flag)
   const {
@@ -3114,7 +3204,7 @@ const openUri = async (state, options) => {
   const tabId = getActiveTabId(newState);
 
   // Save state immediately after adding tab
-  set(uid, currentState, newState);
+  set(uid, state, newState);
   const viewletModuleId = await getViewletModuleId(uri);
 
   // After async call, get the latest state to account for any concurrent changes
@@ -3141,7 +3231,7 @@ const openUri = async (state, options) => {
     newState: switchedState
   } = switchViewlet(intermediateState1);
   intermediateState1 = switchedState;
-  set(uid, stateWithViewlet, intermediateState1);
+  set(uid, state, intermediateState1);
 
   // Get the tab to extract editorUid
   const tabWithViewlet = findTabById(intermediateState1, tabId);
@@ -3166,7 +3256,7 @@ const openUri = async (state, options) => {
   const readyState = handleViewletReady(latestState, editorUid);
 
   // Save state before async icon request
-  set(uid, intermediateState1, readyState);
+  set(uid, state, readyState);
 
   // Request file icon for the newly opened tab
   try {
@@ -3199,7 +3289,7 @@ const openUri = async (state, options) => {
       };
 
       // Save the state with icon update so concurrent calls can see it
-      set(uid, stateBeforeIconUpdate, stateWithIcon);
+      set(uid, state, stateWithIcon);
       return stateWithIcon;
     }
   } catch {
@@ -3236,6 +3326,7 @@ const NavigateChild = 7;
 const NavigateParent = 8;
 const RemoveChild = 9;
 const NavigateSibling = 10;
+const SetReferenceNodeUid = 11;
 
 const isKey = key => {
   return key !== 'type' && key !== 'childCount';
@@ -3303,6 +3394,16 @@ const compareNodes = (oldNode, newNode) => {
   if (oldNode.type !== newNode.type) {
     return null;
   }
+  // Handle reference nodes - special handling for uid changes
+  if (oldNode.type === Reference) {
+    if (oldNode.uid !== newNode.uid) {
+      patches.push({
+        type: SetReferenceNodeUid,
+        uid: newNode.uid
+      });
+    }
+    return patches;
+  }
   // Handle text nodes
   if (oldNode.type === Text && newNode.type === Text) {
     if (oldNode.text !== newNode.text) {
@@ -3584,6 +3685,7 @@ const HandleClick = 11;
 const HandleClickClose = 12;
 const HandleClickTab = 13;
 const HandleTabContextMenu = 14;
+const HandleHeaderDoubleClick = 15;
 
 const renderTabActions = (isDirty, tabIndex, groupIndex) => {
   if (isDirty) {
@@ -3683,6 +3785,7 @@ const renderEditorGroupHeader = (group, groupIndex, splitButtonEnabled) => {
   return [{
     childCount: hasActions ? 2 : 1,
     className: 'EditorGroupHeader',
+    onDblClick: HandleHeaderDoubleClick,
     role: 'none',
     type: Div
   }, ...getTabsVirtualDom(group, groupIndex, tabsChildCount), ...actions];
@@ -3716,10 +3819,14 @@ const getMainAreaVirtualDom = (layout, splitButtonEnabled = false) => {
 
 const renderItems = (oldState, newState) => {
   const {
+    initial,
     layout,
     splitButtonEnabled,
     uid
   } = newState;
+  if (initial) {
+    return [SetDom2, uid, []];
+  }
   const dom = getMainAreaVirtualDom(layout, splitButtonEnabled);
   return [SetDom2, uid, dom];
 };
@@ -3781,6 +3888,9 @@ const renderEventListeners = () => {
   }, {
     name: HandleClickAction,
     params: ['handleClickAction', 'event.target.dataset.action', 'event.target.dataset.groupId']
+  }, {
+    name: HandleHeaderDoubleClick,
+    params: ['handleHeaderDoubleClick', 'event.target.className', 'event.target.dataset.groupId']
   }];
 };
 
@@ -3938,9 +4048,14 @@ const commandMap = {
   'MainArea.closeAll': wrapCommand(closeAll$1),
   'MainArea.closeAllEditors': wrapCommand(closeAll$1),
   'MainArea.closeFocusedTab': wrapCommand(closeFocusedTab),
+  'MainArea.closeOthers': wrapCommand(closeOtherTabs),
+  'MainArea.copyPath': wrapCommand(copyPath$1),
+  'MainArea.copyRelativePath': wrapCommand(copyRelativePath$1),
   'MainArea.create': create,
   'MainArea.diff2': diff2,
+  'MainArea.focusNext': wrapCommand(focusNextTab),
   'MainArea.focusNextTab': wrapCommand(focusNextTab),
+  'MainArea.focusPrevious': wrapCommand(focusPreviousTab),
   'MainArea.focusPreviousTab': wrapCommand(focusPreviousTab),
   'MainArea.getCommandIds': getCommandIds,
   'MainArea.getMenuEntries': wrapGetter(getMenuEntries),
@@ -3950,6 +4065,7 @@ const commandMap = {
   'MainArea.handleClickCloseTab': wrapCommand(handleClickCloseTab),
   'MainArea.handleClickTab': wrapCommand(handleClickTab),
   'MainArea.handleDoubleClick': wrapCommand(handleDoubleClick),
+  'MainArea.handleHeaderDoubleClick': wrapCommand(handleHeaderDoubleClick),
   'MainArea.handleModifiedStatusChange': wrapCommand(handleModifiedStatusChange),
   'MainArea.handleResize': wrapCommand(handleResize),
   'MainArea.handleTabContextMenu': wrapCommand(handleTabContextMenu),

package/package.json

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