@lvce-editor/extension-detail-view 7.2.0 → 7.4.0

package/dist/extensionDetailViewWorkerMain.js

@@ -341,6 +341,7 @@ const None$2 = 0;
 const Web$1 = 1;
 const Electron$1 = 2;
 
+const ClipBoardWorker = 3400;
 const ExtensionHostWorker = 44;
 const ExtensionManagementWorker = 9006;
 const FileSystemWorker$1 = 209;
@@ -437,12 +438,12 @@ const getChildrenWithCount = (nodes, startIndex, childCount) => {
 };
 
 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;
   }
+  const patches = [];
   // Handle reference nodes - special handling for uid changes
   if (oldNode.type === Reference) {
     if (oldNode.uid !== newNode.uid) {
@@ -478,7 +479,7 @@ const compareNodes = (oldNode, newNode) => {
   }
   // Check for removed attributes
   for (const key of oldKeys) {
-    if (!(key in newNode)) {
+    if (!Object.hasOwn(newNode, key)) {
       patches.push({
         type: RemoveAttribute,
         key
@@ -496,11 +497,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];
@@ -509,88 +577,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,
@@ -599,33 +596,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 => {
@@ -865,9 +840,9 @@ const getCellCodeVirtualDom = (value, props) => {
     childCount: 1,
     className: tdClassName,
     type: Td,
-    ...(props?.title ? {
+    ...(props?.title && {
       title: props.title
-    } : {})
+    })
   }, {
     childCount: 1,
     type: Code$2
@@ -903,9 +878,9 @@ const getCellTextVirtualDom = (value, props) => {
     childCount: 1,
     className: tdClassName,
     type: Td,
-    ...(props?.title ? {
+    ...(props?.title && {
       title: props.title
-    } : {})
+    })
   }, text(value)];
 };
 
@@ -1028,10 +1003,7 @@ const isValidRelativePath = value => {
     return false;
   }
   // Must contain at least one alphanumeric character
-  if (!/[A-Za-z0-9]/.test(value)) {
-    return false;
-  }
-  return true;
+  return !!/[A-Za-z0-9]/.test(value);
 };
 const getSchemaLinkUrl = (schema, extensionUri) => {
   if (!schema || typeof schema !== 'string') {
@@ -1048,7 +1020,7 @@ const getSchemaLinkUrl = (schema, extensionUri) => {
     return '';
   }
   try {
-    return new URL(schema, extensionUri).toString();
+    return new URL(schema, extensionUri).href;
   } catch {
     return '';
   }
@@ -2236,7 +2208,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const createRpc = ipc => {
+const createRpc$1 = ipc => {
   const callbacks = Object.create(null);
   ipc._resolve = (id, response) => {
     const fn = callbacks[id];
@@ -2316,7 +2288,7 @@ const create$6 = async ({
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
-  const rpc = createRpc(ipc);
+  const rpc = createRpc$1(ipc);
   messagePort.start();
   return rpc;
 };
@@ -2387,7 +2359,7 @@ const create$3 = async ({
   register(commandMap);
   const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
   handleIpc(ipc);
-  const rpc = createRpc(ipc);
+  const rpc = createRpc$1(ipc);
   return rpc;
 };
 
@@ -2412,7 +2384,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$a = (id, rpc) => {
+const set$b = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$2 = id => {
@@ -2445,7 +2417,7 @@ const create$2 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$a(rpcId, mockRpc);
+      set$b(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -2454,11 +2426,22 @@ const create$2 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$a(rpcId, rpc);
+      set$b(rpcId, rpc);
     }
   };
 };
 
+const {
+  invoke: invoke$6,
+  set: set$a
+} = create$2(ClipBoardWorker);
+const writeText$1 = async text => {
+  return invoke$6('ClipBoard.writeText', text);
+};
+const writeImage = async image => {
+  return invoke$6('ClipBoard.writeImage', image);
+};
+
 const {
   invoke: invoke$5,
   set: set$9
@@ -2541,6 +2524,10 @@ const showContextMenu2 = async (uid, menuId, x, y, args) => {
 const setColorTheme$1 = async id => {
   return invoke$1(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
 };
+const sendMessagePortToClipBoardWorker = async (port, rpcId) => {
+  const command = 'ClipBoard.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToClipBoardWorker', port, command, rpcId);
+};
 const sendMessagePortToMarkdownWorker$1 = async (port, rpcId) => {
   const command = 'Markdown.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
@@ -2557,12 +2544,6 @@ const confirm = async (message, options) => {
   const result = await invoke$1('ConfirmPrompt.prompt', message, options);
   return result;
 };
-const writeClipBoardText = async text => {
-  await invoke$1('ClipBoard.writeText', /* text */text);
-};
-const writeClipBoardImage = async blob => {
-  await invoke$1('ClipBoard.writeImage', /* text */blob);
-};
 const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
   const command = 'Extensions.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
@@ -2594,6 +2575,9 @@ const openExternal$1 = async uri => {
 const openUrl = async uri => {
   await invoke$1('Open.openUrl', uri);
 };
+const getAllPreferences = async () => {
+  return invoke$1('Preferences.getAll');
+};
 
 /* eslint-disable unicorn/prefer-export-from */
 
@@ -2628,10 +2612,7 @@ const featureRuntimeStatusEnabled = extension => {
   if (!extension || typeof extension !== 'object') {
     return false;
   }
-  if ('main' in extension || 'browser' in extension) {
-    return true;
-  }
-  return false;
+  return 'main' in extension || 'browser' in extension;
 };
 
 const formatTime = time => {
@@ -3327,10 +3308,10 @@ const terminate = () => {
 };
 
 const writeClipboardImage = async blob => {
-  await writeClipBoardImage(blob);
+  await writeImage(blob);
 };
 const writeText = async text => {
-  await writeClipBoardText(text);
+  await writeText$1(text);
 };
 
 /* eslint-disable unicorn/prefer-export-from */
@@ -3412,6 +3393,7 @@ const create = (uid, uri, x, y, width, height, platform, assetDir) => {
     changelogVirtualDom: [],
     commands: [],
     commit: '',
+    currentColorThemeId: '',
     description: '',
     detailsVirtualDom: [],
     disabled: false,
@@ -3765,12 +3747,28 @@ const getExtension = async (id, platform) => {
   }
 };
 
+const getColorThemeId = extension => {
+  if (extension && Array.isArray(extension.colorThemes) && extension.colorThemes.length > 0) {
+    const colorTheme = extension.colorThemes[0];
+    return colorTheme.id || colorTheme.label;
+  }
+  return undefined;
+};
+const getColorThemeLabel = extension => {
+  if (extension && Array.isArray(extension.colorThemes) && extension.colorThemes.length > 0) {
+    const colorTheme = extension.colorThemes[0];
+    return colorTheme.label;
+  }
+  return undefined;
+};
+
 const isEnabled$1 = button => {
   return button.enabled;
 };
-const getExtensionDetailButtons = (hasColorTheme, isBuiltin, isDisabled) => {
+const getExtensionDetailButtons = (hasColorTheme, isBuiltin, isDisabled, extensionColorThemeId, extensionColorThemeLabel, currentColorThemeId) => {
+  const isCurrentColorTheme = extensionColorThemeId !== '' && extensionColorThemeId === currentColorThemeId || extensionColorThemeLabel !== '' && extensionColorThemeLabel === currentColorThemeId;
   const allActions = [{
-    enabled: hasColorTheme && !isDisabled,
+    enabled: hasColorTheme && !isDisabled && !isCurrentColorTheme,
     label: setColorTheme$2(),
     name: SetColorTheme,
     onClick: HandleClickSetColorTheme
@@ -3796,6 +3794,7 @@ const getExtensionDetailButtons = (hasColorTheme, isBuiltin, isDisabled) => {
 
 const updateExtensionStatus = async (state, updateFunction) => {
   const {
+    currentColorThemeId,
     extensionId,
     hasColorTheme,
     platform
@@ -3806,7 +3805,10 @@ const updateExtensionStatus = async (state, updateFunction) => {
   }
   const extension = await getExtension(extensionId, platform);
   const disabled = extension?.disabled;
-  const buttons = getExtensionDetailButtons(hasColorTheme, false, disabled);
+  const extensionColorThemeId = getColorThemeId(extension) || '';
+  const extensionColorThemeLabel = getColorThemeLabel(extension) || '';
+  const isBuiltin = extension?.isBuiltin || extension?.builtin || false;
+  const buttons = getExtensionDetailButtons(hasColorTheme, isBuiltin, disabled, extensionColorThemeId, extensionColorThemeLabel, currentColorThemeId);
   return {
     ...state,
     buttons,
@@ -3875,14 +3877,6 @@ const handleClickScrollToTop = state => {
   };
 };
 
-const getColorThemeId = extension => {
-  if (extension && Array.isArray(extension.colorThemes) && extension.colorThemes.length > 0) {
-    const colorTheme = extension.colorThemes[0];
-    return colorTheme.id || colorTheme.label;
-  }
-  return undefined;
-};
-
 const setColorTheme = id => {
   return setColorTheme$1(id);
 };
@@ -3897,6 +3891,14 @@ const handleClickSetColorTheme = async state => {
     if (error) {
       await confirm(`${error}`);
     }
+    const isBuiltin = extension?.isBuiltin || extension?.builtin || false;
+    const colorThemeLabel = getColorThemeLabel(extension) || '';
+    const buttons = getExtensionDetailButtons(state.hasColorTheme, isBuiltin, state.disabled, colorThemeId, colorThemeLabel, colorThemeId);
+    return {
+      ...state,
+      buttons,
+      currentColorThemeId: colorThemeId
+    };
   }
   return state;
 };
@@ -3961,6 +3963,41 @@ const getCommit = async () => {
   }
 };
 
+const getThemeFromPreferences = preferences => {
+  if (!preferences || typeof preferences !== 'object') {
+    return '';
+  }
+  const workbenchTheme = preferences['workbench.colorTheme'];
+  if (typeof workbenchTheme === 'string') {
+    return workbenchTheme;
+  }
+  const legacyTheme = preferences['workbnech.colorTheme'];
+  if (typeof legacyTheme === 'string') {
+    return legacyTheme;
+  }
+  return '';
+};
+const getCurrentColorTheme = async () => {
+  const setting = await getPreference('workbench.colorTheme');
+  if (typeof setting === 'string' && setting) {
+    return setting;
+  }
+  try {
+    const preferences = await getAllPreferences();
+    const theme = getThemeFromPreferences(preferences);
+    if (theme) {
+      return theme;
+    }
+  } catch {
+    // ignore and fall back to legacy key lookup
+  }
+  const legacySetting = await getPreference('workbnech.colorTheme');
+  if (typeof legacySetting === 'string') {
+    return legacySetting;
+  }
+  return '';
+};
+
 const getExtensionIdFromUri = uri => {
   const id = uri.slice('extension-detail://'.length);
   return id;
@@ -4606,6 +4643,7 @@ const loadContent = async (state, platform, savedState, isTest = false) => {
   if (!extension) {
     throw new ExtensionNotFoundError(id);
   }
+  const currentColorThemeId = await getCurrentColorTheme();
   const commit = await getCommit();
   const headerData = loadHeaderContent(state, platform, extension);
   const {
@@ -4639,7 +4677,9 @@ const loadContent = async (state, platform, savedState, isTest = false) => {
   });
   const isBuiltin = extension?.isBuiltin;
   const disabled = extension?.disabled;
-  const buttons = getExtensionDetailButtons(hasColorTheme, isBuiltin, disabled);
+  const extensionColorThemeId = getColorThemeId(extension) || '';
+  const extensionColorThemeLabel = getColorThemeLabel(extension) || '';
+  const buttons = getExtensionDetailButtons(hasColorTheme, isBuiltin, disabled, extensionColorThemeId, extensionColorThemeLabel, currentColorThemeId);
   const size = getViewletSize(width);
   const {
     changelogScrollTop,
@@ -4674,6 +4714,7 @@ const loadContent = async (state, platform, savedState, isTest = false) => {
     categories,
     changelogScrollTop,
     commit,
+    currentColorThemeId,
     description,
     detailsVirtualDom,
     disabled,
@@ -5021,6 +5062,20 @@ const hideSizeLink = state => {
   };
 };
 
+const createRpc = async () => {
+  const rpc = await create$4({
+    commandMap: {},
+    send: async port => {
+      await sendMessagePortToClipBoardWorker(port, 0);
+    }
+  });
+  return rpc;
+};
+const initializeClipBoardWorker = async () => {
+  const rpc = await createRpc();
+  set$a(rpc);
+};
+
 const sendMessagePortToExtensionHostWorker = async port => {
   await sendMessagePortToExtensionHostWorker$1(port, 0);
 };
@@ -5089,15 +5144,11 @@ const sendMessagePortToMarkdownWorker = async port => {
 };
 
 const createMarkdownWorkerRpc = async () => {
-  try {
-    const rpc = await create$4({
-      commandMap: {},
-      send: sendMessagePortToMarkdownWorker
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create markdown worker rpc`);
-  }
+  const rpc = await create$4({
+    commandMap: {},
+    send: sendMessagePortToMarkdownWorker
+  });
+  return rpc;
 };
 
 const initializeMarkdownWorker = async () => {
@@ -5107,7 +5158,7 @@ const initializeMarkdownWorker = async () => {
 
 const initialize = async () => {
   // TODO load markdown worker only when needed
-  await Promise.all([initializeMarkdownWorker(), initializeFileSystemWorker(), initializeExtensionHostWorker(), initializeExtensionManagementWorker()]);
+  await Promise.all([initializeMarkdownWorker(), initializeFileSystemWorker(), initializeExtensionHostWorker(), initializeExtensionManagementWorker(), initializeClipBoardWorker()]);
 };
 
 const loadContent2 = async (state, savedState, isTest = false) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-detail-view",
-  "version": "7.2.0",
+  "version": "7.4.0",
   "description": "Extension Detail View Worker",
   "repository": {
     "type": "git",