@lvce-editor/editor-worker 18.19.0 → 18.21.0

package/dist/editorWorkerMain.js

@@ -1296,7 +1296,7 @@ const sendMessagePortToTextMeasurementWorker = async port => {
   const command = 'TextMeasurement.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
 };
-const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+const sendMessagePortToExtensionManagementWorker$1 = async (port, rpcId) => {
   const command = 'Extensions.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
 };
@@ -1321,7 +1321,7 @@ const RendererWorker = {
   readClipBoardText,
   readFile,
   sendMessagePortToExtensionHostWorker,
-  sendMessagePortToExtensionManagementWorker,
+  sendMessagePortToExtensionManagementWorker: sendMessagePortToExtensionManagementWorker$1,
   sendMessagePortToOpenerWorker,
   sendMessagePortToSyntaxHighlightingWorker: sendMessagePortToSyntaxHighlightingWorker$1,
   sendMessagePortToTextMeasurementWorker,
@@ -3794,7 +3794,23 @@ const execute = async ({
   return result;
 };
 
-const executeDiagnosticProvider = editor => {
+const getTextDocument$1 = editor => {
+  return {
+    documentId: editor.id || editor.uid,
+    languageId: editor.languageId,
+    text: getText$1(editor),
+    uri: editor.uri
+  };
+};
+const executeIsolatedDiagnosticProvider = async editor => {
+  const textDocument = getTextDocument$1(editor);
+  return invoke$e('Extensions.executeDiagnosticProvider', textDocument);
+};
+const executeDiagnosticProvider = async editor => {
+  const isolatedDiagnostics = await executeIsolatedDiagnosticProvider(editor);
+  if (isolatedDiagnostics.length > 0) {
+    return isolatedDiagnostics;
+  }
   const {
     assetDir,
     platform
@@ -9348,9 +9364,25 @@ const EditorFindWidget = {
   toggleUseRegularExpression
 };
 
+const getTextDocument = editor => {
+  return {
+    documentId: editor.id || editor.uid,
+    languageId: editor.languageId,
+    text: getText$1(editor),
+    uri: editor.uri
+  };
+};
+const executeIsolatedHoverProvider = async (editor, offset) => {
+  const textDocument = getTextDocument(editor);
+  return invoke$e('Extensions.executeHoverProvider', textDocument, offset);
+};
 const executeHoverProvider = async (editor, offset) => {
   object(editor);
   number(offset);
+  const isolatedHover = await executeIsolatedHoverProvider(editor, offset);
+  if (isolatedHover) {
+    return isolatedHover;
+  }
   return execute({
     args: [offset],
     editor,
@@ -10757,7 +10789,7 @@ const createExtensionManagementWorkerRpc = async () => {
     const rpc = await create$e({
       commandMap: {},
       async send(port) {
-        await sendMessagePortToExtensionManagementWorker(port, EditorWorker);
+        await sendMessagePortToExtensionManagementWorker$1(port, EditorWorker);
       }
     });
     return rpc;
@@ -11250,11 +11282,78 @@ const treeToArray = node => {
   return result;
 };
 
+const navigateToChild = (patches, currentChildIndex, index) => {
+  if (currentChildIndex === -1) {
+    patches.push({
+      type: NavigateChild,
+      index
+    });
+    return index;
+  }
+  if (currentChildIndex !== index) {
+    patches.push({
+      type: NavigateSibling,
+      index
+    });
+  }
+  return index;
+};
+const navigateToParent = (patches, currentChildIndex) => {
+  if (currentChildIndex >= 0) {
+    patches.push({
+      type: NavigateParent
+    });
+  }
+  return -1;
+};
+const addTree = (newNode, patches) => {
+  patches.push({
+    type: Add,
+    nodes: treeToArray(newNode)
+  });
+};
+const replaceTree = (newNode, patches) => {
+  patches.push({
+    type: Replace,
+    nodes: treeToArray(newNode)
+  });
+};
+const diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+    replaceTree(newNode, patches);
+    return nextChildIndex;
+  }
+  const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+  if (nodePatches.length === 0 && !hasChildrenToCompare) {
+    return currentChildIndex;
+  }
+  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (hasChildrenToCompare) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+  return nextChildIndex;
+};
+const diffRootNode = (oldNode, newNode, patches) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    replaceTree(newNode, patches);
+    return;
+  }
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (oldNode.children.length > 0 || newNode.children.length > 0) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+};
 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];
@@ -11263,88 +11362,17 @@ const diffChildren = (oldChildren, newChildren, patches) => {
       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
+      currentChildIndex = navigateToParent(patches, currentChildIndex);
+      addTree(newNode, patches);
+      continue;
+    }
+    if (!newNode) {
       indicesToRemove.push(i);
+      continue;
     }
+    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, i);
   }
-  // Navigate back to parent if we ended at a child
-  if (currentChildIndex >= 0) {
-    patches.push({
-      type: NavigateParent
-    });
-  }
-  // Add remove patches in reverse order (highest index first)
-  // This ensures indices remain valid as we remove
+  navigateToParent(patches, currentChildIndex);
   for (let j = indicesToRemove.length - 1; j >= 0; j--) {
     patches.push({
       type: RemoveChild,
@@ -11353,33 +11381,11 @@ const diffChildren = (oldChildren, newChildren, patches) => {
   }
 };
 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);
+    diffRootNode(oldTree[0], newTree[0], patches);
+    return;
   }
+  diffChildren(oldTree, newTree, patches);
 };
 
 const removeTrailingNavigationPatches = patches => {
@@ -12058,6 +12064,10 @@ const saveState = (state, savedState) => {
   };
 };
 
+const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+  await sendMessagePortToExtensionManagementWorker$1(port, rpcId);
+};
+
 const setDebugEnabled = (state, enabled) => {
   return state;
 };
@@ -12381,7 +12391,8 @@ const commandMap = {
   'Listener.register': registerListener,
   'Listener.registerListener': registerListener$1,
   'Listener.unregister': unregisterListener,
-  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker': sendMessagePortToExtensionHostWorker2
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker': sendMessagePortToExtensionHostWorker2,
+  'SendMessagePortToExtensionManagementWorker.sendMessagePortToExtensionManagementWorker': sendMessagePortToExtensionManagementWorker
 };
 for (const [key, value] of Object.entries(commandMap)) {
   if (key.startsWith('Editor.')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/editor-worker",
-  "version": "18.19.0",
+  "version": "18.21.0",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/editor-worker.git"